package pl.wat.ms4ds.terrain.konwersja;

import pl.wat.ms4ds.terrain.Coord;
import pl.wat.ms4ds.terrain.Teren;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.HashMap;
import javax.xml.stream.*;

/**
 *
 */
public class OpenStreetMapReader {
    private static final Logger LOGGER = LoggerFactory.getLogger(OpenStreetMapReader.class);

    private static final String DATA_DIR = "c:/Workspace/openstreetmap-data-20160925/";

    static final Object synch = new Object();

    public static void main(String[] args) throws Exception {
        System.out.println("OpenStreetMapReader - Working Directory = " +
                System.getProperty("user.dir"));
        String osm_fn = DATA_DIR + args[0] + "-latest.osm";
        HashMap<String, Relation> relationsMap = new HashMap<>(8000);
        HashMap<String, Way> relationWaysMap = new HashMap<>(50000);
        HashMap<String, Node> nodesMap = new HashMap<>(5000000);
        HashMap<String, Node> buildingNodesMap = new HashMap<>(500000);
        HashMap<String, Way> waysMap = new HashMap<>(800000);
        String[] goals = {"lasy", "wody", "bagna", "zabudowa", "drogi", "rzeki", "rowy"};
        ArrayList<String> toDo = new ArrayList<>();
        for (int i = 1; i < args.length; i++) {
            for (int j = 0; j < goals.length; j++) {
                if (goals[j].equals(args[i])) {
                    toDo.add(goals[j]);
                    break;
                }
            }
        }
        MapBounds mapBounds = new MapBounds();
//        readMapBounds(mapBounds, osm_fn);
        for (int i = 0; i < toDo.size(); i++) {
            relationsMap.clear();
            relationWaysMap.clear();
            nodesMap.clear();
            buildingNodesMap.clear();
            waysMap.clear();
            readRelations(relationsMap, relationWaysMap, osm_fn, toDo.get(i));
            readWays(nodesMap, relationWaysMap, waysMap, osm_fn, toDo.get(i));
            readNodes(nodesMap, buildingNodesMap, mapBounds, osm_fn, toDo.get(i));
            if (nodesMap.size() > 0) {
                String nodes_poland_fn = DATA_DIR + "poland-latest_nodes.osm";
                readNodes(nodesMap, null, mapBounds, nodes_poland_fn, toDo.get(i));
            }
            for (Relation rel : relationsMap.values()) {
                rel.outerWays = rel.generatePolygons(rel.outerWays);
                rel.innerWays = rel.generatePolygons(rel.innerWays);
            }
            LOGGER.debug("Poczatek przetwarzania danych dla regionu " + osm_fn + " - cel: " + toDo.get(i));
            generujDaneTerenowe(toDo.get(i), relationsMap, waysMap, buildingNodesMap);
            LOGGER.debug("Koniec przetwarzania danych dla regionu " + osm_fn + " - cel: " + toDo.get(i));
//            Teren.setBinarnyFormatPliku(false);
//            Teren.zapisBuforaMapyDoPliku();
//            Teren.reset();
//                Teren.setBinarnyFormatPliku(true);
        }
        LOGGER.debug("Poczatek zapisu danych dla regionu " + osm_fn);
        Teren.saveToFiles(null);
        LOGGER.debug("Koniec zapisu danych dla regionu " + osm_fn);
    }


    //        XMLOutputFactory outFactory = XMLOutputFactory.newInstance();
//
//        try {
//            XMLStreamWriter writer = outFactory.createXMLStreamWriter(new FileWriter("au2data\\output2.xml"));
//
//            writer.writeStartDocument();
//            writer.writeStartElement("document");
//            writer.writeStartElement("data");
//            writer.writeAttribute("name", "value");
//            writer.writeEndElement();
//            writer.writeEndElement();
//            writer.writeEndDocument();
//
//            writer.flush();
//            writer.close();
//
//        } catch (XMLStreamException e) {
//            e.printStackTrace();
//        } catch (IOException e) {
//            e.printStackTrace();
//        }

