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

 *

 * PostGIS - Spatial Types for PostgreSQL

 * http://postgis.net

 *

 * PostGIS is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation, either version 2 of the License, or

 * (at your option) any later version.

 *

 * PostGIS is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with PostGIS.  If not, see <http://www.gnu.org/licenses/>.

 *

 **********************************************************************

 *

 * Copyright 2019 Darafei Praliaskouski <me@komzpa.net>

 * Copyright 2013 Sandro Santilli <strk@kbt.io>

 * Copyright 2011 Kashif Rasul <kashif.rasul@gmail.com>

 *

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

#include "liblwgeom.h"

#include "lwgeom_log.h"

#include "../postgis_config.h"

#if defined(HAVE_LIBJSON)

#define JSON_C_VERSION_013 (13 << 8)

#include <json.h>

#if !defined(JSON_C_VERSION_NUM) || JSON_C_VERSION_NUM < JSON_C_VERSION_013

#include <json_object_private.h>

#endif

#ifndef JSON_C_VERSION

/* Adds support for libjson < 0.10 */

#define json_tokener_error_desc(x) json_tokener_errors[(x)]

#endif

#include <string.h>

/* Prototype */

static LWGEOM *parse_geojson(json_object *geojson, int *hasz);

static inline json_object *

findMemberByName(json_object *poObj, const char *pszName)

{

  json_object *poTmp;

  json_object_iter it;

  poTmp = poObj;

  if (!pszName || !poObj)

    return NULL;

  it.key = NULL;

  it.val = NULL;

  it.entry = NULL;

  if (json_object_get_object(poTmp))

  {

    if (!json_object_get_object(poTmp)->head)

    {

      lwerror("invalid GeoJSON representation");

      return NULL;

    }

    for (it.entry = json_object_get_object(poTmp)->head;

         (it.entry ? (it.key = (char *)it.entry->k, it.val = (json_object *)it.entry->v, it.entry) : 0);

         it.entry = it.entry->next)

    {

      if (strcasecmp((char *)it.key, pszName) == 0)

        return it.val;

    }

  }

  return NULL;

}

static inline json_object *

parse_coordinates(json_object *geojson)

{

  json_object *coordinates = findMemberByName(geojson, "coordinates");

  if (!coordinates)

  {

    lwerror("Unable to find 'coordinates' in GeoJSON string");

    return NULL;

  }

  if (json_type_array != json_object_get_type(coordinates))

  {

    lwerror("The 'coordinates' in GeoJSON are not an array");

    return NULL;

  }

  return coordinates;

}

static inline int

parse_geojson_coord(json_object *poObj, int *hasz, POINTARRAY *pa)

{

  POINT4D pt = {0, 0, 0, 0};

  if (json_object_get_type(poObj) == json_type_array)

  {

    json_object *poObjCoord = NULL;

    const int nSize = json_object_array_length(poObj);

    if (nSize == 0)

      return LW_TRUE;

    if (nSize < 2)

    {

      lwerror("Too few ordinates in GeoJSON");

      return LW_FAILURE;

    }

    /* Read X coordinate */

    poObjCoord = json_object_array_get_idx(poObj, 0);

    pt.x = json_object_get_double(poObjCoord);

    /* Read Y coordinate */

    poObjCoord = json_object_array_get_idx(poObj, 1);

    pt.y = json_object_get_double(poObjCoord);

    if (nSize > 2) /* should this be >= 3 ? */

    {

      /* Read Z coordinate */

      poObjCoord = json_object_array_get_idx(poObj, 2);

      pt.z = json_object_get_double(poObjCoord);

      *hasz = LW_TRUE;

    }

  }

  else

  {

    /* If it's not an array, just don't handle it */

    lwerror("The 'coordinates' in GeoJSON are not sufficiently nested");

    return LW_FAILURE;

  }

  return ptarray_append_point(pa, &pt, LW_TRUE);

}

static inline LWGEOM *

parse_geojson_point(json_object *geojson, int *hasz)

{

  json_object *coords = parse_coordinates(geojson);

  if (!coords)

    return NULL;

  POINTARRAY *pa = ptarray_construct_empty(1, 0, 1);

  parse_geojson_coord(coords, hasz, pa);

  return (LWGEOM *)lwpoint_construct(0, NULL, pa);

}

static inline LWGEOM *

parse_geojson_linestring(json_object *geojson, int *hasz)

{

  json_object *points = parse_coordinates(geojson);

  if (!points)

    return NULL;

  POINTARRAY *pa = ptarray_construct_empty(1, 0, 1);

  const int nPoints = json_object_array_length(points);

  for (int i = 0; i < nPoints; i++)

  {

    json_object *coords = json_object_array_get_idx(points, i);

    parse_geojson_coord(coords, hasz, pa);

  }

  return (LWGEOM *)lwline_construct(0, NULL, pa);

}

