// SPDX-License-Identifier: MIT

// Copyright 2024, Even Rouault <even.rouault at spatialys.com>

/*! @cond Doxygen_Suppress */

#include "ogresrijsongeometry.h"

#include "ogrlibjsonutils.h"

#include "ogr_geometry.h"

#include "ogr_spatialref.h"

static OGRPoint *OGRESRIJSONReadPoint(json_object *poObj);

static OGRGeometry *OGRESRIJSONReadLineString(json_object *poObj);

static OGRGeometry *OGRESRIJSONReadPolygon(json_object *poObj);

static OGRMultiPoint *OGRESRIJSONReadMultiPoint(json_object *poObj);

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

/*                      OGRESRIJSONReadGeometry()                       */

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

OGRGeometry *OGRESRIJSONReadGeometry(json_object *poObj)

{

    OGRGeometry *poGeometry = nullptr;

    if (OGRGeoJSONFindMemberByName(poObj, "x"))

        poGeometry = OGRESRIJSONReadPoint(poObj);

    else if (OGRGeoJSONFindMemberByName(poObj, "paths"))

        poGeometry = OGRESRIJSONReadLineString(poObj);

    else if (OGRGeoJSONFindMemberByName(poObj, "rings"))

        poGeometry = OGRESRIJSONReadPolygon(poObj);

    else if (OGRGeoJSONFindMemberByName(poObj, "points"))

        poGeometry = OGRESRIJSONReadMultiPoint(poObj);

    return poGeometry;

}

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

/*                  OGR_G_CreateGeometryFromEsriJson()                  */

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

/** Create a OGR geometry from a ESRIJson geometry object */

OGRGeometryH OGR_G_CreateGeometryFromEsriJson(const char *pszJson)

{

    if (nullptr == pszJson)

    {

        // Translation failed.

        return nullptr;

    }

    json_object *poObj = nullptr;

    if (!OGRJSonParse(pszJson, &poObj))

        return nullptr;

    OGRGeometry *poGeometry = OGRESRIJSONReadGeometry(poObj);

    // Release JSON tree.

    json_object_put(poObj);

    return OGRGeometry::ToHandle(poGeometry);

}

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

/*                         OGRESRIJSONGetType()                         */

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

OGRwkbGeometryType OGRESRIJSONGetGeometryType(json_object *poObj)

{

    if (nullptr == poObj)

        return wkbUnknown;

    json_object *poObjType = OGRGeoJSONFindMemberByName(poObj, "geometryType");

    if (nullptr == poObjType)

    {

        return wkbNone;

    }

    const char *name = json_object_get_string(poObjType);

    if (EQUAL(name, "esriGeometryPoint"))

        return wkbPoint;

    else if (EQUAL(name, "esriGeometryPolyline"))

        return wkbLineString;

    else if (EQUAL(name, "esriGeometryPolygon"))

        return wkbPolygon;

    else if (EQUAL(name, "esriGeometryMultiPoint"))

        return wkbMultiPoint;

    else

        return wkbUnknown;

}

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

/*                  OGRESRIJSONGetCoordinateToDouble()                  */

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

static double OGRESRIJSONGetCoordinateToDouble(json_object *poObjCoord,

                                               const char *pszCoordName,

                                               bool &bValid)

{

    const int iType = json_object_get_type(poObjCoord);

    if (json_type_double != iType && json_type_int != iType)

    {

        CPLError(CE_Failure, CPLE_AppDefined,

                 "Invalid '%s' coordinate. "

                 "Type is not double or integer for \'%s\'.",

                 pszCoordName, json_object_to_json_string(poObjCoord));

        bValid = false;

        return 0.0;

    }

    return json_object_get_double(poObjCoord);

}

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

/*                      OGRESRIJSONGetCoordinate()                      */

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

static double OGRESRIJSONGetCoordinate(json_object *poObj,

                                       const char *pszCoordName, bool &bValid)