    private static void readMapBounds(MapBounds mapBounds, String fn) throws Exception {
        XMLInputFactory factory = XMLInputFactory.newInstance();
//        FileInputStream is = new FileInputStream(fn);
        FileInputStream is = new FileInputStream(fn);
//        XMLStreamReader reader = factory.createXMLStreamReader(ClassLoader.getSystemResourceAsStream(fn));
        XMLStreamReader reader = factory.createXMLStreamReader(is);
        String val;
        while (reader.hasNext()) {
            int eventType = reader.next();
            switch (eventType) {
                case XMLStreamConstants.START_ELEMENT:
                    if ("bounds".equals(reader.getLocalName())) {
                        for (int i = 0; i < reader.getAttributeCount(); i++) {
                            val = reader.getAttributeLocalName(i);
                            switch (val) {
                                case "minlat":
                                    val = reader.getAttributeValue(i);
                                    mapBounds.minLat = Double.parseDouble(val);
                                    break;
                                case "minlon":
                                    val = reader.getAttributeValue(i);
                                    mapBounds.minLon = Double.parseDouble(val);
                                    break;
                                case "maxlat":
                                    val = reader.getAttributeValue(i);
                                    mapBounds.maxLat = Double.parseDouble(val);
                                    break;
                                case "maxlon":
                                    val = reader.getAttributeValue(i);
                                    mapBounds.maxLon = Double.parseDouble(val);
                                    break;
                                default:
                            }
                        }
                        reader.close();
                        return;
                    }
                    break;

                default:
                    break;
            }
        }
        reader.close();
    }

    private static void readNodes(HashMap<String, Node> nodesMap, HashMap<String, Node> buildingNodesMap, MapBounds mapBounds, String fn, String genGoal) throws Exception {
        Node currNode = null;
        XMLInputFactory factory = XMLInputFactory.newInstance();
        FileInputStream is = new FileInputStream(fn);
//        XMLStreamReader reader = factory.createXMLStreamReader(ClassLoader.getSystemResourceAsStream(fn));
        XMLStreamReader reader = factory.createXMLStreamReader(is);
        String val;
        int count = 1;
        LOGGER.debug("Poczatek odczytu wezlow z pliku: " + fn);
        while (reader.hasNext()) {
            int eventType = reader.next();
            switch (eventType) {
                case XMLStreamConstants.START_ELEMENT:
                    if ("node".equals(reader.getLocalName())) {
                        val = reader.getAttributeValue(0);
//                        if ("3206180317".equals(val)) {
//                            logger.debug("!!!!!!!!!!! niepoprawny wezel id= " + val);
//                        }
                        if (count % 100000 == 0) {
                            LOGGER.debug("+-+-+-+-+-+-+-+- liczba odczytanych wezlow= " + count / 1000 + " [tys.], ostatni wezel id= " + val);
                        }
                        currNode = nodesMap.remove(val);
                        if (!"zabudowa".equals(genGoal)) {
                            if (currNode != null) {
                                int c = 0;
                                for (int i = 1; i < reader.getAttributeCount() && c < 2; i++) {
                                    val = reader.getAttributeLocalName(i);
                                    switch (val) {
                                        case "lat":
                                            val = reader.getAttributeValue(i);
                                            currNode.lat = Double.parseDouble(val);
                                            c++;
                                            break;
                                        case "lon":
                                            val = reader.getAttributeValue(i);
                                            currNode.lon = Double.parseDouble(val);
                                            c++;
                                            break;
                                        default:
                                    }
                                }
                            }
                        } else if (buildingNodesMap != null) {
                            if (currNode == null) {
                                currNode = buildingNodesMap.get(val);
                                if (currNode == null) {
                                    currNode = new Node(val);
                                }
                            }
                            int c = 0;
                            for (int i = 1; i < reader.getAttributeCount() && c < 2; i++) {
                                val = reader.getAttributeLocalName(i);
                                switch (val) {
                                    case "lat":
                                        val = reader.getAttributeValue(i);
                                        currNode.lat = Double.parseDouble(val);
                                        c++;
                                        break;
                                    case "lon":
                                        val = reader.getAttributeValue(i);
                                        currNode.lon = Double.parseDouble(val);
                                        c++;
                                        break;
                                    default:
                                }
                            }
                        }
                    } else if ("tag".equals(reader.getLocalName())) {
                        if (currNode != null) {
                            String k = reader.getAttributeValue(0);
                            String v = reader.getAttributeValue(1);
                            switch (k) {
                                case "building":
                                    currNode.building = EOSMBuilding.getValue(v);
                                    break;
                                case "amenity":
                                    currNode.amenity = EOSMAmenity.getValue(v);
                                    break;
                                case "addr:housenumber":
                                    currNode.buildingsCount++;
                                    break;
                                default:
                                    break;
                            }
                        }
                    } else if ("way".equals(reader.getLocalName())) {
                        reader.close();
                        return;
                    }
                    break;

                case XMLStreamConstants.CHARACTERS:
//                        tagContent = reader.getText().trim();
                    break;

                case XMLStreamConstants.END_ELEMENT:
                    switch (reader.getLocalName()) {
                        case "node":
                            if (currNode != null) {
                                currNode.idX = Coord.zamienDlugoscGeoNaIdKwadratuX(currNode.lon);
                                currNode.idY = Coord.zamienSzerokoscGeoNaIdKwadratuY(currNode.lat);
                                if ("zabudowa".equals(genGoal) && currNode.buildingsCount > 0) {
                                    buildingNodesMap.put(currNode.id, currNode);
                                }
                                count++;
                                currNode = null;
                            }
                            break;
                        default:
                            break;
                    }
                    break;

                default:
                    break;
            }
        }
        reader.close();
    }

