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

 *

 * Project:  OGR

 * Purpose:  Implements OGC API - Features (previously known as WFS3)

 * Author:   Even Rouault, even dot rouault at spatialys dot com

 *

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

 * Copyright (c) 2018-2019, Even Rouault <even dot rouault at spatialys dot com>

 *

 * SPDX-License-Identifier: MIT

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

#include "ogrsf_frmts.h"

#include "cpl_conv.h"

#include "cpl_minixml.h"

#include "cpl_http.h"

#include "ogr_swq.h"

#include "parsexsd.h"

#include <algorithm>

#include <cinttypes>

#include <memory>

#include <vector>

#include <set>

// g++ -Wshadow -Wextra -std=c++11 -fPIC -g -Wall

// ogr/ogrsf_frmts/wfs/ogroapif*.cpp -shared -o ogr_OAPIF.so -Iport -Igcore

// -Iogr -Iogr/ogrsf_frmts -Iogr/ogrsf_frmts/gml -Iogr/ogrsf_frmts/wfs -L.

// -lgdal

extern "C" void RegisterOGROAPIF();

#define MEDIA_TYPE_OAPI_3_0 "application/vnd.oai.openapi+json;version=3.0"

#define MEDIA_TYPE_OAPI_3_0_ALT "application/openapi+json;version=3.0"

#define MEDIA_TYPE_JSON "application/json"

#define MEDIA_TYPE_GEOJSON "application/geo+json"

#define MEDIA_TYPE_TEXT_XML "text/xml"

#define MEDIA_TYPE_APPLICATION_XML "application/xml"

#define MEDIA_TYPE_JSON_SCHEMA "application/schema+json"

constexpr const char *OGC_CRS84_WKT =

    "GEOGCRS[\"WGS 84 (CRS84)\",ENSEMBLE[\"World Geodetic System 1984 "

    "ensemble\",MEMBER[\"World Geodetic System 1984 "

    "(Transit)\"],MEMBER[\"World Geodetic System 1984 (G730)\"],MEMBER[\"World "

    "Geodetic System 1984 (G873)\"],MEMBER[\"World Geodetic System 1984 "

    "(G1150)\"],MEMBER[\"World Geodetic System 1984 (G1674)\"],MEMBER[\"World "

    "Geodetic System 1984 (G1762)\"],MEMBER[\"World Geodetic System 1984 "

    "(G2139)\"],ELLIPSOID[\"WGS "

    "84\",6378137,298.257223563,LENGTHUNIT[\"metre\",1]],ENSEMBLEACCURACY[2.0]]"

    ",PRIMEM[\"Greenwich\",0,ANGLEUNIT[\"degree\",0.0174532925199433]],CS["

    "ellipsoidal,2],AXIS[\"geodetic longitude "

    "(Lon)\",east,ORDER[1],ANGLEUNIT[\"degree\",0.0174532925199433]],AXIS["

    "\"geodetic latitude "

    "(Lat)\",north,ORDER[2],ANGLEUNIT[\"degree\",0.0174532925199433]],USAGE["

    "SCOPE[\"Not "

    "known.\"],AREA[\"World.\"],BBOX[-90,-180,90,180]],ID[\"OGC\",\"CRS84\"]]";

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

/*                           OGROAPIFDataset                             */

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

class OGROAPIFLayer;

class OGROAPIFDataset final : public GDALDataset

{

    friend class OGROAPIFLayer;

    bool m_bMustCleanPersistent = false;

    // Server base URL. Like "https://example.com"

    // Relative links are relative to it

    CPLString m_osServerBaseURL{};

    // Service base URL. Like "https://example.com/ogcapi"

    CPLString m_osRootURL{};

    CPLString m_osUserQueryParams{};

    CPLString m_osUserPwd{};

    int m_nPageSize = 1000;

    int m_nInitialRequestPageSize = 20;

    bool m_bPageSizeSetFromOpenOptions = false;

    std::vector<std::unique_ptr<OGRLayer>> m_apoLayers{};

    std::string m_osAskedCRS{};

    OGRSpatialReference m_oAskedCRS{};

    bool m_bAskedCRSIsRequired = false;

    bool m_bServerFeaturesAxisOrderGISFriendly = false;

    bool m_bAPIDocLoaded = false;

    CPLJSONDocument m_oAPIDoc{};