{

    json_object *poObjCoord = OGRGeoJSONFindMemberByName(poObj, pszCoordName);

    if (nullptr == poObjCoord)

    {

        CPLError(CE_Failure, CPLE_AppDefined,

                 "Invalid Point object. "

                 "Missing '%s' member.",

                 pszCoordName);

        bValid = false;

        return 0.0;

    }

    return OGRESRIJSONGetCoordinateToDouble(poObjCoord, pszCoordName, bValid);

}

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

/*                        OGRESRIJSONReadPoint()                        */

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

OGRPoint *OGRESRIJSONReadPoint(json_object *poObj)

{

    CPLAssert(nullptr != poObj);

    bool bValid = true;

    const double dfX = OGRESRIJSONGetCoordinate(poObj, "x", bValid);

    const double dfY = OGRESRIJSONGetCoordinate(poObj, "y", bValid);

    if (!bValid)

        return nullptr;

    json_object *poObjZ = OGRGeoJSONFindMemberByName(poObj, "z");

    if (nullptr == poObjZ)

        return new OGRPoint(dfX, dfY);

    const double dfZ = OGRESRIJSONGetCoordinateToDouble(poObjZ, "z", bValid);

    if (!bValid)

        return nullptr;

    return new OGRPoint(dfX, dfY, dfZ);

}

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

/*                      OGRESRIJSONReaderParseZM()                      */

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

static void OGRESRIJSONReaderParseZM(json_object *poObj, bool *bHasZ,

                                     bool *bHasM)

{

    CPLAssert(nullptr != poObj);

    // The ESRI geojson spec states that geometries other than point can

    // have the attributes hasZ and hasM.  A geometry that has a z value

    // implies the 3rd number in the tuple is z.  if hasM is true, but hasZ

    // is not, it is the M value.

    bool bZ = false;

    json_object *poObjHasZ = OGRGeoJSONFindMemberByName(poObj, "hasZ");

    if (poObjHasZ != nullptr)

    {

        if (json_object_get_type(poObjHasZ) == json_type_boolean)

        {

            bZ = CPL_TO_BOOL(json_object_get_boolean(poObjHasZ));

        }

    }

    bool bM = false;

    json_object *poObjHasM = OGRGeoJSONFindMemberByName(poObj, "hasM");

    if (poObjHasM != nullptr)

    {

        if (json_object_get_type(poObjHasM) == json_type_boolean)

        {

            bM = CPL_TO_BOOL(json_object_get_boolean(poObjHasM));

        }

    }

    if (bHasZ != nullptr)

        *bHasZ = bZ;

    if (bHasM != nullptr)

        *bHasM = bM;

}

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

/*                  OGRESRIJSONReaderParseXYZMArray()                   */

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

static bool OGRESRIJSONReaderParseXYZMArray(json_object *poObjCoords,

                                            bool /*bHasZ*/, bool bHasM,

                                            double *pdfX, double *pdfY,

                                            double *pdfZ, double *pdfM,

                                            int *pnNumCoords)

