/******************************************************************************
 *
 * Project:  GDAL Core
 * Purpose:  Implementation of GDALMultiDomainMetadata class.  This class
 *           manages metadata items for a variable list of domains.
 * Author:   Frank Warmerdam, warmerdam@pobox.com
 *
 ******************************************************************************
 * Copyright (c) 2005, Frank Warmerdam <warmerdam@pobox.com>
 * Copyright (c) 2009-2011, Even Rouault <even dot rouault at spatialys.com>
 *
 * SPDX-License-Identifier: MIT
 ****************************************************************************/

#include "cpl_port.h"
#include "gdal_priv.h"

#include <cstring>

#include "cpl_conv.h"
#include "cpl_error.h"
#include "cpl_minixml.h"
#include "cpl_string.h"
#include "gdal_pam.h"

//! @cond Doxygen_Suppress
/************************************************************************/
/*                      GDALMultiDomainMetadata()                       */
/************************************************************************/

GDALMultiDomainMetadata::GDALMultiDomainMetadata() = default;

/************************************************************************/
/*                      ~GDALMultiDomainMetadata()                      */
/************************************************************************/

GDALMultiDomainMetadata::~GDALMultiDomainMetadata() = default;

/************************************************************************/
/*                               Clear()                                */
/************************************************************************/

void GDALMultiDomainMetadata::Clear()

{
    aosDomainList.clear();
    oMetadata.clear();
}

/************************************************************************/
/*                           SanitizeDomain()                           */
/************************************************************************/

static inline const char *SanitizeDomain(const char *pszDomain)
{
    return pszDomain ? pszDomain : "";
}

/************************************************************************/
/*                            GetMetadata()                             */
/************************************************************************/

char **GDALMultiDomainMetadata::GetMetadata(const char *pszDomain)

{
    const auto oIter = oMetadata.find(SanitizeDomain(pszDomain));
    if (oIter == oMetadata.end())
        return nullptr;
    return oIter->second.List();
}

/************************************************************************/
/*                            SetMetadata()                             */
/************************************************************************/

CPLErr GDALMultiDomainMetadata::SetMetadata(CSLConstList papszMetadata,
                                            const char *pszDomain)

{
    pszDomain = SanitizeDomain(pszDomain);

    auto oIter = oMetadata.find(pszDomain);
    if (oIter == oMetadata.end())
    {
        aosDomainList.AddString(pszDomain);
        oIter =
            oMetadata.insert(std::pair(aosDomainList.back(), CPLStringList()))
                .first;
    }

    auto &oMDList = oIter->second;
    oMDList = papszMetadata;

    // we want to mark name/value pair domains as being sorted for fast
    // access.
    if (!STARTS_WITH_CI(pszDomain, "xml:") &&
        !STARTS_WITH_CI(pszDomain, "json:") &&
        !EQUAL(pszDomain, "SUBDATASETS")
        // The IMD metadata domain should not be sorted, as order matters
        // when writing it back. Cf https://github.com/OSGeo/gdal/issues/11470
        && !EQUAL(pszDomain, "IMD"))
    {
        oMDList.Sort();
    }

    return CE_None;
}

/************************************************************************/
/*                          GetMetadataItem()                           */
/************************************************************************/

const char *
GDALMultiDomainMetadata::GetMetadataItem(const char *pszName,
                                         const char *pszDomain) const

{
    const auto oIter = oMetadata.find(SanitizeDomain(pszDomain));
    if (oIter == oMetadata.end())
        return nullptr;
    return oIter->second.FetchNameValue(pszName);
}

/************************************************************************/
/*                          SetMetadataItem()                           */
/************************************************************************/

CPLErr GDALMultiDomainMetadata::SetMetadataItem(const char *pszName,
                                                const char *pszValue,
                                                const char *pszDomain)

{
    pszDomain = SanitizeDomain(pszDomain);

    /* -------------------------------------------------------------------- */
    /*      Create the domain if it does not already exist.                 */
    /* -------------------------------------------------------------------- */

    auto oIter = oMetadata.find(pszDomain);
    if (oIter == oMetadata.end())
    {
        aosDomainList.AddString(pszDomain);
        oIter =
            oMetadata.insert(std::pair(aosDomainList.back(), CPLStringList()))
                .first;
    }

    /* -------------------------------------------------------------------- */
    /*      Set the value in the domain list.                               */
    /* -------------------------------------------------------------------- */
    oIter->second.SetNameValue(pszName, pszValue);

    return CE_None;
}

/************************************************************************/
/*                              XMLInit()                               */
/*                                                                      */
/*      This method should be invoked on the parent of the              */
/*      <Metadata> elements.                                            */
/************************************************************************/