    private static void readWays(HashMap<String, Node> nodesMap, HashMap<String, Way> relationWaysMap,
                                 HashMap<String, Way> goalWaysMap, String fn, String genGoal) throws Exception {
        Way currWay = null;
        String tagContent = null;
        XMLInputFactory factory = XMLInputFactory.newInstance();
//        FileInputStream is = new FileInputStream(fn);
        FileInputStream is = new FileInputStream(fn);
//        XMLStreamReader reader = factory.createXMLStreamReader(ClassLoader.getSystemResourceAsStream(fn));
        XMLStreamReader reader = factory.createXMLStreamReader(is);
        String val;
        int count = 0;
        LOGGER.debug("Poczatek odczytu lamanych z pliku: " + fn + " - cel: " + genGoal);
        while (reader.hasNext()) {
            int eventType = reader.next();
            switch (eventType) {
                case XMLStreamConstants.START_ELEMENT:
                    if ("way".equals(reader.getLocalName())) {
                        val = reader.getAttributeValue(0);
                        currWay = relationWaysMap.get(val);
                        if (currWay == null) {
                            currWay = new Way(val);
                        }
//                        if ("314575560".equals(val)) {
//                            logger.debug("!!!!!");
//                        }
                        count++;
                        if (count % 10000 == 0) {
                            LOGGER.debug("=================== liczba odczytanych lamanych= " + count / 1000 + " [tys.], ostatnia lamana id= " + val);
                            LOGGER.debug("=>liczba lamanych celu=" + goalWaysMap.size() + ", liczba lamanych relacji=" + relationWaysMap.size() + ", liczba wezlow=" + nodesMap.size());
                        }
                    } else if ("nd".equals(reader.getLocalName())) {
                        if (currWay != null) {
                            // odczyt id wezla wchodzacego w sklad lamanej
                            val = reader.getAttributeValue(0);
                            Node node = nodesMap.get(val);
                            if (node == null) {
                                for (int i = 0; i < currWay.nodes.size(); i++) {
                                    if (val.equals(currWay.nodes.get(i).id)) {
                                        node = currWay.nodes.get(i);
                                        break;
                                    }
                                }
                                if (node == null) {
                                    node = new Node(val);
                                }
                            }
                            currWay.nodes.add(node);
                        }
                    } else if ("tag".equals(reader.getLocalName())) {
                        if (currWay != null) {
                            String k = reader.getAttributeValue(0);
                            String v = reader.getAttributeValue(1);
                                switch (k) {
                                    case "highway":
                                        currWay.highway = EOSMHighway.getValue(v);
                                        break;
                                    case "waterway":
                                        currWay.waterway = EOSMWaterway.getValue(v);
                                        break;
                                    case "natural":
                                        currWay.natural = EOSMNatural.getValue(v);
                                        break;
                                    case "water":
                                        currWay.water = EOSMWater.getValue(v);
                                        break;
                                    case "landuse":
                                        currWay.landuse = EOSMLanduse.getValue(v);
                                        break;
                                    case "landcover":
                                        currWay.landcover = EOSMLandcover.getValue(v);
                                        break;
                                    case "bridge":
                                        currWay.bridge = EOSMBridge.getValue(v);
                                        break;
                                    case "building":
                                        currWay.building = EOSMBuilding.getValue(v);
                                        break;
                                    case "amenity":
                                        currWay.amenity = EOSMAmenity.getValue(v);
                                        break;
                                    default:
                                        break;
                                }
                        }
                    }
                    break;

                case XMLStreamConstants.CHARACTERS:
//                        tagContent = reader.getText().trim();
                    break;

                case XMLStreamConstants.END_ELEMENT:
                    if (currWay != null) {
                        switch (reader.getLocalName()) {
                            case "way":
                                if ("lasy".equals(genGoal)) {
//                                LASY
                                    if (relationWaysMap.containsKey(currWay.id)) {
                                        for (Node node : currWay.nodes) {
                                            nodesMap.put(node.id, node);
                                        }
                                    } else if ((currWay.landuse != null) && currWay.landuse == EOSMLanduse.FOREST) {
                                        goalWaysMap.put(currWay.id, currWay);
                                        for (Node node : currWay.nodes) {
                                            nodesMap.put(node.id, node);
                                        }
                                    } else if ((currWay.landcover != null) && currWay.landcover == EOSMLandcover.TREES) {
                                        goalWaysMap.put(currWay.id, currWay);
                                        for (Node node : currWay.nodes) {
                                            nodesMap.put(node.id, node);
                                        }
                                    } else if ((currWay.natural != null) && currWay.natural == EOSMNatural.WOOD) {
                                        goalWaysMap.put(currWay.id, currWay);
                                        for (Node node : currWay.nodes) {
                                            nodesMap.put(node.id, node);
                                        }
                                    }
                                } else if ("wody".equals(genGoal)) {
//                                SZEROKIE RZEKI, JEZIORA I ZBIORNIKI WODNE
                                    if (relationWaysMap.containsKey(currWay.id)) {
                                        for (Node node : currWay.nodes) {
                                            nodesMap.put(node.id, node);
                                        }
                                    } else if (currWay.natural != null && currWay.natural == EOSMNatural.WATER) {
                                        goalWaysMap.put(currWay.id, currWay);
                                        for (Node node : currWay.nodes) {
                                            nodesMap.put(node.id, node);
                                        }
                                    } else if (currWay.waterway != null && currWay.waterway == EOSMWaterway.RIVERBANK) {
                                        goalWaysMap.put(currWay.id, currWay);
                                        for (Node node : currWay.nodes) {
                                            nodesMap.put(node.id, node);
                                        }
                                    }
                                } else if ("drogi".equals(genGoal)) {
//                                DROGI
                                    if (currWay.highway != null) {
                                        switch (currWay.highway) {
                                            case MOTORWAY:
                                            case TRUNCK:
                                            case PRIMARY:
                                            case SECONDARY:
                                            case TERTIARY:
                                            case UNCLASSIFIED:
                                            case RESIDENTIAL:
                                            case PEDESTRIAN:
                                            case TRACK:
                                            case MOTORWAY_LINK:
                                            case TRUNCK_LINK:
                                            case PRIMARY_LINK:
                                            case SECONDARY_LINK:
                                            case TERTIARY_LINK:
                                            case SERVICE:
                                            case LIVING_STREET:
                                                goalWaysMap.put(currWay.id, currWay);
                                                for (Node node : currWay.nodes) {
                                                    nodesMap.put(node.id, node);
                                                }
                                                break;
                                            default:
//                                        case "footway":
//                                        case "bridleway":
//                                        case "steps":
//                                        case "cycleway":
//                                        case "PATH":
//                                        case "proposed":
                                                break;
                                        }
                                    }
                                } else if ("rzeki".equals(genGoal)) {
//                                RZEKI (LINIOWE, NIESZEROKIE)
                                    if (currWay.waterway != null) {
                                        switch (currWay.waterway) {
                                            case RIVER:
                                            case CANAL:
                                                goalWaysMap.put(currWay.id, currWay);
                                                for (Node node : currWay.nodes) {
                                                    nodesMap.put(node.id, node);
                                                }
                                                break;
                                            default:
                                        }
                                    }
                                } else if ("rowy".equals(genGoal)) {
//                            ROWY
                                    if (currWay.waterway != null) {
                                        switch (currWay.waterway) {
                                            case STREAM:
                                            case DRAIN:
                                            case DITCH:
                                                goalWaysMap.put(currWay.id, currWay);
                                                for (Node node : currWay.nodes) {
                                                    nodesMap.put(node.id, node);
                                                }
                                                break;
                                            default:
                                        }
                                    }
                                } else if ("bagna".equals(genGoal)) {
//                                BAGNA
                                    if (currWay.natural != null) {
                                        switch (currWay.natural) {
                                            case WETLAND:
                                                goalWaysMap.put(currWay.id, currWay);
                                                for (Node node : currWay.nodes) {
                                                    nodesMap.put(node.id, node);
                                                }
                                                break;
                                            default:
                                        }
                                    }
                                } else if ("zabudowa".equals(genGoal)) {
//                                ZABUDOWA
                                    if (currWay.landuse != null) {
                                        switch (currWay.landuse) {
                                            case RESIDENTIAL:
                                            case COMMERCIAL:
                                                goalWaysMap.put(currWay.id, currWay);
                                                for (Node node : currWay.nodes) {
                                                    nodesMap.put(node.id, node);
                                                }
                                                break;
                                            default:
                                        }
                                    } else if (currWay.building != null) {
                                        goalWaysMap.put(currWay.id, currWay);
                                        for (Node node : currWay.nodes) {
                                            nodesMap.put(node.id, node);
                                        }
                                    } else if (currWay.amenity != null) {
                                        switch (currWay.amenity) {
                                            case HOSPITAL:
                                            case CLINIC:
                                            case POST_OFFICE:
                                            case POLICE:
                                            case FIRE_STATION:
                                            case MARKETPLACE:
                                                goalWaysMap.put(currWay.id, currWay);
                                                for (Node node : currWay.nodes) {
                                                    nodesMap.put(node.id, node);
                                                }
                                                break;
                                            default:
                                        }
                                    }
                                }
                                currWay = null;
                                break;
                            default:
                                break;
                        }
                    }
                    break;

                default:
            }
        }
        reader.close();
    }