{

    if (poObjCoords == nullptr)

    {

        CPLDebug("ESRIJSON",

                 "OGRESRIJSONReaderParseXYZMArray: got null object.");

        return false;

    }

    if (json_type_array != json_object_get_type(poObjCoords))

    {

        CPLDebug("ESRIJSON",

                 "OGRESRIJSONReaderParseXYZMArray: got non-array object.");

        return false;

    }

    const auto coordDimension = json_object_array_length(poObjCoords);

    // Allow 4 coordinates if M is present, but it is eventually ignored.

    if (coordDimension < 2 || coordDimension > 4)

    {

        CPLDebug("ESRIJSON",

                 "OGRESRIJSONReaderParseXYZMArray: got an unexpected "

                 "array object.");

        return false;

    }

    // Read X coordinate.

    json_object *poObjCoord = json_object_array_get_idx(poObjCoords, 0);

    if (poObjCoord == nullptr)

    {

        CPLDebug("ESRIJSON",

                 "OGRESRIJSONReaderParseXYZMArray: got null object.");

        return false;

    }

    bool bValid = true;

    const double dfX =

        OGRESRIJSONGetCoordinateToDouble(poObjCoord, "x", bValid);

    // Read Y coordinate.

    poObjCoord = json_object_array_get_idx(poObjCoords, 1);

    if (poObjCoord == nullptr)

    {

        CPLDebug("ESRIJSON",

                 "OGRESRIJSONReaderParseXYZMArray: got null object.");

        return false;

    }

    const double dfY =

        OGRESRIJSONGetCoordinateToDouble(poObjCoord, "y", bValid);

    if (!bValid)

        return false;

    // Read Z or M or Z and M coordinates.

    if (coordDimension > 2)

    {

        poObjCoord = json_object_array_get_idx(poObjCoords, 2);

        if (poObjCoord == nullptr)

        {

            CPLDebug("ESRIJSON",

                     "OGRESRIJSONReaderParseXYZMArray: got null object.");

            return false;

        }

        const double dfZorM = OGRESRIJSONGetCoordinateToDouble(

            poObjCoord, (coordDimension > 3 || !bHasM) ? "z" : "m", bValid);

        if (!bValid)

            return false;

        if (pdfZ != nullptr)

        {

            if (coordDimension > 3 || !bHasM)

                *pdfZ = dfZorM;

            else

                *pdfZ = 0.0;

        }

        if (pdfM != nullptr && coordDimension == 3)

        {

            if (bHasM)

                *pdfM = dfZorM;

            else

                *pdfM = 0.0;

        }

        if (coordDimension == 4)

        {

            poObjCoord = json_object_array_get_idx(poObjCoords, 3);

            if (poObjCoord == nullptr)

            {

                CPLDebug("ESRIJSON",

                         "OGRESRIJSONReaderParseXYZMArray: got null object.");

                return false;

            }

            const double dfM =

                OGRESRIJSONGetCoordinateToDouble(poObjCoord, "m", bValid);

            if (!bValid)

                return false;

            if (pdfM != nullptr)

                *pdfM = dfM;

        }

    }

    else

    {

        if (pdfZ != nullptr)

            *pdfZ = 0.0;

        if (pdfM != nullptr)

            *pdfM = 0.0;

    }

    if (pnNumCoords != nullptr)

        *pnNumCoords = static_cast<int>(coordDimension);

    if (pdfX != nullptr)

        *pdfX = dfX;

    if (pdfY != nullptr)

        *pdfY = dfY;

    return true;

}

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

/*                     OGRESRIJSONReadLineString()                      */

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

OGRGeometry *OGRESRIJSONReadLineString(json_object *poObj)

{

    CPLAssert(nullptr != poObj);

    bool bHasZ = false;

    bool bHasM = false;

    OGRESRIJSONReaderParseZM(poObj, &bHasZ, &bHasM);

    json_object *poObjPaths = OGRGeoJSONFindMemberByName(poObj, "paths");

    if (nullptr == poObjPaths)

    {

        CPLError(CE_Failure, CPLE_AppDefined,

                 "Invalid LineString object. "

                 "Missing \'paths\' member.");

        return nullptr;

    }

    if (json_type_array != json_object_get_type(poObjPaths))

    {

        CPLError(CE_Failure, CPLE_AppDefined,

                 "Invalid LineString object. "

                 "Invalid \'paths\' member.");

        return nullptr;

    }

    OGRMultiLineString *poMLS = nullptr;

    OGRGeometry *poRet = nullptr;

    const auto nPaths = json_object_array_length(poObjPaths);

    for (auto iPath = decltype(nPaths){0}; iPath < nPaths; iPath++)

    {

        json_object *poObjPath = json_object_array_get_idx(poObjPaths, iPath);

        if (poObjPath == nullptr ||

            json_type_array != json_object_get_type(poObjPath))

        {

            delete poRet;

            CPLDebug("ESRIJSON", "LineString: got non-array object.");

            return nullptr;

        }

        OGRLineString *poLine = new OGRLineString();

        if (nPaths > 1)

        {

            if (iPath == 0)

            {

                poMLS = new OGRMultiLineString();

                poRet = poMLS;

            }

            poMLS->addGeometryDirectly(poLine);

        }

        else

        {

            poRet = poLine;

        }

        const auto nPoints = json_object_array_length(poObjPath);

        for (auto i = decltype(nPoints){0}; i < nPoints; i++)

        {

            int nNumCoords = 2;

            json_object *poObjCoords = json_object_array_get_idx(poObjPath, i);

            double dfX = 0.0;

            double dfY = 0.0;

            double dfZ = 0.0;

            double dfM = 0.0;

            if (!OGRESRIJSONReaderParseXYZMArray(poObjCoords, bHasZ, bHasM,

                                                 &dfX, &dfY, &dfZ, &dfM,

                                                 &nNumCoords))

            {

                delete poRet;

                return nullptr;

            }

            if (nNumCoords == 3 && !bHasM)

            {

                poLine->addPoint(dfX, dfY, dfZ);

            }

            else if (nNumCoords == 3)

            {

                poLine->addPointM(dfX, dfY, dfM);

            }

            else if (nNumCoords == 4)

            {

                poLine->addPoint(dfX, dfY, dfZ, dfM);

            }

            else

            {

                poLine->addPoint(dfX, dfY);

            }

        }

    }

    if (poRet == nullptr)

        poRet = new OGRLineString();

    return poRet;

}

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