    bool m_bLandingPageDocLoaded = false;

    CPLJSONDocument m_oLandingPageDoc{};

    bool m_bIgnoreSchema = false;

    std::string m_osDateTime{};

    bool Download(const CPLString &osURL, const char *pszAccept,

                  CPLString &osResult, CPLString &osContentType,

                  CPLStringList *paosHeaders = nullptr);

    bool DownloadJSon(const CPLString &osURL, CPLJSONDocument &oDoc,

                      const char *pszAccept = MEDIA_TYPE_GEOJSON

                      ", " MEDIA_TYPE_JSON,

                      CPLStringList *paosHeaders = nullptr);

    bool LoadJSONCollection(const CPLJSONObject &oCollection,

                            const CPLJSONArray &oGlobalCRSList);

    bool LoadJSONCollections(const CPLString &osResultIn,

                             const std::string &osCollectionsURL);

    /**

     * Determines the page size by making a call to the API endpoint to get the server's

     * default and max limits for the collection items specified by itemsUrl

     */

    void DeterminePageSizeFromAPI(const std::string &itemsUrl);

  public:

    OGROAPIFDataset() = default;

    ~OGROAPIFDataset();

    int GetLayerCount() override

    {

        return static_cast<int>(m_apoLayers.size());

    }

    OGRLayer *GetLayer(int idx) override;

    bool Open(GDALOpenInfo *);

    const CPLJSONDocument &GetAPIDoc(std::string &osURLOut);

    const CPLJSONDocument &GetLandingPageDoc(std::string &osURLOut);

    CPLString ResolveURL(const CPLString &osURL,

                         const std::string &osRequestURL) const;

};

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

/*                            OGROAPIFLayer                              */

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

class OGROAPIFLayer final : public OGRLayer

{

    OGROAPIFDataset *m_poDS = nullptr;

    OGRFeatureDefn *m_poFeatureDefn = nullptr;

    bool m_bIsGeographicCRS = false;

    bool m_bCRSHasGISFriendlyOrder = false;

    bool m_bHasEmittedContentCRSWarning = false;

    bool m_bHasEmittedJsonCRWarning = false;

    std::string m_osActiveCRS{};

    CPLString m_osURL{};

    CPLString m_osPath{};

    OGREnvelope m_oExtent{};

    OGREnvelope m_oOriginalExtent{};

    OGRSpatialReference m_oOriginalExtentCRS{};

    bool m_bFeatureDefnEstablished = false;

    std::unique_ptr<GDALDataset> m_poUnderlyingDS{};

    OGRLayer *m_poUnderlyingLayer = nullptr;

    GIntBig m_nFID = 1;

    CPLString m_osGetURL{};

    CPLString m_osAttributeFilter{};

    CPLString m_osGetID{};

    std::vector<std::string> m_oSupportedCRSList{};

    OGRLayer::GetSupportedSRSListRetType m_apoSupportedCRSList{};

    bool m_bFilterMustBeClientSideEvaluated = false;

    bool m_bGotQueryableAttributes = false;

    std::set<CPLString> m_aoSetQueryableAttributes{};

    bool m_bHasCQLText = false;

    // https://github.com/tschaub/ogcapi-features/blob/json-array-expression/extensions/cql/jfe/readme.md

    bool m_bHasJSONFilterExpression = false;

    GIntBig m_nTotalFeatureCount = -1;

    bool m_bHasIntIdMember = false;

    bool m_bHasStringIdMember = false;

    std::vector<std::unique_ptr<OGRFieldDefn>> m_apoFieldsFromSchema{};

    CPLString m_osDescribedByURL{};

    CPLString m_osDescribedByType{};

    bool m_bDescribedByIsXML = false;

    CPLString m_osQueryablesURL{};

    std::vector<std::string> m_aosItemAssetNames{};  // STAC specific

    CPLJSONDocument m_oCurDoc{};

    int m_iFeatureInPage = 0;

    void EstablishFeatureDefn();

    OGRFeature *GetNextRawFeature();

    CPLString AddFilters(const CPLString &osURL);

    CPLString BuildFilter(const swq_expr_node *poNode);

    CPLString BuildFilterCQLText(const swq_expr_node *poNode);

    CPLString BuildFilterJSONFilterExpr(const swq_expr_node *poNode);

    bool SupportsResultTypeHits();

    void GetQueryableAttributes();

    void GetSchema();

