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

 *

 * Project:  OpenGIS Simple Features Reference Implementation

 * Purpose:  Implements FileGDB relationship handling.

 * Author:   Nyall Dawson, <nyall dot dawson at gmail dot com>

 *

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

 * Copyright (c) 2022, Nyall Dawson <nyall dot dawson at gmail dot com>

 *

 * SPDX-License-Identifier: MIT

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

#ifndef FILEGDB_RELATIONSHIP_H

#define FILEGDB_RELATIONSHIP_H

#include "cpl_minixml.h"

#include "filegdb_gdbtoogrfieldtype.h"

#include "gdal.h"

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

/*                       ParseXMLFieldDomainDef()                       */

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

inline std::unique_ptr<GDALRelationship>

ParseXMLRelationshipDef(const std::string &domainDef)

{

    CPLXMLTreeCloser oTree(CPLParseXMLString(domainDef.c_str()));

    if (!oTree.get())

    {

        return nullptr;

    }

    const CPLXMLNode *psRelationship =

        CPLGetXMLNode(oTree.get(), "=DERelationshipClassInfo");

    if (psRelationship == nullptr)

    {

        CPLError(CE_Failure, CPLE_AppDefined,

                 "Cannot find root 'Relationship' node");

        return nullptr;

    }

    const char *pszName = CPLGetXMLValue(psRelationship, "Name", "");

    const char *pszOriginTableName =

        CPLGetXMLValue(psRelationship, "OriginClassNames.Name", nullptr);

    if (pszOriginTableName == nullptr)

    {

        CPLError(CE_Failure, CPLE_AppDefined,

                 "Cannot find OriginClassName table node");

        return nullptr;

    }

    const char *pszDestinationTableName =

        CPLGetXMLValue(psRelationship, "DestinationClassNames.Name", nullptr);

    if (pszDestinationTableName == nullptr)

    {

        CPLError(CE_Failure, CPLE_AppDefined,

                 "Cannot find DestinationClassNames table node");

        return nullptr;

    }

    const char *pszCardinality =

        CPLGetXMLValue(psRelationship, "Cardinality", "");

    if (pszCardinality == nullptr)

    {

        CPLError(CE_Failure, CPLE_AppDefined, "Cannot find Cardinality node");

        return nullptr;

    }

    GDALRelationshipCardinality eCardinality = GRC_ONE_TO_MANY;

    if (EQUAL(pszCardinality, "esriRelCardinalityOneToOne"))

    {

        eCardinality = GRC_ONE_TO_ONE;

    }

    else if (EQUAL(pszCardinality, "esriRelCardinalityOneToMany"))

    {

        eCardinality = GRC_ONE_TO_MANY;

    }

    else if (EQUAL(pszCardinality, "esriRelCardinalityManyToMany"))

    {

        eCardinality = GRC_MANY_TO_MANY;

    }

    else

    {

        CPLError(CE_Failure, CPLE_AppDefined, "Unknown cardinality: %s",

                 pszCardinality);

        return nullptr;

    }

    auto poRelationship = std::make_unique<GDALRelationship>(

        pszName, pszOriginTableName, pszDestinationTableName, eCardinality);

    if (eCardinality == GRC_MANY_TO_MANY)

    {

        // seems to be that the middle table name always follows the

        // relationship name?

        poRelationship->SetMappingTableName(pszName);

    }

    std::vector<std::string> aosOriginKeys;

    std::vector<std::string> aosMappingOriginKeys;

    std::vector<std::string> aosDestinationKeys;

    std::vector<std::string> aosMappingDestinationKeys;

    const CPLXMLNode *psOriginClassKeys =

        CPLGetXMLNode(psRelationship, "OriginClassKeys");

    if (psOriginClassKeys == nullptr)

    {

        CPLError(CE_Failure, CPLE_AppDefined,

                 "Cannot find OriginClassKeys node");

        return nullptr;

    }

    for (const CPLXMLNode *psIter = psOriginClassKeys->psChild; psIter;

         psIter = psIter->psNext)

    {

        if (psIter->eType == CXT_Element &&

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

        {

            const char *pszObjectKeyName =

                CPLGetXMLValue(psIter, "ObjectKeyName", "");

            if (pszObjectKeyName == nullptr)

            {

                continue;

            }

            const char *pszKeyRole = CPLGetXMLValue(psIter, "KeyRole", "");

            if (pszKeyRole == nullptr)

            {

                continue;

            }

            if (EQUAL(pszKeyRole, "esriRelKeyRoleOriginPrimary"))

            {

                aosOriginKeys.emplace_back(pszObjectKeyName);

            }

            else if (EQUAL(pszKeyRole, "esriRelKeyRoleOriginForeign"))

            {

                if (eCardinality == GRC_MANY_TO_MANY)

                    aosMappingOriginKeys.emplace_back(pszObjectKeyName);

                else

                    aosDestinationKeys.emplace_back(pszObjectKeyName);

            }

            else

            {

                CPLError(CE_Failure, CPLE_AppDefined, "Unknown KeyRole: %s",

                         pszKeyRole);

                return nullptr;

            }

        }

    }

    const CPLXMLNode *psDestinationClassKeys =

        CPLGetXMLNode(psRelationship, "DestinationClassKeys");

    if (psDestinationClassKeys != nullptr)

    {

        for (const CPLXMLNode *psIter = psDestinationClassKeys->psChild; psIter;

             psIter = psIter->psNext)

        {

            if (psIter->eType == CXT_Element &&

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

            {

                const char *pszObjectKeyName =

                    CPLGetXMLValue(psIter, "ObjectKeyName", "");

                if (pszObjectKeyName == nullptr)

                {

                    continue;

                }

                const char *pszKeyRole = CPLGetXMLValue(psIter, "KeyRole", "");

                if (pszKeyRole == nullptr)

                {

                    continue;

                }

                if (EQUAL(pszKeyRole, "esriRelKeyRoleDestinationPrimary"))

                {

                    aosDestinationKeys.emplace_back(pszObjectKeyName);

                }

                else if (EQUAL(pszKeyRole, "esriRelKeyRoleDestinationForeign"))

                {

                    aosMappingDestinationKeys.emplace_back(pszObjectKeyName);

                }

                else

                {

                    CPLError(CE_Failure, CPLE_AppDefined, "Unknown KeyRole: %s",

                             pszKeyRole);

                    return nullptr;

                }

            }

        }

    }

    poRelationship->SetLeftTableFields(aosOriginKeys);

    poRelationship->SetLeftMappingTableFields(aosMappingOriginKeys);

    poRelationship->SetRightTableFields(aosDestinationKeys);

    poRelationship->SetRightMappingTableFields(aosMappingDestinationKeys);

    const char *pszForwardPathLabel =

        CPLGetXMLValue(psRelationship, "ForwardPathLabel", "");

    if (pszForwardPathLabel != nullptr)

    {

        poRelationship->SetForwardPathLabel(pszForwardPathLabel);

    }

    const char *pszBackwardPathLabel =

        CPLGetXMLValue(psRelationship, "BackwardPathLabel", "");

    if (pszBackwardPathLabel != nullptr)

    {

        poRelationship->SetBackwardPathLabel(pszBackwardPathLabel);

    }

    const char *pszIsComposite =

        CPLGetXMLValue(psRelationship, "IsComposite", "");

    if (pszIsComposite != nullptr && EQUAL(pszIsComposite, "true"))

    {

        poRelationship->SetType(GRT_COMPOSITE);

    }

    else

    {

        poRelationship->SetType(GRT_ASSOCIATION);

    }

    const char *pszIsAttachmentRelationship =

        CPLGetXMLValue(psRelationship, "IsAttachmentRelationship", "");

    if (pszIsAttachmentRelationship != nullptr &&

        EQUAL(pszIsAttachmentRelationship, "true"))

    {

        poRelationship->SetRelatedTableType("media");

    }

    else

    {

        poRelationship->SetRelatedTableType("features");

    }

    return poRelationship;

}

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

/*                      BuildXMLRelationshipDef()                       */

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

inline std::string

BuildXMLRelationshipDef(const GDALRelationship *poRelationship, int iDsid,

                        const std::string &osMappingTableOidName,

                        std::string &failureReason)

{

    std::string osNS = "typens";

    const char *pszRootElt = "DERelationshipClassInfo";

    CPLXMLTreeCloser oTree(CPLCreateXMLNode(nullptr, CXT_Element, pszRootElt));

    CPLXMLNode *psRoot = oTree.get();

    CPLAddXMLAttributeAndValue(psRoot, "xsi:type",

                               "typens:DERelationshipClassInfo");

    CPLAddXMLAttributeAndValue(psRoot, "xmlns:xsi",

                               "http://www.w3.org/2001/XMLSchema-instance");

    CPLAddXMLAttributeAndValue(psRoot, "xmlns:xs",

                               "http://www.w3.org/2001/XMLSchema");

    CPLAddXMLAttributeAndValue(psRoot, ("xmlns:" + osNS).c_str(),

                               "http://www.esri.com/schemas/ArcGIS/10.1");

    CPLCreateXMLElementAndValue(psRoot, "CatalogPath",

                                ("\\" + poRelationship->GetName()).c_str());

    CPLCreateXMLElementAndValue(psRoot, "Name",

                                poRelationship->GetName().c_str());

    CPLCreateXMLElementAndValue(psRoot, "ChildrenExpanded", "false");

    CPLCreateXMLElementAndValue(psRoot, "DatasetType",

                                "esriDTRelationshipClass");

    CPLCreateXMLElementAndValue(psRoot, "DSID",

                                CPLString().Printf("%d", iDsid));

    CPLCreateXMLElementAndValue(psRoot, "Versioned", "false");

    CPLCreateXMLElementAndValue(psRoot, "CanVersion", "false");

    CPLCreateXMLElementAndValue(psRoot, "ConfigurationKeyword", "");

    CPLCreateXMLElementAndValue(psRoot, "RequiredGeodatabaseClientVersion",

                                "10.0");

    CPLCreateXMLElementAndValue(psRoot, "HasOID", "false");

    auto psGPFieldInfoExs =

        CPLCreateXMLNode(psRoot, CXT_Element, "GPFieldInfoExs");

    CPLAddXMLAttributeAndValue(psGPFieldInfoExs, "xsi:type",

                               "typens:ArrayOfGPFieldInfoEx");

    // for many-to-many relationships this is the OID field from the mapping

    // table

    if (poRelationship->GetCardinality() ==

        GDALRelationshipCardinality::GRC_MANY_TO_MANY)

    {

        CPLCreateXMLElementAndValue(psRoot, "OIDFieldName",

                                    osMappingTableOidName.c_str());

        // field info from mapping table

        // OID field

        auto psGPFieldInfoEx =

            CPLCreateXMLNode(psGPFieldInfoExs, CXT_Element, "GPFieldInfoEx");

        CPLAddXMLAttributeAndValue(psGPFieldInfoEx, "xsi:type",

                                   "typens:GPFieldInfoEx");

        CPLCreateXMLElementAndValue(psGPFieldInfoEx, "Name",

                                    osMappingTableOidName.c_str());

        // hopefully not required...

        // CPLCreateXMLElementAndValue(psGPFieldInfoEx, "AliasName", "false");

        // CPLCreateXMLElementAndValue(psGPFieldInfoEx, "FieldType", "false");

        // CPLCreateXMLElementAndValue(psGPFieldInfoEx, "IsNullable", "false");

        // origin foreign key field

        psGPFieldInfoEx =

            CPLCreateXMLNode(psGPFieldInfoExs, CXT_Element, "GPFieldInfoEx");

        CPLAddXMLAttributeAndValue(psGPFieldInfoEx, "xsi:type",

                                   "typens:GPFieldInfoEx");

        if (!poRelationship->GetLeftMappingTableFields().empty())

        {

            CPLCreateXMLElementAndValue(

                psGPFieldInfoEx, "Name",

                poRelationship->GetLeftMappingTableFields()[0].c_str());

        }

        // destination foreign key field

        psGPFieldInfoEx =

            CPLCreateXMLNode(psGPFieldInfoExs, CXT_Element, "GPFieldInfoEx");

        CPLAddXMLAttributeAndValue(psGPFieldInfoEx, "xsi:type",

                                   "typens:GPFieldInfoEx");

        if (!poRelationship->GetRightMappingTableFields().empty())

        {

            CPLCreateXMLElementAndValue(

                psGPFieldInfoEx, "Name",

                poRelationship->GetRightMappingTableFields()[0].c_str());

        }

    }

    else

    {

        CPLCreateXMLElementAndValue(psRoot, "OIDFieldName", "");

    }

    CPLCreateXMLElementAndValue(psRoot, "CLSID", "");

    CPLCreateXMLElementAndValue(psRoot, "EXTCLSID", "");

    auto psRelationshipClassNames =

        CPLCreateXMLNode(psRoot, CXT_Element, "RelationshipClassNames");

    CPLAddXMLAttributeAndValue(psRelationshipClassNames, "xsi:type",

                               "typens:Names");

    CPLCreateXMLElementAndValue(psRoot, "AliasName", "");

    CPLCreateXMLElementAndValue(psRoot, "ModelName", "");

    CPLCreateXMLElementAndValue(psRoot, "HasGlobalID", "false");

    CPLCreateXMLElementAndValue(psRoot, "GlobalIDFieldName", "");

    CPLCreateXMLElementAndValue(psRoot, "RasterFieldName", "");

    auto psExtensionProperties =

        CPLCreateXMLNode(psRoot, CXT_Element, "ExtensionProperties");

    CPLAddXMLAttributeAndValue(psExtensionProperties, "xsi:type",

                               "typens:PropertySet");

    auto psPropertyArray =

        CPLCreateXMLNode(psExtensionProperties, CXT_Element, "PropertyArray");

    CPLAddXMLAttributeAndValue(psPropertyArray, "xsi:type",

                               "typens:ArrayOfPropertySetProperty");

    auto psControllerMemberships =

        CPLCreateXMLNode(psRoot, CXT_Element, "ControllerMemberships");

    CPLAddXMLAttributeAndValue(psControllerMemberships, "xsi:type",

                               "typens:ArrayOfControllerMembership");

    CPLCreateXMLElementAndValue(psRoot, "EditorTrackingEnabled", "false");

    CPLCreateXMLElementAndValue(psRoot, "CreatorFieldName", "");

    CPLCreateXMLElementAndValue(psRoot, "CreatedAtFieldName", "");

    CPLCreateXMLElementAndValue(psRoot, "EditorFieldName", "");

    CPLCreateXMLElementAndValue(psRoot, "EditedAtFieldName", "");

    CPLCreateXMLElementAndValue(psRoot, "IsTimeInUTC", "true");

    switch (poRelationship->GetCardinality())

    {

        case GDALRelationshipCardinality::GRC_ONE_TO_ONE:

            CPLCreateXMLElementAndValue(psRoot, "Cardinality",

                                        "esriRelCardinalityOneToOne");

            break;

        case GDALRelationshipCardinality::GRC_ONE_TO_MANY:

            CPLCreateXMLElementAndValue(psRoot, "Cardinality",

                                        "esriRelCardinalityOneToMany");

            break;

        case GDALRelationshipCardinality::GRC_MANY_TO_MANY:

            CPLCreateXMLElementAndValue(psRoot, "Cardinality",

                                        "esriRelCardinalityManyToMany");

            break;

        case GDALRelationshipCardinality::GRC_MANY_TO_ONE:

            failureReason = "Many to one relationships are not supported";

            return {};

    }

    CPLCreateXMLElementAndValue(psRoot, "Notification",

                                "esriRelNotificationNone");

    CPLCreateXMLElementAndValue(psRoot, "IsAttributed", "false");

    switch (poRelationship->GetType())

    {

        case GDALRelationshipType::GRT_ASSOCIATION:

            CPLCreateXMLElementAndValue(psRoot, "IsComposite", "false");

            break;

        case GDALRelationshipType::GRT_COMPOSITE:

            CPLCreateXMLElementAndValue(psRoot, "IsComposite", "true");

            break;

        case GDALRelationshipType::GRT_AGGREGATION:

            failureReason = "Aggregate relationships are not supported";

            return {};

    }

    auto psOriginClassNames =

        CPLCreateXMLNode(psRoot, CXT_Element, "OriginClassNames");

    CPLAddXMLAttributeAndValue(psOriginClassNames, "xsi:type", "typens:Names");

    CPLCreateXMLElementAndValue(psOriginClassNames, "Name",

                                poRelationship->GetLeftTableName().c_str());

    auto psDestinationClassNames =

        CPLCreateXMLNode(psRoot, CXT_Element, "DestinationClassNames");

    CPLAddXMLAttributeAndValue(psDestinationClassNames, "xsi:type",

                               "typens:Names");

    CPLCreateXMLElementAndValue(psDestinationClassNames, "Name",

                                poRelationship->GetRightTableName().c_str());

    CPLCreateXMLElementAndValue(psRoot, "KeyType", "esriRelKeyTypeSingle");

    CPLCreateXMLElementAndValue(psRoot, "ClassKey", "esriRelClassKeyUndefined");

    CPLCreateXMLElementAndValue(psRoot, "ForwardPathLabel",

                                poRelationship->GetForwardPathLabel().c_str());

    CPLCreateXMLElementAndValue(psRoot, "BackwardPathLabel",

                                poRelationship->GetBackwardPathLabel().c_str());

    CPLCreateXMLElementAndValue(psRoot, "IsReflexive", "false");

    auto psOriginClassKeys =

        CPLCreateXMLNode(psRoot, CXT_Element, "OriginClassKeys");

    CPLAddXMLAttributeAndValue(psOriginClassKeys, "xsi:type",

                               "typens:ArrayOfRelationshipClassKey");

    auto psRelationshipClassKeyOrigin = CPLCreateXMLNode(

        psOriginClassKeys, CXT_Element, "RelationshipClassKey");

    CPLAddXMLAttributeAndValue(psRelationshipClassKeyOrigin, "xsi:type",

                               "typens:RelationshipClassKey");

    if (!poRelationship->GetLeftTableFields().empty())

    {

        CPLCreateXMLElementAndValue(

            psRelationshipClassKeyOrigin, "ObjectKeyName",

            poRelationship->GetLeftTableFields()[0].c_str());

    }

    CPLCreateXMLElementAndValue(psRelationshipClassKeyOrigin, "ClassKeyName",

                                "");

    CPLCreateXMLElementAndValue(psRelationshipClassKeyOrigin, "KeyRole",

                                "esriRelKeyRoleOriginPrimary");

    if (poRelationship->GetCardinality() ==

        GDALRelationshipCardinality::GRC_MANY_TO_MANY)

    {

        auto psRelationshipClassKeyOriginManyToMany = CPLCreateXMLNode(

            psOriginClassKeys, CXT_Element, "RelationshipClassKey");

        CPLAddXMLAttributeAndValue(psRelationshipClassKeyOriginManyToMany,

                                   "xsi:type", "typens:RelationshipClassKey");

        if (!poRelationship->GetLeftMappingTableFields().empty())

        {

            CPLCreateXMLElementAndValue(

                psRelationshipClassKeyOriginManyToMany, "ObjectKeyName",

                poRelationship->GetLeftMappingTableFields()[0].c_str());

        }

        CPLCreateXMLElementAndValue(psRelationshipClassKeyOriginManyToMany,

                                    "ClassKeyName", "");

        CPLCreateXMLElementAndValue(psRelationshipClassKeyOriginManyToMany,

                                    "KeyRole", "esriRelKeyRoleOriginForeign");

    }

    if (poRelationship->GetCardinality() !=

        GDALRelationshipCardinality::GRC_MANY_TO_MANY)

    {

        auto psRelationshipClassKeyForeign = CPLCreateXMLNode(

            psOriginClassKeys, CXT_Element, "RelationshipClassKey");

        CPLAddXMLAttributeAndValue(psRelationshipClassKeyForeign, "xsi:type",

                                   "typens:RelationshipClassKey");

        if (!poRelationship->GetRightTableFields().empty())

        {

            CPLCreateXMLElementAndValue(

                psRelationshipClassKeyForeign, "ObjectKeyName",

                poRelationship->GetRightTableFields()[0].c_str());

        }

        CPLCreateXMLElementAndValue(psRelationshipClassKeyForeign,

                                    "ClassKeyName", "");

        CPLCreateXMLElementAndValue(psRelationshipClassKeyForeign, "KeyRole",

                                    "esriRelKeyRoleOriginForeign");

    }

    else

    {

        auto psDestinationClassKeys =

            CPLCreateXMLNode(psRoot, CXT_Element, "DestinationClassKeys");

        CPLAddXMLAttributeAndValue(psDestinationClassKeys, "xsi:type",

                                   "typens:ArrayOfRelationshipClassKey");

        auto psRelationshipClassKeyForeign = CPLCreateXMLNode(

            psDestinationClassKeys, CXT_Element, "RelationshipClassKey");

        CPLAddXMLAttributeAndValue(psRelationshipClassKeyForeign, "xsi:type",

                                   "typens:RelationshipClassKey");

        if (!poRelationship->GetRightTableFields().empty())

        {

            CPLCreateXMLElementAndValue(

                psRelationshipClassKeyForeign, "ObjectKeyName",

                poRelationship->GetRightTableFields()[0].c_str());

        }

        CPLCreateXMLElementAndValue(psRelationshipClassKeyForeign,

                                    "ClassKeyName", "");

        CPLCreateXMLElementAndValue(psRelationshipClassKeyForeign, "KeyRole",

                                    "esriRelKeyRoleDestinationPrimary");

        auto psRelationshipClassKeyForeignManyToMany = CPLCreateXMLNode(

            psDestinationClassKeys, CXT_Element, "RelationshipClassKey");

        CPLAddXMLAttributeAndValue(psRelationshipClassKeyForeignManyToMany,

                                   "xsi:type", "typens:RelationshipClassKey");

        if (!poRelationship->GetRightMappingTableFields().empty())

        {

            CPLCreateXMLElementAndValue(

                psRelationshipClassKeyForeignManyToMany, "ObjectKeyName",

                poRelationship->GetRightMappingTableFields()[0].c_str());

        }

        CPLCreateXMLElementAndValue(psRelationshipClassKeyForeignManyToMany,

                                    "ClassKeyName", "");

        CPLCreateXMLElementAndValue(psRelationshipClassKeyForeignManyToMany,

                                    "KeyRole",

                                    "esriRelKeyRoleDestinationForeign");

    }

    auto psRelationshipRules =

        CPLCreateXMLNode(psRoot, CXT_Element, "RelationshipRules");

    CPLAddXMLAttributeAndValue(psRelationshipRules, "xsi:type",

                               "typens:ArrayOfRelationshipRule");

    CPLCreateXMLElementAndValue(

        psRoot, "IsAttachmentRelationship",

        poRelationship->GetRelatedTableType() == "media" ? "true" : "false");

    CPLCreateXMLElementAndValue(psRoot, "ChangeTracked", "false");

    CPLCreateXMLElementAndValue(psRoot, "ReplicaTracked", "false");

    char *pszXML = CPLSerializeXMLTree(oTree.get());

    std::string osXML(pszXML);

    CPLFree(pszXML);

    return osXML;

}

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

/*                    BuildXMLRelationshipItemInfo()                    */

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

inline std::string

BuildXMLRelationshipItemInfo(const GDALRelationship *poRelationship,

                             std::string & /*failureReason*/)

{

    CPLXMLTreeCloser oTree(

        CPLCreateXMLNode(nullptr, CXT_Element, "ESRI_ItemInformation"));

    CPLXMLNode *psRoot = oTree.get();

    CPLAddXMLAttributeAndValue(psRoot, "culture", "");

    CPLCreateXMLElementAndValue(psRoot, "name",

                                poRelationship->GetName().c_str());

    CPLCreateXMLElementAndValue(psRoot, "catalogPath",

                                ("\\" + poRelationship->GetName()).c_str());

    CPLCreateXMLElementAndValue(psRoot, "snippet", "");

    CPLCreateXMLElementAndValue(psRoot, "description", "");

    CPLCreateXMLElementAndValue(psRoot, "summary", "");

    CPLCreateXMLElementAndValue(psRoot, "title",

                                poRelationship->GetName().c_str());

    CPLCreateXMLElementAndValue(psRoot, "tags", "");

    CPLCreateXMLElementAndValue(psRoot, "type",

                                "File Geodatabase Relationship Class");

    auto psTypeKeywords = CPLCreateXMLNode(psRoot, CXT_Element, "typeKeywords");

    CPLCreateXMLElementAndValue(psTypeKeywords, "typekeyword", "Data");

    CPLCreateXMLElementAndValue(psTypeKeywords, "typekeyword", "Dataset");

    CPLCreateXMLElementAndValue(psTypeKeywords, "typekeyword", "Vector Data");

    CPLCreateXMLElementAndValue(psTypeKeywords, "typekeyword", "Feature Data");

    CPLCreateXMLElementAndValue(psTypeKeywords, "typekeyword",

                                "File Geodatabase");

    CPLCreateXMLElementAndValue(psTypeKeywords, "typekeyword", "GDB");

    CPLCreateXMLElementAndValue(psTypeKeywords, "typekeyword",

                                "Relationship Class");

    CPLCreateXMLElementAndValue(psRoot, "url", "");

    CPLCreateXMLElementAndValue(psRoot, "datalastModifiedTime", "");

    auto psExtent = CPLCreateXMLNode(psRoot, CXT_Element, "extent");

    CPLCreateXMLElementAndValue(psExtent, "xmin", "");

    CPLCreateXMLElementAndValue(psExtent, "ymin", "");

    CPLCreateXMLElementAndValue(psExtent, "xmax", "");

    CPLCreateXMLElementAndValue(psExtent, "ymax", "");

    CPLCreateXMLElementAndValue(psRoot, "minScale", "0");

    CPLCreateXMLElementAndValue(psRoot, "maxScale", "0");

    CPLCreateXMLElementAndValue(psRoot, "spatialReference", "");

    CPLCreateXMLElementAndValue(psRoot, "accessInformation", "");

    CPLCreateXMLElementAndValue(psRoot, "licenseInfo", "");

    CPLCreateXMLElementAndValue(psRoot, "typeID", "fgdb_relationship");

    CPLCreateXMLElementAndValue(psRoot, "isContainer", "false");

    CPLCreateXMLElementAndValue(psRoot, "browseDialogOnly", "false");

    CPLCreateXMLElementAndValue(psRoot, "propNames", "");

    CPLCreateXMLElementAndValue(psRoot, "propValues", "");

    char *pszXML = CPLSerializeXMLTree(oTree.get());

    std::string osXML(pszXML);

    CPLFree(pszXML);

    return osXML;

}

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

/*                 BuildXMLRelationshipDocumentation()                  */

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

inline std::string

BuildXMLRelationshipDocumentation(const GDALRelationship * /*poRelationship*/,

                                  std::string & /*failureReason*/)

{

    CPLXMLTreeCloser oTree(CPLCreateXMLNode(nullptr, CXT_Element, "metadata"));

    CPLXMLNode *psRoot = oTree.get();

    CPLAddXMLAttributeAndValue(psRoot, "xml:lang", "en");

    auto psEsri = CPLCreateXMLNode(psRoot, CXT_Element, "Esri");

    CPLCreateXMLElementAndValue(psEsri, "CreaDate", "");

    CPLCreateXMLElementAndValue(psEsri, "CreaTime", "");

    CPLCreateXMLElementAndValue(psEsri, "ArcGISFormat", "1.0");

    CPLCreateXMLElementAndValue(psEsri, "SyncOnce", "TRUE");

    auto psDataProperties =

        CPLCreateXMLNode(psEsri, CXT_Element, "DataProperties");

    CPLCreateXMLNode(psDataProperties, CXT_Element, "lineage");

    char *pszXML = CPLSerializeXMLTree(oTree.get());

    std::string osXML(pszXML);

    CPLFree(pszXML);

    return osXML;

}

#endif  // FILEGDB_RELATIONSHIP_H