/*                       OGRESRIJSONReadPolygon()                       */

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

OGRGeometry *OGRESRIJSONReadPolygon(json_object *poObj)

{

    CPLAssert(nullptr != poObj);

    bool bHasZ = false;

    bool bHasM = false;

    OGRESRIJSONReaderParseZM(poObj, &bHasZ, &bHasM);

    json_object *poObjRings = OGRGeoJSONFindMemberByName(poObj, "rings");

    if (nullptr == poObjRings)

    {

        CPLError(CE_Failure, CPLE_AppDefined,

                 "Invalid Polygon object. "

                 "Missing \'rings\' member.");

        return nullptr;

    }

    if (json_type_array != json_object_get_type(poObjRings))

    {

        CPLError(CE_Failure, CPLE_AppDefined,

                 "Invalid Polygon object. "

                 "Invalid \'rings\' member.");

        return nullptr;

    }

    const auto nRings = json_object_array_length(poObjRings);

    std::vector<std::unique_ptr<OGRGeometry>> apoGeoms;

    apoGeoms.reserve(nRings);

    for (auto iRing = decltype(nRings){0}; iRing < nRings; iRing++)

    {

        json_object *poObjRing = json_object_array_get_idx(poObjRings, iRing);

        if (poObjRing == nullptr ||

            json_type_array != json_object_get_type(poObjRing))

        {

            CPLDebug("ESRIJSON", "Polygon: got non-array object.");

            return nullptr;

        }

        auto poLine = std::make_unique<OGRLinearRing>();

        const auto nPoints = json_object_array_length(poObjRing);

        for (auto i = decltype(nPoints){0}; i < nPoints; i++)

        {

            int nNumCoords = 2;

            json_object *poObjCoords = json_object_array_get_idx(poObjRing, i);

            double dfX = 0.0;

            double dfY = 0.0;

            double dfZ = 0.0;

            double dfM = 0.0;

            if (!OGRESRIJSONReaderParseXYZMArray(poObjCoords, bHasZ, bHasM,

                                                 &dfX, &dfY, &dfZ, &dfM,

                                                 &nNumCoords))

            {

                return nullptr;

            }

            if (nNumCoords == 3 && !bHasM)

            {

                poLine->addPoint(dfX, dfY, dfZ);

            }

            else if (nNumCoords == 3)

            {

                poLine->addPointM(dfX, dfY, dfM);

            }

            else if (nNumCoords == 4)

            {

                poLine->addPoint(dfX, dfY, dfZ, dfM);

            }

            else

            {

                poLine->addPoint(dfX, dfY);

            }

        }

        auto poPoly = std::make_unique<OGRPolygon>();

        poPoly->addRing(std::move(poLine));

        apoGeoms.push_back(std::move(poPoly));

    }

    return OGRGeometryFactory::organizePolygons(apoGeoms).release();

}

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

/*                     OGRESRIJSONReadMultiPoint()                      */

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