    void ComputeExtent();

    CPL_DISALLOW_COPY_ASSIGN(OGROAPIFLayer)

  public:

    OGROAPIFLayer(OGROAPIFDataset *poDS, const CPLString &osName,

                  const CPLJSONArray &oBBOX, const std::string &osBBOXCrs,

                  std::vector<std::string> &&oCRSList,

                  const std::string &osActiveCRS, double dfCoordinateEpoch,

                  const CPLJSONArray &oLinks);

    ~OGROAPIFLayer();

    void SetItemAssets(const CPLJSONObject &oItemAssets);

    const char *GetName() override

    {

        return GetDescription();

    }

    OGRFeatureDefn *GetLayerDefn() override;

    void ResetReading() override;

    OGRFeature *GetNextFeature() override;

    OGRFeature *GetFeature(GIntBig) override;

    int TestCapability(const char *) override;

    GIntBig GetFeatureCount(int bForce = FALSE) override;

    OGRErr IGetExtent(int iGeomField, OGREnvelope *psExtent,

                      bool bForce) override;

    OGRErr ISetSpatialFilter(int iGeomField,

                             const OGRGeometry *poGeom) override;

    OGRErr SetAttributeFilter(const char *pszQuery) override;

    const OGRLayer::GetSupportedSRSListRetType &

    GetSupportedSRSList(int iGeomField) override;

    OGRErr SetActiveSRS(int iGeomField,

                        const OGRSpatialReference *poSRS) override;

    void SetTotalItemCount(GIntBig nCount)

    {

        m_nTotalFeatureCount = nCount;

    }

};

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

/*                          CheckContentType()                          */

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

// We may ask for "application/openapi+json;version=3.0"

// and the server returns "application/openapi+json; charset=utf-8; version=3.0"

static bool CheckContentType(const char *pszGotContentType,

                             const char *pszExpectedContentType)

{

    CPLStringList aosGotTokens(CSLTokenizeString2(pszGotContentType, "; ", 0));

    CPLStringList aosExpectedTokens(

        CSLTokenizeString2(pszExpectedContentType, "; ", 0));

    for (int i = 0; i < aosExpectedTokens.size(); i++)

    {

        bool bFound = false;

        for (int j = 0; j < aosGotTokens.size(); j++)

        {

            if (EQUAL(aosExpectedTokens[i], aosGotTokens[j]))

            {

                bFound = true;

                break;

            }

        }

        if (!bFound)

            return false;

    }

    return true;

}

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

/*                         ~OGROAPIFDataset()                           */

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

OGROAPIFDataset::~OGROAPIFDataset()

{

    if (m_bMustCleanPersistent)

    {

        char **papszOptions = CSLSetNameValue(nullptr, "CLOSE_PERSISTENT",

                                              CPLSPrintf("OAPIF:%p", this));

        CPLHTTPDestroyResult(CPLHTTPFetch(m_osRootURL, papszOptions));

        CSLDestroy(papszOptions);

    }

}

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

/*                               ResolveURL()                           */

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

// Resolve relative links and re-inject authentication elements.

// If source URL is https://user:pwd@server.com/bla

// and link only contains https://server.com/bla, then insert

// into it user:pwd

CPLString OGROAPIFDataset::ResolveURL(const CPLString &osURL,

                                      const std::string &osRequestURL) const