    private static void readRelations(HashMap<String, Relation> relationsMap, HashMap<String, Way> relationWaysMap,
                                      String fn, String genGoal) throws Exception {
        Relation currRelation = null;
        String tagContent = null;
        if (!("lasy".equals(genGoal)) && !("wody".equals(genGoal))) {
            return;
        }
//        fn += "-latest_relations.osm";
        XMLInputFactory factory = XMLInputFactory.newInstance();
//        XMLStreamReader reader = factory.createXMLStreamReader(ClassLoader.getSystemResourceAsStream(fn));
//        BufferedInputStream inputStream = new BufferedInputStream(new FileInputStream(fn));
//        XMLStreamReader reader = factory.createXMLStreamReader(inputStream);

        FileInputStream is = new FileInputStream(fn);
//        XMLStreamReader reader = factory.createXMLStreamReader(ClassLoader.getSystemResourceAsStream(fn));
        XMLStreamReader reader = factory.createXMLStreamReader(is);

        String val;
        int count = 0;
        LOGGER.debug("Poczatek odczytu relacji z pliku: " + fn + " - cel: " + genGoal);
        while (reader.hasNext()) {
            int eventType = reader.next();
            switch (eventType) {
                case XMLStreamConstants.START_ELEMENT:
                    if ("relation".equals(reader.getLocalName())) {
                        val = reader.getAttributeValue(0);
                        currRelation = new Relation(val);
                        count++;
                        if (count % 1000 == 0) {
                            LOGGER.debug("+-+-+-+-+-+-+-+- liczba odczytanych relacji= " + count / 1000 + " [tys.], ostatnia relacja id= " + val);
                        }
                    } else if ("member".equals(reader.getLocalName())) {
                        if (currRelation != null) {
                            String v = reader.getAttributeValue(0);
                            if ("way".equals(v)) {
                                // identyfikator łamanej
                                String v1 = reader.getAttributeValue(1);
                                // rola łamanej w relacji
                                String v2 = reader.getAttributeValue(2);
                                if ("outer".equals(v2)) {
                                    Way way = new Way(v1);
                                    if (way != null) {
                                        currRelation.outerWays.add(way);
                                    }
                                } else if ("inner".equals(v2)) {
                                    Way way = new Way(v1);
                                    if (way != null) {
                                        currRelation.innerWays.add(way);
                                    }
                                }
                            }
                        }
                    } else if ("tag".equals(reader.getLocalName())) {
                        if (currRelation != null) {
                            String k = reader.getAttributeValue(0);
                            String v = reader.getAttributeValue(1);
                            switch (k) {
                                case "waterway":
                                    currRelation.waterway = EOSMWaterway.getValue(v);
                                    break;
                                case "natural":
                                    currRelation.natural = EOSMNatural.getValue(v);
                                    break;
                                case "landuse":
                                    currRelation.landuse = EOSMLanduse.getValue(v);
                                    break;
                                case "landcover":
                                    currRelation.landcover = EOSMLandcover.getValue(v);
                                    break;
                                case "type":
                                    if (!"multipolygon".equals(v)) {
                                        currRelation = null;
                                    }
                                    break;
                                default:
                                    break;
                            }
                        }
                    }
                    break;

                case XMLStreamConstants.CHARACTERS:
//                        tagContent = reader.getText().trim();
                    break;

                case XMLStreamConstants.END_ELEMENT:
                    switch (reader.getLocalName()) {
                        case "relation":
                            if (currRelation != null) {
                                if (currRelation.outerWays.size() > 0) {
                                    if ("lasy".equals(genGoal)) {
                                        if (((currRelation.landuse != null) && currRelation.landuse == EOSMLanduse.FOREST)
                                                || ((currRelation.natural != null) && currRelation.natural == EOSMNatural.WOOD)) {

                                            relationsMap.put(currRelation.id, currRelation);
                                            for (Way way : currRelation.outerWays) {
                                                // kopiuje tagi dla lamanych zewnetrznych
                                                way.copyTags(currRelation);
                                                relationWaysMap.put(way.id, way);
                                            }
                                            for (Way way : currRelation.innerWays) {
                                                relationWaysMap.put(way.id, way);
                                                // nie kopiuje tagow dla lamanych wewnetrznych, gdyz one maja wlasne tagi
                                            }
                                        }
                                    } else if ("wody".equals(genGoal)) {
                                        if (((currRelation.natural != null) && currRelation.natural == EOSMNatural.WATER)
                                                || ((currRelation.waterway != null) && currRelation.waterway == EOSMWaterway.RIVERBANK)) {

                                            relationsMap.put(currRelation.id, currRelation);
                                            for (Way way : currRelation.outerWays) {
                                                // kopiuje tagi dla lamanych zewnetrznych
                                                way.copyTags(currRelation);
                                                relationWaysMap.put(way.id, way);
                                            }
                                            for (Way way : currRelation.innerWays) {
                                                relationWaysMap.put(way.id, way);
                                                // nie kopiuje tagow dla lamanych wewnetrznych, gdyz one maja wlasne tagi
                                            }
                                        }
                                    }
                                }
                            }
                            currRelation = null;
                            break;
                        default:
                            break;
                    }
                    break;

                default:
                    break;
            }
        }
        reader.close();
    }

