/**********************************************************************

 *

 * GEOS - Geometry Engine Open Source

 * http://geos.osgeo.org

 *

 * Copyright (C) 2021 Jared Erickson

 *

 * This is free software; you can redistribute and/or modify it under

 * the terms of the GNU Lesser General Public Licence as published

 * by the Free Software Foundation.

 * See the COPYING file for more information.

 *

 **********************************************************************/

#include <geos/io/GeoJSONReader.h>

#include <geos/util/IllegalArgumentException.h>

#include <geos/io/ParseException.h>

#include <geos/geom/Coordinate.h>

#include <geos/geom/Point.h>

#include <geos/geom/LinearRing.h>

#include <geos/geom/LineString.h>

#include <geos/geom/Polygon.h>

#include <geos/geom/MultiPoint.h>

#include <geos/geom/MultiLineString.h>

#include <geos/geom/MultiPolygon.h>

#include <geos/geom/CoordinateSequence.h>

#include <geos/geom/PrecisionModel.h>

#include <geos/util.h>

#include <algorithm>

#include <ostream>

#include <sstream>

#include <cassert>

#define PROJ_COMPILATION

using namespace geos::geom;

using json = geos_nlohmann::json;

namespace geos {

namespace io { // geos.io

GeoJSONReader::GeoJSONReader(): GeoJSONReader(*(GeometryFactory::getDefaultInstance())) {}

GeoJSONReader::GeoJSONReader(const geom::GeometryFactory& gf) : geometryFactory(gf) {}

std::unique_ptr<geom::Geometry> GeoJSONReader::read(const std::string& geoJsonText) const

{

    try {

        const json& j = json::parse(geoJsonText);

        const std::string& type = j.at("type");

        if (type == "Feature") {

            return readFeatureForGeometry(j);

        }

        else if (type == "FeatureCollection") {

            return readFeatureCollectionForGeometry(j);

        }

        else {

            return readGeometry(j);

        }

    }

    catch (json::exception& ex) {

        throw ParseException("Error parsing JSON", ex.what());

    }

}

GeoJSONFeatureCollection GeoJSONReader::readFeatures(const std::string& geoJsonText) const

{

    try {

        const json& j = json::parse(geoJsonText);

        const std::string& type = j.at("type");

        if (type == "Feature") {

            const auto& feature = readFeature(j);

            return GeoJSONFeatureCollection { std::vector<GeoJSONFeature>{feature} };

        }

        else if (type == "FeatureCollection") {

            return readFeatureCollection(j);

        }

        else {

            auto g = readGeometry(j);

            return GeoJSONFeatureCollection { std::vector<GeoJSONFeature>{GeoJSONFeature{std::move(g), std::map<std::string, GeoJSONValue>{} }}};

        }

    }

    catch (json::exception& ex) {

        throw ParseException("Error parsing JSON", ex.what());

    }

}

std::unique_ptr<geom::Geometry> GeoJSONReader::readFeatureForGeometry(

    const geos_nlohmann::json& j) const

{

    const auto& geometryJson = j.at("geometry");

    auto geometry = readGeometry(geometryJson);

    return geometry;

}

GeoJSONFeature GeoJSONReader::readFeature(const geos_nlohmann::json& j) const

{

    const auto& geometryJson = j.at("geometry");

    const auto& properties = j.at("properties");

    std::string id = "";

    if (j.contains("id") && !j.at("id").is_null()) {

        if (j.at("id").is_string()) id = j.at("id").get<std::string>();

        if (j.at("id").is_number()) id = j.at("id").dump();

    }

    return GeoJSONFeature{readGeometry(geometryJson), readProperties(properties), id};

}

std::map<std::string, GeoJSONValue> GeoJSONReader::readProperties(

    const geos_nlohmann::json& p) const

{

    std::map<std::string, GeoJSONValue> map;

    for (const auto& prop : p.items()) {

        map[prop.key()] = std::move(readProperty(prop.value()));

    }

    return map;

}

GeoJSONValue GeoJSONReader::readProperty(

    const geos_nlohmann::json& value) const

{

    if (value.is_string()) {

        return GeoJSONValue { value.get<std::string>() };

    }

    else if (value.is_number()) {

        return GeoJSONValue { value.get<double>() };

    }

    else if (value.is_boolean()) {

        return GeoJSONValue { value.get<bool>() };

    }

    else if (value.is_array()) {

        std::vector<GeoJSONValue> v {};

        v.reserve(value.size());

        for (const auto& el : value.items()) {

            v.push_back(readProperty(el.value()));

        }

        return GeoJSONValue{ v };

    }

    else if (value.is_object()) {

        std::map<std::string, GeoJSONValue> v {};

        for (const auto& el : value.items()) {

            v[el.key()] = std::move(readProperty(el.value()));

        }

        return GeoJSONValue{ v };

    }

    else {

        return GeoJSONValue{};

    }

}

std::unique_ptr<geom::Geometry> GeoJSONReader::readFeatureCollectionForGeometry(

    const geos_nlohmann::json& j) const

{

    const auto& featuresJson = j.at("features");

    std::vector<std::unique_ptr<geom::Geometry>> geometries;

    geometries.reserve(featuresJson.size());

    for (const auto& featureJson : featuresJson) {

        auto g = readFeatureForGeometry(featureJson);

        geometries.push_back(std::move(g));

    }

    return geometryFactory.createGeometryCollection(std::move(geometries));

}

GeoJSONFeatureCollection GeoJSONReader::readFeatureCollection(

    const geos_nlohmann::json& j) const

{

    const auto& featuresJson = j.at("features");

    std::vector<GeoJSONFeature> features;

    features.reserve(featuresJson.size());

    for (const auto& featureJson : featuresJson) {

        features.push_back(readFeature(featureJson));

    }

    return GeoJSONFeatureCollection{std::move(features)};

}

std::unique_ptr<geom::Geometry> GeoJSONReader::readGeometry(

    const geos_nlohmann::json& j) const

{

    const std::string& type = j.at("type");

    if (type == "Point") {

        return readPoint(j);

    }

    else if (type == "LineString") {

        return readLineString(j);

    }

    else if (type == "Polygon") {

        return readPolygon(j);

    }

    else if (type == "MultiPoint") {

        return readMultiPoint(j);

    }

    else if (type == "MultiLineString") {

        return readMultiLineString(j);

    }

    else if (type == "MultiPolygon") {

        return readMultiPolygon(j);

    }

    else if (type == "GeometryCollection") {

        return readGeometryCollection(j);

    }

    else {

        throw ParseException{"Unknown geometry type!"};

    }

}

geom::Coordinate GeoJSONReader::readCoordinate(

    const std::vector<double>& coords) const

{

    if (coords.size() == 1) {

        throw  ParseException("Expected two or three coordinates found one");

    }

    else if (coords.size() == 2) {

        return geom::Coordinate { coords[0], coords[1] };

    }

    else if (coords.size() == 3) {

        return geom::Coordinate { coords[0], coords[1], coords[2] };

    }

    else {

        throw  ParseException("Expected two or three coordinates found more than three");

    }

}

std::unique_ptr<geom::Point> GeoJSONReader::readPoint(

    const geos_nlohmann::json& j) const

{

    const auto& coords = j.at("coordinates").get<std::vector<double>>();

    if (coords.size() == 1) {

        throw  ParseException("Expected two or three coordinates found one");

    }

    else if (coords.size() < 2) {

        return geometryFactory.createPoint(2);

    }

    else {

        const geom::Coordinate& coord = readCoordinate(coords);

        return std::unique_ptr<geom::Point>(geometryFactory.createPoint(coord));

    }

}

std::unique_ptr<geom::LineString> GeoJSONReader::readLineString(

    const geos_nlohmann::json& j) const

{

    const auto& coords = j.at("coordinates").get<std::vector<std::vector<double>>>();

    bool has_z = std::any_of(coords.begin(), coords.end(), [](auto v) { return v.size() > 2; });

    auto coordinates = detail::make_unique<CoordinateSequence>(0u, has_z, false);

    coordinates->reserve(coords.size());

    for (const auto& coord : coords) {

        const geom::Coordinate& c = readCoordinate(coord);

        coordinates->add(c);

    }

    return geometryFactory.createLineString(std::move(coordinates));

}

std::unique_ptr<geom::Polygon> GeoJSONReader::readPolygon(

    const geos_nlohmann::json& j) const

{

    const auto& polygonCoords = j.at("coordinates").get<std::vector<std::vector<std::vector<double>>>>();

    return readPolygon(polygonCoords);

}

std::unique_ptr<geom::Polygon> GeoJSONReader::readPolygon(

    const std::vector<std::vector<std::vector<double>>>& polygonCoords) const

{

    std::unique_ptr<geom::LinearRing> shell;

    std::vector<std::unique_ptr<geom::LinearRing>> rings;

    rings.reserve(polygonCoords.size());

    for (const auto& ring : polygonCoords) {

        bool has_z = std::any_of(ring.begin(), ring.end(), [](auto v) { return v.size() > 2; });

        auto coordinates = detail::make_unique<CoordinateSequence>(0u, has_z, false);

        coordinates->reserve(ring.size());

        for (const auto& coord : ring) {

            const geom::Coordinate& c = readCoordinate(coord);

            coordinates->add(c);

        }

        if (!shell) {

            shell = geometryFactory.createLinearRing(std::move(coordinates));

        }

        else {

            rings.push_back(geometryFactory.createLinearRing(std::move(coordinates)));

        }

    }

    if (!shell) {

        return geometryFactory.createPolygon(2);

    }

    else if (rings.size() == 0) {

        return geometryFactory.createPolygon(std::move(shell));

    }

    else {

        return geometryFactory.createPolygon(std::move(shell), std::move(rings));

    }

}

std::unique_ptr<geom::MultiPoint> GeoJSONReader::readMultiPoint(

    const geos_nlohmann::json& j) const

{

    const auto& coords = j.at("coordinates").get<std::vector<std::vector<double>>>();

    std::vector<std::unique_ptr<geom::Point>> points;

    points.reserve(coords.size());

    for (const auto& coord : coords) {

        const geom::Coordinate& c = readCoordinate(coord);

        points.push_back(std::unique_ptr<geom::Point>(geometryFactory.createPoint(c)));

    }

    return geometryFactory.createMultiPoint(std::move(points));

}

std::unique_ptr<geom::MultiLineString> GeoJSONReader::readMultiLineString(

    const geos_nlohmann::json& j) const

{

    const auto& listOfCoords = j.at("coordinates").get<std::vector<std::vector<std::vector<double>>>>();

    std::vector<std::unique_ptr<geom::LineString>> lines;

    lines.reserve(listOfCoords.size());

    for (const auto& coords :  listOfCoords) {

        bool has_z = std::any_of(coords.begin(), coords.end(), [](auto v) { return v.size() > 2; });

        auto coordinates = detail::make_unique<geom::CoordinateSequence>(0u, has_z, false);

        coordinates->reserve(coords.size());

        for (const auto& coord : coords) {

            const geom::Coordinate& c = readCoordinate(coord);

            coordinates->add(c);

        }

        lines.push_back(geometryFactory.createLineString(std::move(coordinates)));

    }

    return geometryFactory.createMultiLineString(std::move(lines));

}

std::unique_ptr<geom::MultiPolygon> GeoJSONReader::readMultiPolygon(

    const geos_nlohmann::json& j) const

{

    const auto& multiPolygonCoords = j.at("coordinates").get<std::vector<std::vector<std::vector<std::vector<double>>>>>();

    std::vector<std::unique_ptr<geom::Polygon>> polygons;

    polygons.reserve(multiPolygonCoords.size());

    for (const auto& polygonCoords : multiPolygonCoords) {

        polygons.push_back(readPolygon(polygonCoords));

    }

    return geometryFactory.createMultiPolygon(std::move(polygons));

}

std::unique_ptr<geom::GeometryCollection> GeoJSONReader::readGeometryCollection(

    const geos_nlohmann::json& j) const

{

    const auto& jsonGeometries = j.at("geometries");

    std::vector<std::unique_ptr<geom::Geometry>> geometries;

    geometries.reserve(jsonGeometries.size());

    for (const auto& jsonGeometry : jsonGeometries) {

        auto g = readGeometry(jsonGeometry);

        geometries.push_back(std::move(g));

    }

    return geometryFactory.createGeometryCollection(std::move(geometries));

}

} // namespace geos.io

} // namespace geos