{

    const auto CleanURL = [](const std::string &osStr)

    {

        std::string osRet(osStr);

        const auto nPos = osRet.rfind('?');

        if (nPos != std::string::npos)

            osRet.resize(nPos);

        if (!osRet.empty() && osRet.back() == '/')

            osRet.pop_back();

        return osRet;

    };

    CPLString osRet(osURL);

    // Cf https://datatracker.ietf.org/doc/html/rfc3986#section-5.4

    // Partial implementation for usual cases...

    std::string osRequestURLBase =

        CPLGetPathSafe(CleanURL(osRequestURL).c_str());

    if (!osURL.empty() && osURL[0] == '/')

        osRet = m_osServerBaseURL + osURL;

    else if (osURL.size() > 2 && osURL[0] == '.' && osURL[1] == '/')

        osRet = osRequestURLBase + osURL.substr(1);

    else if (osURL.size() > 3 && osURL[0] == '.' && osURL[1] == '.' &&

             osURL[2] == '/')

    {

        std::string osModifiedRequestURL(std::move(osRequestURLBase));

        while (osRet.size() > 3 && osRet[0] == '.' && osRet[1] == '.' &&

               osRet[2] == '/')

        {

            osModifiedRequestURL = CPLGetPathSafe(osModifiedRequestURL.c_str());

            osRet = osRet.substr(3);

        }

        osRet = osModifiedRequestURL + "/" + osRet;

    }

    else if (!STARTS_WITH(osURL.c_str(), "http://") &&

             !STARTS_WITH(osURL.c_str(), "https://") &&

             !STARTS_WITH(osURL.c_str(), "file://"))

    {

        osRet = osRequestURLBase + "/" + osURL;

    }

    const auto nArobaseInURLPos = m_osServerBaseURL.find('@');

    if (!osRet.empty() && STARTS_WITH(m_osServerBaseURL, "https://") &&

        STARTS_WITH(osRet, "https://") &&

        nArobaseInURLPos != std::string::npos &&

        osRet.find('@') == std::string::npos)

    {

        const auto nFirstSlashPos =

            m_osServerBaseURL.find('/', strlen("https://"));

        if (nFirstSlashPos == std::string::npos ||

            nFirstSlashPos > nArobaseInURLPos)

        {

            auto osUserPwd = m_osServerBaseURL.substr(

                strlen("https://"), nArobaseInURLPos - strlen("https://"));

            std::string osServer(

                nFirstSlashPos == std::string::npos

                    ? m_osServerBaseURL.substr(nArobaseInURLPos + 1)

                    : m_osServerBaseURL.substr(nArobaseInURLPos + 1,

                                               nFirstSlashPos -

                                                   nArobaseInURLPos));

            if (STARTS_WITH(osRet, ("https://" + osServer).c_str()))

            {

                osRet = "https://" + osUserPwd + "@" +

                        osRet.substr(strlen("https://"));

            }

        }

    }

    return osRet;

}

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

/*                              Download()                              */

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

bool OGROAPIFDataset::Download(const CPLString &osURL, const char *pszAccept,

                               CPLString &osResult, CPLString &osContentType,

                               CPLStringList *paosHeaders)