OGRMultiPoint *OGRESRIJSONReadMultiPoint(json_object *poObj)

{

    CPLAssert(nullptr != poObj);

    bool bHasZ = false;

    bool bHasM = false;

    OGRESRIJSONReaderParseZM(poObj, &bHasZ, &bHasM);

    json_object *poObjPoints = OGRGeoJSONFindMemberByName(poObj, "points");

    if (nullptr == poObjPoints)

    {

        CPLError(CE_Failure, CPLE_AppDefined,

                 "Invalid MultiPoint object. "

                 "Missing \'points\' member.");

        return nullptr;

    }

    if (json_type_array != json_object_get_type(poObjPoints))

    {

        CPLError(CE_Failure, CPLE_AppDefined,

                 "Invalid MultiPoint object. "

                 "Invalid \'points\' member.");

        return nullptr;

    }

    OGRMultiPoint *poMulti = new OGRMultiPoint();

    const auto nPoints = json_object_array_length(poObjPoints);

    for (auto i = decltype(nPoints){0}; i < nPoints; i++)

    {

        int nNumCoords = 2;

        json_object *poObjCoords = json_object_array_get_idx(poObjPoints, i);

        double dfX = 0.0;

        double dfY = 0.0;

        double dfZ = 0.0;

        double dfM = 0.0;

        if (!OGRESRIJSONReaderParseXYZMArray(poObjCoords, bHasZ, bHasM, &dfX,

                                             &dfY, &dfZ, &dfM, &nNumCoords))

        {

            delete poMulti;

            return nullptr;

        }

        if (nNumCoords == 3 && !bHasM)

        {

            poMulti->addGeometryDirectly(new OGRPoint(dfX, dfY, dfZ));

        }

        else if (nNumCoords == 3)

        {

            OGRPoint *poPoint = new OGRPoint(dfX, dfY);

            poPoint->setM(dfM);

            poMulti->addGeometryDirectly(poPoint);

        }

        else if (nNumCoords == 4)

        {

            poMulti->addGeometryDirectly(new OGRPoint(dfX, dfY, dfZ, dfM));

        }

        else

        {

            poMulti->addGeometryDirectly(new OGRPoint(dfX, dfY));

        }

    }

    return poMulti;

}

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

/*                  OGRESRIJSONReadSpatialReference()                   */

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

OGRSpatialReference *OGRESRIJSONReadSpatialReference(json_object *poObj)

{

    /* -------------------------------------------------------------------- */

    /*      Read spatial reference definition.                              */

    /* -------------------------------------------------------------------- */

    OGRSpatialReference *poSRS = nullptr;

    json_object *poObjSrs =

        OGRGeoJSONFindMemberByName(poObj, "spatialReference");

    if (nullptr != poObjSrs)

    {

        json_object *poObjWkid =

            OGRGeoJSONFindMemberByName(poObjSrs, "latestWkid");

        if (poObjWkid == nullptr)

            poObjWkid = OGRGeoJSONFindMemberByName(poObjSrs, "wkid");

        if (poObjWkid == nullptr)

        {

            json_object *poObjWkt = OGRGeoJSONFindMemberByName(poObjSrs, "wkt");

            if (poObjWkt == nullptr)

                return nullptr;

            const char *pszWKT = json_object_get_string(poObjWkt);

            poSRS = new OGRSpatialReference();

            poSRS->SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);

            if (OGRERR_NONE != poSRS->importFromWkt(pszWKT))

            {

                delete poSRS;

                poSRS = nullptr;

            }

            else

            {

                auto poSRSMatch = poSRS->FindBestMatch(70);

                if (poSRSMatch)

                {

                    poSRS->Release();

                    poSRS = poSRSMatch;

                    poSRS->SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);

                }

            }

            return poSRS;

        }

        const int nEPSG = json_object_get_int(poObjWkid);

        poSRS = new OGRSpatialReference();

        poSRS->SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);

        if (OGRERR_NONE != poSRS->importFromEPSG(nEPSG))

        {

            delete poSRS;

            poSRS = nullptr;

        }

    }

    return poSRS;

}

/*! @endcond */