    static void generujDaneTerenowe(String genGoal, HashMap<String, Relation> relationsMap,
                                    HashMap<String, Way> waysMap, HashMap<String, Node> buildingNodesMap) {
        int count = 0;
        int m1 = relationsMap.size() / 100;
        m1 = (m1 == 0) ? 1 : m1;
        int m2 = waysMap.size() / 100;
        m2 = (m2 == 0) ? 1 : m2;
        ArrayList<Way> wayList = new ArrayList<>(waysMap.values());
        // określenie formatu odczytu danych terenowych przed uaktualnieniem
        if ("lasy".equals(genGoal)) {
            for (Relation rel : relationsMap.values()) {
                count++;
                rel.removeLastNodes();
                rel.removeSimilarNodes();
                rel.removeCollinearNodes(true);
                rel.writeAreaFeatureIntoSquares(EAreaFeature.FOREST);
                if (count % m1 == 0) {
                    LOGGER.debug(">><<>><<>><<: rel count= " + count + ", " + genGoal);
                }
            }
            count = 0;
            for (Way way : wayList) {
                count++;
                // usunięcie powtórzenia węzła z łamanej definiującej obszar
                if (way.nodes.size() > 1) {
                    way.nodes.remove(way.nodes.size() - 1);
                }
                way.removeSimilarNodes();
                way.removeCollinearNodes(true);
                way.writeAreaFeatureIntoSquares(EAreaFeature.FOREST, false);
                if (count % m2 == 0) {
                    LOGGER.debug("<><><><><><>: way count= " + count + ", " + genGoal);
                }
            }
        } else if ("wody".equals(genGoal)) {
            for (Relation rel : relationsMap.values()) {
                count++;
                rel.removeLastNodes();
                rel.removeSimilarNodes();
                rel.removeCollinearNodes(true);
                rel.writeAreaFeatureIntoSquares(EAreaFeature.WATER);
                if (count % m1 == 0) {
                    LOGGER.debug(">><<>><<>><<: rel count= " + count + ", " + genGoal);
                }
            }
            count = 0;
            for (Way way : wayList) {
                count++;
                // usunięcie powtórzenia węzła z łamanej definiującej obszar
                if (way.nodes.size() > 1) {
                    way.nodes.remove(way.nodes.size() - 1);
                }
                way.removeSimilarNodes();
                way.removeCollinearNodes(true);
                way.writeAreaFeatureIntoSquares(EAreaFeature.WATER, false);
                if (count % m2 == 0) {
                    LOGGER.debug("<><><><><><>: way count= " + count + ", " + genGoal);
                }
            }
        } else if ("bagna".equals(genGoal)) {
            for (Way way : wayList) {
                count++;
                // usunięcie powtórzenia węzła z łamanej definiującej obszar
                if (way.nodes.size() > 1) {
                    way.nodes.remove(way.nodes.size() - 1);
                }
                way.removeSimilarNodes();
                way.removeCollinearNodes(true);
                way.writeAreaFeatureIntoSquares(EAreaFeature.SWAMP, false);
                if (count % m2 == 0) {
                    LOGGER.debug("<><><><><><>: way count= " + count + ", " + genGoal);
                }
            }
        } else if ("zabudowa".equals(genGoal)) {
            // wygenerowanie danych o stopniu zabudowy na podstawie danych adresowych
//            HashMap<Node, Node> newNodesMap = new HashMap<>();
//            for (Node node : buildingNodesMap.values()) {
//                Node node1 = newNodesMap.get(node);
//                if (node1 != null) {
//                    node1.buildingsCount += node.buildingsCount;
//                } else {
//                    newNodesMap.put(node, node);
//                }
//            }
//            buildingNodesMap.clear();

            for (Node node : buildingNodesMap.values()) {
                node.writeAreaFeatureIntoSquare(EAreaFeature.BUILDINGS);
            }
            for (Way way : wayList) {
                count++;
                // usunięcie powtórzenia węzła z łamanej definiującej obszar
                if (way.nodes.size() > 1) {
                    way.nodes.remove(way.nodes.size() - 1);
                }
//                for (int i = 0; i < way.nodes.size(); i++) {
//                    Node node = way.nodes.get(i);
//                    if (node.idX <= 0 || node.idY <= 0) {
//                        logger.debug("!!!! niepoprawny wezel id= " + node.id + ", lamana id= " + way.id);
//                    }
//                }
                way.removeSimilarNodes();
                way.removeCollinearNodes(true);
                way.writeAreaFeatureIntoSquares(EAreaFeature.BUILDINGS, false);
                if (count % m2 == 0) {
                    LOGGER.debug("<><><><><><>: way count= " + count + ", " + genGoal);
                }
            }
        } else if ("drogi".equals(genGoal)) {
            for (Way way : wayList) {
                count++;
//                if ("249908111".equals(way.id) || "238353558".equals(way.id)) {
//                    logger.debug("!!!!!");
//                }
                way.removeSimilarNodes();
                way.removeCollinearNodes(false);
                way.removeSteps();
                if (way.nodes.size() > 1) {
                    way.writeLinearFeatureIntoSquares(ELinearFeature.ROAD);
                }
//                if (count % 10000 == 0) {
//                    logger.debug("-*-*-*-*-");
//                    logger.debug("maxMemory=" + java.lang.Runtime.getRuntime().maxMemory()
//                            + ", totalMemory=" + java.lang.Runtime.getRuntime().totalMemory()
//                            + ", freeMemory=" + java.lang.Runtime.getRuntime().freeMemory());
//                }
//                count++;
                if (count % m2 == 0) {
                    LOGGER.debug("<><><><><><>: way count= " + count + ", " + genGoal);
                }
            }
        } else if ("rzeki".equals(genGoal)) {
            for (Way way : wayList) {
                count++;
                way.removeSimilarNodes();
                way.removeCollinearNodes(false);
                way.removeSteps();
                if (way.nodes.size() > 1) {
                    way.writeLinearFeatureIntoSquares(ELinearFeature.WATER_WAY);
                }
                if (count % m2 == 0) {
                    LOGGER.debug("<><><><><><>: way count= " + count + ", " + genGoal);
                }
            }
        } else if ("rowy".equals(genGoal)) {
            for (Way way : wayList) {
                count++;
                way.removeSimilarNodes();
                way.removeCollinearNodes(false);
                way.removeSteps();
                if (way.nodes.size() > 1) {
                    way.writeLinearFeatureIntoSquares(ELinearFeature.DITCH);
                }
                if (count % m2 == 0) {
                    LOGGER.debug("<><><><><><>: way count= " + count + ", " + genGoal);
                }
            }
        }
    }