{

#ifndef REMOVE_HACK

    VSIStatBufL sStatBuf;

    if (VSIStatL(osURL, &sStatBuf) == 0)

    {

        CPLDebug("OAPIF", "Reading %s", osURL.c_str());

        GByte *pabyRet = nullptr;

        if (VSIIngestFile(nullptr, osURL, &pabyRet, nullptr, -1))

        {

            osResult = reinterpret_cast<char *>(pabyRet);

            CPLFree(pabyRet);

        }

        return false;

    }

#endif

    char **papszOptions = nullptr;

    if (pszAccept)

    {

        papszOptions =

            CSLSetNameValue(papszOptions, "HEADERS",

                            (CPLString("Accept: ") + pszAccept).c_str());

    }

    if (!m_osUserPwd.empty())

    {

        papszOptions =

            CSLSetNameValue(papszOptions, "USERPWD", m_osUserPwd.c_str());

    }

    m_bMustCleanPersistent = true;

    papszOptions =

        CSLAddString(papszOptions, CPLSPrintf("PERSISTENT=OAPIF:%p", this));

    CPLString osURLWithQueryParameters(osURL);

    if (!m_osUserQueryParams.empty() &&

        osURL.find('?' + m_osUserQueryParams) == std::string::npos &&

        osURL.find('&' + m_osUserQueryParams) == std::string::npos)

    {

        if (osURL.find('?') == std::string::npos)

        {

            osURLWithQueryParameters += '?';

        }

        else

        {

            osURLWithQueryParameters += '&';

        }

        osURLWithQueryParameters += m_osUserQueryParams;

    }

    CPLHTTPResult *psResult =

        CPLHTTPFetch(osURLWithQueryParameters, papszOptions);

    CSLDestroy(papszOptions);

    if (!psResult)

        return false;

    if (psResult->pszErrBuf != nullptr)

    {

        std::string osErrorMsg(psResult->pszErrBuf);

        const char *pszData =

            reinterpret_cast<const char *>(psResult->pabyData);

        if (pszData)

        {

            osErrorMsg += ", ";

            osErrorMsg.append(pszData, CPLStrnlen(pszData, 1000));

        }

        CPLError(CE_Failure, CPLE_AppDefined, "%s", osErrorMsg.c_str());

        CPLHTTPDestroyResult(psResult);

        return false;

    }

    if (psResult->pszContentType)

        osContentType = psResult->pszContentType;

    // Do not check content type if not specified

    bool bFoundExpectedContentType = pszAccept ? false : true;

    if (!bFoundExpectedContentType)

    {

#ifndef REMOVE_HACK

        // cppcheck-suppress nullPointer

        if (strstr(pszAccept, "json"))

        {

            if (strstr(osURL, "raw.githubusercontent.com") &&

                strstr(osURL, ".json"))

            {

                bFoundExpectedContentType = true;

            }

            else if (psResult->pszContentType != nullptr &&

                     (CheckContentType(psResult->pszContentType,

                                       MEDIA_TYPE_JSON) ||

                      CheckContentType(psResult->pszContentType,

                                       MEDIA_TYPE_GEOJSON)))

            {

                bFoundExpectedContentType = true;

            }

        }

#endif

        // cppcheck-suppress nullPointer

        if (strstr(pszAccept, "xml") && psResult->pszContentType != nullptr &&

            (CheckContentType(psResult->pszContentType, MEDIA_TYPE_TEXT_XML) ||

             CheckContentType(psResult->pszContentType,

                              MEDIA_TYPE_APPLICATION_XML)))

        {

            bFoundExpectedContentType = true;

        }

        // cppcheck-suppress nullPointer

        if (strstr(pszAccept, MEDIA_TYPE_JSON_SCHEMA) &&

            psResult->pszContentType != nullptr &&

            (CheckContentType(psResult->pszContentType, MEDIA_TYPE_JSON) ||

             CheckContentType(psResult->pszContentType,

                              MEDIA_TYPE_JSON_SCHEMA)))

        {

            bFoundExpectedContentType = true;

        }

        for (const char *pszMediaType : {

                 MEDIA_TYPE_JSON,

                 MEDIA_TYPE_GEOJSON,

                 MEDIA_TYPE_OAPI_3_0,

#ifndef REMOVE_SUPPORT_FOR_OLD_VERSIONS

                 MEDIA_TYPE_OAPI_3_0_ALT,

#endif

             })

        {

            // cppcheck-suppress nullPointer

            if (strstr(pszAccept, pszMediaType) &&

                psResult->pszContentType != nullptr &&

                CheckContentType(psResult->pszContentType, pszMediaType))

            {

                bFoundExpectedContentType = true;

                break;

            }

        }

    }

    if (!bFoundExpectedContentType)

    {

        CPLError(CE_Failure, CPLE_AppDefined, "Unexpected Content-Type: %s",

                 psResult->pszContentType ? psResult->pszContentType

                                          : "(null)");

        CPLHTTPDestroyResult(psResult);

        return false;

    }

    if (psResult->pabyData == nullptr)

    {

        CPLError(CE_Failure, CPLE_AppDefined,

                 "Empty content returned by server");

        CPLHTTPDestroyResult(psResult);

        return false;

    }

    if (paosHeaders)

    {

        *paosHeaders = CSLDuplicate(psResult->papszHeaders);

    }

    osResult = reinterpret_cast<const char *>(psResult->pabyData);

    CPLHTTPDestroyResult(psResult);

    return true;

}

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

/*                           DownloadJSon()                             */

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

bool OGROAPIFDataset::DownloadJSon(const CPLString &osURL,

                                   CPLJSONDocument &oDoc, const char *pszAccept,

                                   CPLStringList *paosHeaders)

{

    CPLString osResult;

    CPLString osContentType;

    if (!Download(osURL, pszAccept, osResult, osContentType, paosHeaders))

        return false;

    return oDoc.LoadMemory(osResult);

}

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

/*                        GetLandingPageDoc()                           */

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

const CPLJSONDocument &OGROAPIFDataset::GetLandingPageDoc(std::string &osURLOut)

{

    if (m_bLandingPageDocLoaded)

        return m_oLandingPageDoc;

    m_bLandingPageDocLoaded = true;

    osURLOut = m_osRootURL;

    CPL_IGNORE_RET_VAL(

        DownloadJSon(osURLOut, m_oLandingPageDoc, MEDIA_TYPE_JSON));

    return m_oLandingPageDoc;

}

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

/*                            GetAPIDoc()                               */

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