static inline LWPOLY *

parse_geojson_poly_rings(json_object *rings, int *hasz)

{

  if (!rings || json_object_get_type(rings) != json_type_array)

    return NULL;

  int nRings = json_object_array_length(rings);

  /* No rings => POLYGON EMPTY */

  if (!nRings)

    return lwpoly_construct_empty(0, 1, 0);

  /* Expecting up to nRings otherwise */

  POINTARRAY **ppa = (POINTARRAY **)lwalloc(sizeof(POINTARRAY *) * nRings);

  int o = 0;

  for (int i = 0; i < nRings; i++)

  {

    json_object *points = json_object_array_get_idx(rings, i);

    if (!points || json_object_get_type(points) != json_type_array)

    {

      for (int k = 0; k < o; k++)

        ptarray_free(ppa[k]);

      lwfree(ppa);

      lwerror("The 'coordinates' in GeoJSON ring are not an array");

      return NULL;

    }

    int nPoints = json_object_array_length(points);

    /* Skip empty rings */

    if (!nPoints)

    {

      /* Empty outer? Don't promote first hole to outer, holes don't matter. */

      if (!i)

        break;

      else

        continue;

    }

    ppa[o] = ptarray_construct_empty(1, 0, 1);

    for (int j = 0; j < nPoints; j++)

    {

      json_object *coords = NULL;

      coords = json_object_array_get_idx(points, j);

      if (LW_FAILURE == parse_geojson_coord(coords, hasz, ppa[o]))

      {

        for (int k = 0; k <= o; k++)

          ptarray_free(ppa[k]);

        lwfree(ppa);

        lwerror("The 'coordinates' in GeoJSON are not sufficiently nested");

        return NULL;

      }

    }

    o++;

  }

  /* All the rings were empty! */

  if (!o)

  {

    lwfree(ppa);

    return lwpoly_construct_empty(0, 1, 0);

  }

  return lwpoly_construct(0, NULL, o, ppa);

}

static inline LWGEOM *

parse_geojson_polygon(json_object *geojson, int *hasz)

{

  return (LWGEOM *)parse_geojson_poly_rings(parse_coordinates(geojson), hasz);

}

static inline LWGEOM *

parse_geojson_multipoint(json_object *geojson, int *hasz)

{

  json_object *points = parse_coordinates(geojson);

  if (!points)

    return NULL;

  LWMPOINT *geom = (LWMPOINT *)lwcollection_construct_empty(MULTIPOINTTYPE, 0, 1, 0);

  const int nPoints = json_object_array_length(points);

  for (int i = 0; i < nPoints; ++i)

  {

    POINTARRAY *pa = ptarray_construct_empty(1, 0, 1);

    json_object *coord = json_object_array_get_idx(points, i);

    if (parse_geojson_coord(coord, hasz, pa))

      geom = lwmpoint_add_lwpoint(geom, lwpoint_construct(0, NULL, pa));

    else

    {

      lwmpoint_free(geom);

      ptarray_free(pa);

      return NULL;

    }

  }

  return (LWGEOM *)geom;

}

static inline LWGEOM *

parse_geojson_multilinestring(json_object *geojson, int *hasz)

{

  json_object *mls = parse_coordinates(geojson);

  if (!mls)

    return NULL;

  LWMLINE *geom = (LWMLINE *)lwcollection_construct_empty(MULTILINETYPE, 0, 1, 0);

  const int nLines = json_object_array_length(mls);

  for (int i = 0; i < nLines; ++i)

  {

    POINTARRAY *pa = ptarray_construct_empty(1, 0, 1);

    json_object *coords = json_object_array_get_idx(mls, i);

    if (json_type_array == json_object_get_type(coords))

    {

      const int nPoints = json_object_array_length(coords);

      for (int j = 0; j < nPoints; ++j)

      {

        json_object *coord = json_object_array_get_idx(coords, j);

        if (!parse_geojson_coord(coord, hasz, pa))

        {

          lwmline_free(geom);

          ptarray_free(pa);

          return NULL;

        }

      }

      geom = lwmline_add_lwline(geom, lwline_construct(0, NULL, pa));

    }

    else

    {

      lwmline_free(geom);

      ptarray_free(pa);

      return NULL;

    }

  }

  return (LWGEOM *)geom;

}

static inline LWGEOM *

parse_geojson_multipolygon(json_object *geojson, int *hasz)