    static void generujDaneTerenowe2(String genGoal, HashMap<String, Relation> relationsMap,
                                     HashMap<String, Way> waysMap, HashMap<String, Node> buildingNodesMap) {
        int count = 0;
        int m1 = relationsMap.size() / 100;
        m1 = (m1 == 0) ? 1 : m1;
        ArrayList<Way> wayList = new ArrayList<>(waysMap.values());
        // określenie formatu odczytu danych terenowych przed uaktualnieniem
        if ("lasy".equals(genGoal)) {
            for (Relation rel : relationsMap.values()) {
                count++;
                rel.removeLastNodes();
                rel.removeSimilarNodes();
                rel.removeCollinearNodes(true);
                rel.writeAreaFeatureIntoSquares(EAreaFeature.FOREST);
                if (count % m1 == 0) {
                    synchronized (synch) {
                        LOGGER.debug(Thread.currentThread().getName() + " >><<>><<>><<: rel count= " + count + ", " + genGoal);
                    }
                }
            }
            count = 0;
            for (Way way : wayList) {
                count++;
                // usunięcie powtórzenia węzła z łamanej definiującej obszar
                if (way.nodes.size() > 1) {
                    way.nodes.remove(way.nodes.size() - 1);
                }
                way.removeSimilarNodes();
                way.removeCollinearNodes(true);
                way.writeAreaFeatureIntoSquares(EAreaFeature.FOREST, false);
                synchronized (synch) {
                    LOGGER.debug(Thread.currentThread().getName() + " <><><><><><>: way count= " + count + ", " + genGoal);
                }
            }
        } else if ("wody".equals(genGoal)) {
            for (Relation rel : relationsMap.values()) {
                count++;
                rel.removeLastNodes();
                rel.removeSimilarNodes();
                rel.removeCollinearNodes(true);
                rel.writeAreaFeatureIntoSquares(EAreaFeature.WATER);
                synchronized (synch) {
                    LOGGER.debug(Thread.currentThread().getName() + " >><<>><<>><<: rel count= " + count + ", " + genGoal);
                }
            }
            count = 0;
            for (Way way : wayList) {
                count++;
                // usunięcie powtórzenia węzła z łamanej definiującej obszar
                if (way.nodes.size() > 1) {
                    way.nodes.remove(way.nodes.size() - 1);
                }
                way.removeSimilarNodes();
                way.removeCollinearNodes(true);
                way.writeAreaFeatureIntoSquares(EAreaFeature.WATER, false);
                synchronized (synch) {
                    LOGGER.debug(Thread.currentThread().getName() + " <><><><><><>: way count= " + count + ", " + genGoal);
                }
            }
        } else if ("bagna".equals(genGoal)) {
            for (Way way : wayList) {
                count++;
                // usunięcie powtórzenia węzła z łamanej definiującej obszar
                if (way.nodes.size() > 1) {
                    way.nodes.remove(way.nodes.size() - 1);
                }
                way.removeSimilarNodes();
                way.removeCollinearNodes(true);
                way.writeAreaFeatureIntoSquares(EAreaFeature.SWAMP, false);
                synchronized (synch) {
                    LOGGER.debug(Thread.currentThread().getName() + " <><><><><><>: way count= " + count + ", " + genGoal);
                }
            }
        } else if ("zabudowa".equals(genGoal)) {
            // wygenerowanie danych o stopniu zabudowy na podstawie danych adresowych
//            HashMap<Node, Node> newNodesMap = new HashMap<>();
//            for (Node node : buildingNodesMap.values()) {
//                Node node1 = newNodesMap.get(node);
//                if (node1 != null) {
//                    node1.buildingsCount += node.buildingsCount;
//                } else {
//                    newNodesMap.put(node, node);
//                }
//            }
//            buildingNodesMap.clear();

            for (Node node : buildingNodesMap.values()) {
                node.writeAreaFeatureIntoSquare(EAreaFeature.BUILDINGS);
            }
            for (Way way : wayList) {
                count++;
                // usunięcie powtórzenia węzła z łamanej definiującej obszar
                if (way.nodes.size() > 1) {
                    way.nodes.remove(way.nodes.size() - 1);
                }
//                for (int i = 0; i < way.nodes.size(); i++) {
//                    Node node = way.nodes.get(i);
//                    if (node.idX <= 0 || node.idY <= 0) {
//                        logger.debug("!!!! niepoprawny wezel id= " + node.id + ", lamana id= " + way.id);
//                    }
//                }
                way.removeSimilarNodes();
                way.removeCollinearNodes(true);
                way.writeAreaFeatureIntoSquares(EAreaFeature.BUILDINGS, false);
                synchronized (synch) {
                    LOGGER.debug(Thread.currentThread().getName() + " <><><><><><>: way count= " + count + ", " + genGoal);
                }
            }
        } else if ("drogi".equals(genGoal)) {
            for (Way way : wayList) {
                count++;
//                if ("249908111".equals(way.id) || "238353558".equals(way.id)) {
//                    logger.debug("!!!!!");
//                }
                way.removeSimilarNodes();
                way.removeCollinearNodes(false);
                way.removeSteps();
                if (way.nodes.size() > 1) {
                    way.writeLinearFeatureIntoSquares(ELinearFeature.ROAD);
                }
//                if (count % 10000 == 0) {
//                    logger.debug("-*-*-*-*-");
//                    logger.debug("maxMemory=" + java.lang.Runtime.getRuntime().maxMemory()
//                            + ", totalMemory=" + java.lang.Runtime.getRuntime().totalMemory()
//                            + ", freeMemory=" + java.lang.Runtime.getRuntime().freeMemory());
//                }
//                count++;
                synchronized (synch) {
                    LOGGER.debug(Thread.currentThread().getName() + " <><><><><><>: way count= " + count + ", " + genGoal);
                }
            }
        } else if ("rzeki".equals(genGoal)) {
            for (Way way : wayList) {
                count++;
                way.removeSimilarNodes();
                way.removeCollinearNodes(false);
                way.removeSteps();
                if (way.nodes.size() > 1) {
                    way.writeLinearFeatureIntoSquares(ELinearFeature.WATER_WAY);
                }
                synchronized (synch) {
                    LOGGER.debug(Thread.currentThread().getName() + " <><><><><><>: way count= " + count + ", " + genGoal);
                }
            }
        } else if ("rowy".equals(genGoal)) {
            for (Way way : wayList) {
                count++;
                way.removeSimilarNodes();
                way.removeCollinearNodes(false);
                way.removeSteps();
                if (way.nodes.size() > 1) {
                    way.writeLinearFeatureIntoSquares(ELinearFeature.DITCH);
                }
                synchronized (synch) {
                    LOGGER.debug(Thread.currentThread().getName() + " <><><><><><>: way count= " + count + ", " + genGoal);
                }
            }
        }
    }

}