const CPLJSONDocument &OGROAPIFDataset::GetAPIDoc(std::string &osURLOut)

{

    if (m_bAPIDocLoaded)

        return m_oAPIDoc;

    m_bAPIDocLoaded = true;

    // Fetch the /api URL from the links of the landing page

    CPLString osAPIURL;

    std::string osLandingPageURL;

    const auto &oLandingPage = GetLandingPageDoc(osLandingPageURL);

    if (oLandingPage.GetRoot().IsValid())

    {

        const auto oLinks = oLandingPage.GetRoot().GetArray("links");

        if (oLinks.IsValid())

        {

            int nCountRelAPI = 0;

            for (int i = 0; i < oLinks.Size(); i++)

            {

                CPLJSONObject oLink = oLinks[i];

                if (!oLink.IsValid() ||

                    oLink.GetType() != CPLJSONObject::Type::Object)

                {

                    continue;

                }

                const auto osRel(oLink.GetString("rel"));

                const auto osType(oLink.GetString("type"));

                if (EQUAL(osRel.c_str(), "service-desc")

#ifndef REMOVE_SUPPORT_FOR_OLD_VERSIONS

                    // Needed for http://beta.fmi.fi/data/3/wfs/sofp

                    || EQUAL(osRel.c_str(), "service")

#endif

                )

                {

                    nCountRelAPI++;

                    osAPIURL =

                        ResolveURL(oLink.GetString("href"), osLandingPageURL);

                    if (osType == MEDIA_TYPE_OAPI_3_0

#ifndef REMOVE_SUPPORT_FOR_OLD_VERSIONS

                        // Needed for http://beta.fmi.fi/data/3/wfs/sofp

                        || osType == MEDIA_TYPE_OAPI_3_0_ALT

#endif

                    )

                    {

                        nCountRelAPI = 1;

                        break;

                    }

                }

            }

            if (!osAPIURL.empty() && nCountRelAPI > 1)

            {

                osAPIURL.clear();

            }

        }

    }

    const char *pszAccept = MEDIA_TYPE_OAPI_3_0

#ifndef REMOVE_SUPPORT_FOR_OLD_VERSIONS

        ", " MEDIA_TYPE_OAPI_3_0_ALT ", " MEDIA_TYPE_JSON

#endif

        ;

    if (!osAPIURL.empty())

    {

        osURLOut = osAPIURL;

        CPL_IGNORE_RET_VAL(DownloadJSon(osAPIURL, m_oAPIDoc, pszAccept));

        return m_oAPIDoc;

    }

#ifndef REMOVE_HACK

    CPLPushErrorHandler(CPLQuietErrorHandler);

    CPLString osURL(m_osRootURL + "/api");

    osURL = CPLGetConfigOption("OGR_WFS3_API_URL", osURL.c_str());

    bool bOK = DownloadJSon(osURL, m_oAPIDoc, pszAccept);

    CPLPopErrorHandler();

    CPLErrorReset();

    if (bOK)

    {

        return m_oAPIDoc;

    }

    osURLOut = m_osRootURL + "/api/";

    if (DownloadJSon(osURLOut, m_oAPIDoc, pszAccept))

    {

        return m_oAPIDoc;

    }

#endif

    return m_oAPIDoc;

}

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

/*                         LoadJSONCollection()                         */

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

bool OGROAPIFDataset::LoadJSONCollection(const CPLJSONObject &oCollection,

                                         const CPLJSONArray &oGlobalCRSList)