int GDALMultiDomainMetadata::XMLInit(const CPLXMLNode *psTree, int /* bMerge */)
{
    const CPLXMLNode *psMetadata = nullptr;

    /* ==================================================================== */
    /*      Process all <Metadata> elements, each for one domain.           */
    /* ==================================================================== */
    for (psMetadata = psTree->psChild; psMetadata != nullptr;
         psMetadata = psMetadata->psNext)
    {
        if (psMetadata->eType != CXT_Element ||
            !EQUAL(psMetadata->pszValue, "Metadata"))
            continue;

        const char *pszDomain = CPLGetXMLValue(psMetadata, "domain", "");
        const char *pszFormat = CPLGetXMLValue(psMetadata, "format", "");

        // Make sure we have a CPLStringList for this domain,
        // without wiping out an existing one.
        if (GetMetadata(pszDomain) == nullptr)
            SetMetadata(nullptr, pszDomain);

        auto oIter = oMetadata.find(pszDomain);
        CPLAssert(oIter != oMetadata.end());

        auto &oMDList = oIter->second;

        /* --------------------------------------------------------------------
         */
        /*      XML format subdocuments. */
        /* --------------------------------------------------------------------
         */
        if (EQUAL(pszFormat, "xml"))
        {
            // Find first non-attribute child of current element.
            const CPLXMLNode *psSubDoc = psMetadata->psChild;
            while (psSubDoc != nullptr && psSubDoc->eType == CXT_Attribute)
                psSubDoc = psSubDoc->psNext;

            char *pszDoc = CPLSerializeXMLTree(psSubDoc);

            oMDList.Clear();
            oMDList.AddStringDirectly(pszDoc);
        }

        /* --------------------------------------------------------------------
         */
        /*      JSon format subdocuments. */
        /* --------------------------------------------------------------------
         */
        else if (EQUAL(pszFormat, "json"))
        {
            // Find first text child of current element.
            const CPLXMLNode *psSubDoc = psMetadata->psChild;
            while (psSubDoc != nullptr && psSubDoc->eType != CXT_Text)
                psSubDoc = psSubDoc->psNext;
            if (psSubDoc)
            {
                oMDList.Clear();
                oMDList.AddString(psSubDoc->pszValue);
            }
        }

        /* --------------------------------------------------------------------
         */
        /*      Name value format. */
        /*      <MDI key="...">value_Text</MDI> */
        /* --------------------------------------------------------------------
         */
        else
        {
            for (const CPLXMLNode *psMDI = psMetadata->psChild;
                 psMDI != nullptr; psMDI = psMDI->psNext)
            {
                if (!EQUAL(psMDI->pszValue, "MDI") ||
                    psMDI->eType != CXT_Element || psMDI->psChild == nullptr ||
                    psMDI->psChild->psNext == nullptr ||
                    psMDI->psChild->eType != CXT_Attribute ||
                    psMDI->psChild->psChild == nullptr)
                    continue;

                char *pszName = psMDI->psChild->psChild->pszValue;
                char *pszValue = psMDI->psChild->psNext->pszValue;
                if (pszName != nullptr && pszValue != nullptr)
                    oMDList.SetNameValue(pszName, pszValue);
            }
        }
    }

    return !aosDomainList.empty();
}

/************************************************************************/
/*                             Serialize()                              */
/************************************************************************/

CPLXMLNode *GDALMultiDomainMetadata::Serialize() const

{
    CPLXMLNode *psFirst = nullptr;

    for (const auto &[pszDomainName, oList] : oMetadata)
    {
        CSLConstList papszMD = oList.List();
        // Do not serialize empty domains.
        if (papszMD == nullptr || papszMD[0] == nullptr)
            continue;

        CPLXMLNode *psMD = CPLCreateXMLNode(nullptr, CXT_Element, "Metadata");

        if (strlen(pszDomainName) > 0)
            CPLCreateXMLNode(CPLCreateXMLNode(psMD, CXT_Attribute, "domain"),
                             CXT_Text, pszDomainName);

        bool bFormatXMLOrJSon = false;

        if (STARTS_WITH_CI(pszDomainName, "xml:") && CSLCount(papszMD) == 1)
        {
            CPLXMLNode *psValueAsXML = CPLParseXMLString(papszMD[0]);
            if (psValueAsXML != nullptr)
            {
                bFormatXMLOrJSon = true;

                CPLCreateXMLNode(
                    CPLCreateXMLNode(psMD, CXT_Attribute, "format"), CXT_Text,
                    "xml");

                CPLAddXMLChild(psMD, psValueAsXML);
            }
        }

        if (STARTS_WITH_CI(pszDomainName, "json:") && CSLCount(papszMD) == 1)
        {
            bFormatXMLOrJSon = true;

            CPLCreateXMLNode(CPLCreateXMLNode(psMD, CXT_Attribute, "format"),
                             CXT_Text, "json");
            CPLCreateXMLNode(psMD, CXT_Text, *papszMD);
        }

        if (!bFormatXMLOrJSon)
        {
            CPLXMLNode *psLastChild = nullptr;
            // To go after domain attribute.
            if (psMD->psChild != nullptr)
            {
                psLastChild = psMD->psChild;
                while (psLastChild->psNext != nullptr)
                    psLastChild = psLastChild->psNext;
            }
            for (int i = 0; papszMD[i] != nullptr; i++)
            {
                char *pszKey = nullptr;

                const char *pszRawValue =
                    CPLParseNameValue(papszMD[i], &pszKey);

                CPLXMLNode *psMDI =
                    CPLCreateXMLNode(nullptr, CXT_Element, "MDI");
                if (psLastChild == nullptr)
                    psMD->psChild = psMDI;
                else
                    psLastChild->psNext = psMDI;
                psLastChild = psMDI;

                CPLSetXMLValue(psMDI, "#key", pszKey);
                CPLCreateXMLNode(psMDI, CXT_Text, pszRawValue);

                CPLFree(pszKey);
            }
        }

        if (psFirst == nullptr)
            psFirst = psMD;
        else
            CPLAddXMLSibling(psFirst, psMD);
    }

    return psFirst;
}

//! @endcond
