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

 *

 * Project:  GML registry

 * Purpose:  GML reader

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

 *

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

 * Copyright (c) 2013, Even Rouault <even dot rouault at spatialys.com>

 *

 * SPDX-License-Identifier: MIT

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

#include "cpl_port.h"

#include "gmlregistry.h"

#include <cstring>

#include "cpl_conv.h"

#ifdef EMBED_RESOURCE_FILES

#include "embedded_resources.h"

#endif

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

/*                               Parse()                                */

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

bool GMLRegistry::Parse()

{

#ifndef USE_ONLY_EMBEDDED_RESOURCE_FILES

    if (osRegistryPath.empty())

    {

#ifdef EMBED_RESOURCE_FILES

        CPLErrorStateBackuper oErrorStateBackuper(CPLQuietErrorHandler);

#endif

        const char *pszFilename = CPLFindFile("gdal", "gml_registry.xml");

        if (pszFilename)

            osRegistryPath = pszFilename;

    }

#endif

    CPLXMLNode *psRootNode = nullptr;

    if (!osRegistryPath.empty())

    {

        psRootNode = CPLParseXMLFile(osRegistryPath);

    }

#ifdef EMBED_RESOURCE_FILES

    else

    {

        const char *pszContent = GMLGetFileContent("gml_registry.xml");

        if (pszContent)

        {

            static const bool bOnce [[maybe_unused]] = []()

            {

                CPLDebug("GML", "Using embedded gml_registry.xml");

                return true;

            }();

            psRootNode = CPLParseXMLString(pszContent);

        }

    }

#endif

    if (psRootNode == nullptr)

        return false;

    CPLXMLNode *psRegistryNode = CPLGetXMLNode(psRootNode, "=gml_registry");

    if (psRegistryNode == nullptr)

    {

        CPLDestroyXMLNode(psRootNode);

        return false;

    }

    CPLXMLNode *psIter = psRegistryNode->psChild;

    while (psIter != nullptr)

    {

        if (psIter->eType == CXT_Element &&

            strcmp(psIter->pszValue, "namespace") == 0)

        {

            GMLRegistryNamespace oNameSpace;

            if (oNameSpace.Parse(osRegistryPath, psIter))

            {

                aoNamespaces.push_back(std::move(oNameSpace));

            }

        }

        psIter = psIter->psNext;

    }

    CPLDestroyXMLNode(psRootNode);

    return true;

}

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

/*                               Parse()                                */

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

bool GMLRegistryNamespace::Parse(const char *pszRegistryFilename,

                                 CPLXMLNode *psNode)

{

    const char *pszPrefix = CPLGetXMLValue(psNode, "prefix", "");

    const char *pszURI = CPLGetXMLValue(psNode, "uri", nullptr);

    if (pszURI == nullptr)

        return false;

    osPrefix = pszPrefix;

    osURI = pszURI;

    const char *pszUseGlobalSRSName =

        CPLGetXMLValue(psNode, "useGlobalSRSName", nullptr);

    if (pszUseGlobalSRSName != nullptr &&

        strcmp(pszUseGlobalSRSName, "true") == 0)

        bUseGlobalSRSName = true;

    CPLXMLNode *psIter = psNode->psChild;

    while (psIter != nullptr)

    {

        if (psIter->eType == CXT_Element &&

            strcmp(psIter->pszValue, "featureType") == 0)

        {

            GMLRegistryFeatureType oFeatureType;

            if (oFeatureType.Parse(pszRegistryFilename, psIter))

            {

                aoFeatureTypes.push_back(std::move(oFeatureType));

            }

        }

        psIter = psIter->psNext;

    }

    return true;

}

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

/*                               Parse()                                */

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

bool GMLRegistryFeatureType::Parse(const char *pszRegistryFilename,

                                   CPLXMLNode *psNode)

{

    const char *pszElementName = CPLGetXMLValue(psNode, "elementName", nullptr);

    osSchemaLocation = CPLGetXMLValue(psNode, "schemaLocation", "");

    osGFSSchemaLocation = CPLGetXMLValue(psNode, "gfsSchemaLocation", "");

    if (pszElementName == nullptr ||

        (osSchemaLocation.empty() && osGFSSchemaLocation.empty()))

        return false;

    const char *pszElementValue =

        CPLGetXMLValue(psNode, "elementValue", nullptr);

    osElementName = pszElementName;

    if (!osSchemaLocation.empty())

    {

        if (pszRegistryFilename[0] &&

            !STARTS_WITH(osSchemaLocation.c_str(), "http://") &&

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

            CPLIsFilenameRelative(osSchemaLocation.c_str()))

        {

            osSchemaLocation =

                CPLFormFilenameSafe(CPLGetPathSafe(pszRegistryFilename).c_str(),

                                    osSchemaLocation.c_str(), nullptr);

        }

    }

    else if (!osGFSSchemaLocation.empty())

    {

        if (pszRegistryFilename[0] &&

            !STARTS_WITH(osGFSSchemaLocation.c_str(), "http://") &&

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

            CPLIsFilenameRelative(osGFSSchemaLocation.c_str()))

        {

            osGFSSchemaLocation =

                CPLFormFilenameSafe(CPLGetPathSafe(pszRegistryFilename).c_str(),

                                    osGFSSchemaLocation.c_str(), nullptr);

        }

    }

    if (pszElementValue != nullptr)

    {

        osElementValue = pszElementValue;

    }

    return true;

}