{

    if (oCollection.GetType() != CPLJSONObject::Type::Object)

        return false;

    // As used by https://maps.ecere.com/ogcapi/collections?f=json

    const auto osLayerDataType = oCollection.GetString("layerDataType");

    if (osLayerDataType == "Raster" || osLayerDataType == "Coverage")

        return false;

    CPLString osName(oCollection.GetString("id"));

#ifndef REMOVE_SUPPORT_FOR_OLD_VERSIONS

    if (osName.empty())

        osName = oCollection.GetString("name");

    if (osName.empty())

        osName = oCollection.GetString("collectionId");

#endif

    if (osName.empty())

        return false;

    CPLString osTitle(oCollection.GetString("title"));

    CPLString osDescription(oCollection.GetString("description"));

    CPLJSONArray oBBOX = oCollection.GetArray("extent/spatial/bbox");

#ifndef REMOVE_HACK_FOR_NLS_FINLAND_SERVICES

    if (!oBBOX.IsValid())

        oBBOX = oCollection.GetArray("extent/spatialExtent/bbox");

#endif

#ifndef REMOVE_SUPPORT_FOR_OLD_VERSIONS

    if (!oBBOX.IsValid())

        oBBOX = oCollection.GetArray("extent/spatial");

#endif

    const std::string osBBOXCrs = oCollection.GetString("extent/spatial/crs");

    // Deal with CRS list

    const CPLJSONArray oCRSListOri = oCollection.GetArray("crs");

    std::vector<std::string> oCRSList;

    std::string osActiveCRS;

    double dfCoordinateEpoch = 0.0;

    if (oCRSListOri.IsValid())

    {

        std::set<std::string> oSetCRS;

        for (const auto &oCRS : oCRSListOri)

        {

            if (oCRS.ToString() == "#/crs")

            {

                if (!oGlobalCRSList.IsValid())

                {

                    CPLError(CE_Failure, CPLE_AppDefined,

                             "Collection %s refer to #/crs global CRS list, "

                             "which is missing",

                             osTitle.c_str());

                }

                else

                {

                    for (const auto &oGlobalCRS : oGlobalCRSList)

                    {

                        std::string osCRS = oGlobalCRS.ToString();

                        if (oSetCRS.find(osCRS) == oSetCRS.end())

                        {

                            oSetCRS.insert(osCRS);

                            oCRSList.push_back(std::move(osCRS));

                        }

                    }

                }

            }

            else

            {

                std::string osCRS = oCRS.ToString();

                if (oSetCRS.find(osCRS) == oSetCRS.end())

                {

                    oSetCRS.insert(osCRS);

                    oCRSList.push_back(std::move(osCRS));

                }

            }

        }

        if (!m_oAskedCRS.IsEmpty())

        {

            for (const auto &osCRS : oCRSList)

            {

                OGRSpatialReference oSRS;

                if (oSRS.SetFromUserInput(

                        osCRS.c_str(),

                        OGRSpatialReference::

                            SET_FROM_USER_INPUT_LIMITATIONS_get()) ==

                    OGRERR_NONE)

                {

                    if (oSRS.IsSame(&m_oAskedCRS))

                    {

                        osActiveCRS = osCRS;

                        break;

                    }

                }

            }

            if (osActiveCRS.empty())

            {

                if (m_bAskedCRSIsRequired)

                {

                    std::string osList;

                    for (const auto &osCRS : oCRSList)

                    {

                        if (!osList.empty())

                            osList += ", ";

                        if (osCRS.find(

                                "http://www.opengis.net/def/crs/EPSG/0/") == 0)

                            osList +=

                                "EPSG:" +

                                osCRS.substr(strlen(

                                    "http://www.opengis.net/def/crs/EPSG/0/"));

                        else if (osCRS.find("https://www.opengis.net/def/crs/"

                                            "EPSG/0/") == 0)

                            osList +=

                                "EPSG:" +

                                osCRS.substr(strlen(

                                    "https://www.opengis.net/def/crs/EPSG/0/"));

                        else if (osCRS.find("http://www.opengis.net/def/crs/"

                                            "OGC/1.3/") == 0)

                            osList +=

                                "OGC:" +

                                osCRS.substr(strlen(

                                    "http://www.opengis.net/def/crs/OGC/1.3/"));

                        else if (osCRS.find("https://www.opengis.net/def/crs/"

                                            "OGC/1.3/") == 0)

                            osList += "OGC:" + osCRS.substr(strlen(

                                                   "https://www.opengis.net/"

                                                   "def/crs/OGC/1.3/"));

                        else

                            osList += osCRS;

                    }

                    CPLError(CE_Failure, CPLE_AppDefined,

                             "CRS %s not found in list of CRS valid for "

                             "collection %s. Available CRS are %s.",

                             m_osAskedCRS.c_str(), osTitle.c_str(),

                             osList.c_str());

                    return false;

                }

                else

                {

                    CPLDebug("OAPIF",

                             "CRS %s not found in list of CRS valid for "

                             "collection %s",

                             m_osAskedCRS.c_str(), osTitle.c_str());

                }

            }

        }

    }

    // storageCRS is in the "OGC API - Features - Part 2: Coordinate Reference

    // Systems" extension

    std::string osStorageCRS = oCollection.GetString("storageCrs");

    const double dfStorageCrsCoordinateEpoch =

        oCollection.GetDouble("storageCrsCoordinateEpoch");

    if (osActiveCRS.empty() || osActiveCRS == osStorageCRS)

    {

        osActiveCRS = std::move(osStorageCRS);

        dfCoordinateEpoch = dfStorageCrsCoordinateEpoch;

    }

    const auto oLinks = oCollection.GetArray("links");

    auto poLayer = std::make_unique<OGROAPIFLayer>(

        this, osName, oBBOX, osBBOXCrs, std::move(oCRSList), osActiveCRS,

        dfCoordinateEpoch, oLinks);

    if (!osTitle.empty())

        poLayer->SetMetadataItem("TITLE", osTitle.c_str());

    if (!osDescription.empty())

        poLayer->SetMetadataItem("DESCRIPTION", osDescription.c_str());

    auto oTemporalInterval = oCollection.GetArray("extent/temporal/interval");

    if (oTemporalInterval.IsValid() && oTemporalInterval.Size() == 1 &&

        oTemporalInterval[0].GetType() == CPLJSONObject::Type::Array)

    {

        auto oArray = oTemporalInterval[0].ToArray();

        if (oArray.Size() == 2)

        {

            if (oArray[0].GetType() == CPLJSONObject::Type::String)

            {

                poLayer->SetMetadataItem("TEMPORAL_INTERVAL_MIN",

                                         oArray[0].ToString().c_str());

            }

            if (oArray[1].GetType() == CPLJSONObject::Type::String)

            {

                poLayer->SetMetadataItem("TEMPORAL_INTERVAL_MAX",

                                         oArray[1].ToString().c_str());

            }

        }

    }

    // STAC specific

    auto oItemAssets = oCollection.GetObj("item_assets");

    if (oItemAssets.IsValid() &&

        oItemAssets.GetType() == CPLJSONObject::Type::Object)

    {

        poLayer->SetItemAssets(oItemAssets);

    }

    // LDProxy extension (https://github.com/opengeospatial/ogcapi-features/issues/261#issuecomment-1271010859)

    const auto nItemCount = oCollection.GetLong("itemCount", -1);

    if (nItemCount >= 0)

        poLayer->SetTotalItemCount(nItemCount);

    auto oJSONStr = oCollection.Format(CPLJSONObject::PrettyFormat::Pretty);

    char *apszMetadata[2] = {&oJSONStr[0], nullptr};

    poLayer->SetMetadata(apszMetadata, "json:metadata");

    m_apoLayers.emplace_back(std::move(poLayer));

    return true;

}

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