{

  json_object *polys = parse_coordinates(geojson);

  if (!polys)

    return NULL;

  LWGEOM *geom = (LWGEOM *)lwcollection_construct_empty(MULTIPOLYGONTYPE, 0, 1, 0);

  int nPolys = json_object_array_length(polys);

  for (int i = 0; i < nPolys; ++i)

  {

    json_object *rings = json_object_array_get_idx(polys, i);

    LWPOLY *poly = parse_geojson_poly_rings(rings, hasz);

    if (poly)

      geom = (LWGEOM *)lwmpoly_add_lwpoly((LWMPOLY *)geom, poly);

  }

  return geom;

}

static inline LWGEOM *

parse_geojson_geometrycollection(json_object *geojson, int *hasz)

{

  json_object *poObjGeoms = findMemberByName(geojson, "geometries");

  if (!poObjGeoms)

  {

    lwerror("Unable to find 'geometries' in GeoJSON string");

    return NULL;

  }

  LWGEOM *geom = (LWGEOM *)lwcollection_construct_empty(COLLECTIONTYPE, 0, 1, 0);

  if (json_type_array == json_object_get_type(poObjGeoms))

  {

    const int nGeoms = json_object_array_length(poObjGeoms);

    for (int i = 0; i < nGeoms; ++i)

    {

      json_object *poObjGeom = json_object_array_get_idx(poObjGeoms, i);

      LWGEOM *t = parse_geojson(poObjGeom, hasz);

      if (t)

        geom = (LWGEOM *)lwcollection_add_lwgeom((LWCOLLECTION *)geom, t);

      else

      {

        lwgeom_free(geom);

        return NULL;

      }

    }

  }

  return geom;

}

static inline LWGEOM *

parse_geojson(json_object *geojson, int *hasz)

{

  json_object *type = NULL;

  const char *name;

  if (!geojson)

  {

    lwerror("invalid GeoJSON representation");

    return NULL;

  }

  type = findMemberByName(geojson, "type");

  if (!type)

  {

    lwerror("unknown GeoJSON type");

    return NULL;

  }

  name = json_object_get_string(type);

  if (strcasecmp(name, "Point") == 0)

    return parse_geojson_point(geojson, hasz);

  if (strcasecmp(name, "LineString") == 0)

    return parse_geojson_linestring(geojson, hasz);

  if (strcasecmp(name, "Polygon") == 0)

    return parse_geojson_polygon(geojson, hasz);

  if (strcasecmp(name, "MultiPoint") == 0)

    return parse_geojson_multipoint(geojson, hasz);

  if (strcasecmp(name, "MultiLineString") == 0)

    return parse_geojson_multilinestring(geojson, hasz);

  if (strcasecmp(name, "MultiPolygon") == 0)

    return parse_geojson_multipolygon(geojson, hasz);

  if (strcasecmp(name, "GeometryCollection") == 0)

    return parse_geojson_geometrycollection(geojson, hasz);

  lwerror("invalid GeoJson representation");

  return NULL; /* Never reach */

}

#endif /* HAVE_LIBJSON */

LWGEOM *

lwgeom_from_geojson(const char *geojson, char **srs)

{

#ifndef HAVE_LIBJSON

  *srs = NULL;

  lwerror("You need JSON-C for lwgeom_from_geojson");

  return NULL;

#else  /* HAVE_LIBJSON */

  /* Begin to Parse json */

  json_tokener *jstok = json_tokener_new();

  json_object *poObj = json_tokener_parse_ex(jstok, geojson, -1);

  if (jstok->err != json_tokener_success)

  {

    char err[256];

    snprintf(err, 256, "%s (at offset %d)", json_tokener_error_desc(jstok->err), jstok->char_offset);

    json_tokener_free(jstok);

    json_object_put(poObj);

    lwerror("%s", err);

    return NULL;

  }

  json_tokener_free(jstok);

  *srs = NULL;

  json_object *poObjSrs = findMemberByName(poObj, "crs");

  if (poObjSrs != NULL)

  {

    json_object *poObjSrsType = findMemberByName(poObjSrs, "type");

    if (poObjSrsType != NULL)

    {

      json_object *poObjSrsProps = findMemberByName(poObjSrs, "properties");

      if (poObjSrsProps)

      {

        json_object *poNameURL = findMemberByName(poObjSrsProps, "name");

        if (poNameURL)

        {

          const char *pszName = json_object_get_string(poNameURL);

          if (pszName)

          {

            *srs = lwalloc(strlen(pszName) + 1);

            strcpy(*srs, pszName);

          }

        }

      }

    }

  }

  int hasz = LW_FALSE;

  LWGEOM *lwgeom = parse_geojson(poObj, &hasz);

  json_object_put(poObj);

  if (!lwgeom)

    return NULL;

  if (!hasz)

  {

    LWGEOM *tmp = lwgeom_force_2d(lwgeom);

    lwgeom_free(lwgeom);

    lwgeom = tmp;

  }

  lwgeom_add_bbox(lwgeom);

  return lwgeom;

#endif /* HAVE_LIBJSON */

}