/*                         LoadJSONCollections()                        */

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

bool OGROAPIFDataset::LoadJSONCollections(const CPLString &osResultIn,

                                          const std::string &osCollectionsURL)

{

    std::string osParentURL(osCollectionsURL);

    CPLString osResult(osResultIn);

    while (!osResult.empty())

    {

        CPLJSONDocument oDoc;

        if (!oDoc.LoadMemory(osResult))

        {

            return false;

        }

        const auto &oRoot = oDoc.GetRoot();

        CPLJSONArray oCollections = oRoot.GetArray("collections");

        if (!oCollections.IsValid())

        {

            CPLError(CE_Failure, CPLE_AppDefined, "No collections array");

            return false;

        }

        const auto oGlobalCRSList = oRoot.GetArray("crs");

        for (int i = 0; i < oCollections.Size(); i++)

        {

            LoadJSONCollection(oCollections[i], oGlobalCRSList);

        }

        osResult.clear();

        // Paging is a (unspecified) extension to the core used by

        // https://{api_key}:@api.planet.com/analytics

        const auto oLinks = oRoot.GetArray("links");

        if (oLinks.IsValid())

        {

            CPLString osNextURL;

            int nCountRelNext = 0;

            for (int i = 0; i < oLinks.Size(); i++)

            {

                CPLJSONObject oLink = oLinks[i];

                if (!oLink.IsValid() ||

                    oLink.GetType() != CPLJSONObject::Type::Object)

                {

                    continue;

                }

                if (EQUAL(oLink.GetString("rel").c_str(), "next"))

                {

                    osNextURL = oLink.GetString("href");

                    nCountRelNext++;

                    auto type = oLink.GetString("type");