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

 *

 * Project:  OpenGIS Simple Features Reference Implementation

 * Purpose:  OGR C API "Spy"

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

 *

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

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

 *

 * SPDX-License-Identifier: MIT

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

#include "cpl_port.h"

#include "cpl_multiproc.h"

#include "ograpispy.h"

#include <cassert>

#include <cstdio>

#include <map>

#include <set>

#include "cpl_string.h"

#include "gdal.h"

#include "ogr_geometry.h"

#include "ogr_feature.h"

#include "ogr_spatialref.h"

#include "ogrsf_frmts.h"

#ifdef OGRAPISPY_ENABLED

int bOGRAPISpyEnabled = FALSE;

static CPLMutex *hOGRAPISpyMutex = nullptr;

static CPLString osSnapshotPath;

static CPLString osSpyFile;

static FILE *fpSpyFile = nullptr;

// Keep in sync with cpl_conv.cpp

void OGRAPISPYCPLSetConfigOption(const char *, const char *);

void OGRAPISPYCPLSetThreadLocalConfigOption(const char *, const char *);

namespace

{

class LayerDescription

{

  public:

    int iLayer = -1;

    LayerDescription() = default;

    explicit LayerDescription(int iLayerIn) : iLayer(iLayerIn)

    {

    }

};

class DatasetDescription

{

  public:

    int iDS = -1;

    std::map<OGRLayerH, LayerDescription> oMapLayer{};

    DatasetDescription() = default;

    explicit DatasetDescription(int iDSIn) : iDS(iDSIn)

    {

    }

    DatasetDescription &operator=(DatasetDescription &&) = default;

    ~DatasetDescription();

};

class FeatureDefnDescription

{

  public:

    OGRFeatureDefnH hFDefn = nullptr;

    int iUniqueNumber = -1;

    std::map<OGRFieldDefnH, int> oMapFieldDefn{};

    std::map<OGRGeomFieldDefnH, int> oMapGeomFieldDefn{};

    FeatureDefnDescription() = default;

    FeatureDefnDescription(OGRFeatureDefnH hFDefnIn, int iUniqueNumberIn)

        : hFDefn(hFDefnIn), iUniqueNumber(iUniqueNumberIn)

    {

    }

    FeatureDefnDescription(const FeatureDefnDescription &) = default;

    FeatureDefnDescription &operator=(const FeatureDefnDescription &) = default;

    void Free();

};

}  // namespace

static std::map<GDALDatasetH, DatasetDescription> oMapDS;

static std::set<int> oSetDSIndex;

static std::map<OGRLayerH, CPLString> oGlobalMapLayer;

static OGRLayerH hLayerGetNextFeature = nullptr;

static OGRLayerH hLayerGetLayerDefn = nullptr;

static bool bDeferGetFieldCount = false;

static int nGetNextFeatureCalls = 0;

static std::set<CPLString> aoSetCreatedDS;

static std::map<OGRFeatureDefnH, FeatureDefnDescription> oMapFDefn;

static std::map<OGRGeomFieldDefnH, CPLString> oGlobalMapGeomFieldDefn;

static std::map<OGRFieldDefnH, CPLString> oGlobalMapFieldDefn;

void FeatureDefnDescription::Free()

{

    {

        std::map<OGRGeomFieldDefnH, int>::iterator oIter =

            oMapGeomFieldDefn.begin();

        for (; oIter != oMapGeomFieldDefn.end(); ++oIter)

            oGlobalMapGeomFieldDefn.erase(oIter->first);

    }

    {

        std::map<OGRFieldDefnH, int>::iterator oIter = oMapFieldDefn.begin();

        for (; oIter != oMapFieldDefn.end(); ++oIter)

            oGlobalMapFieldDefn.erase(oIter->first);

    }

}

DatasetDescription::~DatasetDescription()

{

    {

        std::map<OGRLayerH, LayerDescription>::iterator oIter =

            oMapLayer.begin();

        for (; oIter != oMapLayer.end(); ++oIter)

            oGlobalMapLayer.erase(oIter->first);

    }

}

void OGRAPISpyDestroyMutex()

{

    if (hOGRAPISpyMutex)

    {

        CPLDestroyMutex(hOGRAPISpyMutex);

        hOGRAPISpyMutex = nullptr;

        aoSetCreatedDS.clear();

        oMapFDefn.clear();

        oGlobalMapGeomFieldDefn.clear();

        oGlobalMapFieldDefn.clear();

    }

}

static void OGRAPISpyFileReopen()

{

    if (fpSpyFile == nullptr)

    {

        fpSpyFile = fopen(osSpyFile, "ab");

        if (fpSpyFile == nullptr)

            fpSpyFile = stderr;

    }

}

static void OGRAPISpyFileClose()

{

    if (fpSpyFile != stdout && fpSpyFile != stderr)

    {

        fclose(fpSpyFile);

        fpSpyFile = nullptr;

    }

}

static bool OGRAPISpyEnabled()

{

    if (bOGRAPISpyEnabled < 0)

        return false;

    const char *pszSpyFile = CPLGetConfigOption("OGR_API_SPY_FILE", nullptr);

    bOGRAPISpyEnabled = pszSpyFile != nullptr;

    if (!bOGRAPISpyEnabled)

    {

        osSpyFile.resize(0);

        aoSetCreatedDS.clear();

        return false;

    }

    if (!osSpyFile.empty())

        return true;

    CPLMutexHolderD(&hOGRAPISpyMutex);

    if (!osSpyFile.empty())

        return true;

    osSpyFile = pszSpyFile;

    const char *pszSnapshotPath =

        CPLGetConfigOption("OGR_API_SPY_SNAPSHOT_PATH", ".");

    if (EQUAL(pszSnapshotPath, "NO"))

        osSnapshotPath = "";

    else

        osSnapshotPath = pszSnapshotPath;

    if (EQUAL(pszSpyFile, "stdout"))

        fpSpyFile = stdout;

    else if (EQUAL(pszSpyFile, "stderr"))

        fpSpyFile = stderr;

    else

        fpSpyFile = fopen(pszSpyFile, "wb");

    if (fpSpyFile == nullptr)

        fpSpyFile = stderr;

    assert(fpSpyFile != nullptr);

    fprintf(fpSpyFile,

            "# This file is generated by the OGR_API_SPY mechanism.\n");

    fprintf(fpSpyFile, "import os\n");

    fprintf(fpSpyFile, "import shutil\n");

    fprintf(fpSpyFile, "from osgeo import gdal\n");

    fprintf(fpSpyFile, "from osgeo import ogr\n");

    fprintf(fpSpyFile, "from osgeo import osr\n");

    // To make pyflakes happy in case it is unused later.

    fprintf(fpSpyFile, "os.access\n");

    fprintf(fpSpyFile, "shutil.copy\n");  // Same here.

    fprintf(fpSpyFile, "\n");

    return true;

}

static CPLString OGRAPISpyGetOptions(CSLConstList papszOptions)

{

    if (papszOptions == nullptr)

    {

        return "[]";

    }

    CPLString options = "[";

    for (CSLConstList papszIter = papszOptions; *papszIter != nullptr;

         papszIter++)

    {

        if (papszIter != papszOptions)

            options += ", ";

        options += "'";

        options += *papszIter;

        options += "'";

    }

    options += "]";

    return options;

}

static CPLString OGRAPISpyGetString(const char *pszStr)

{

    if (pszStr == nullptr)

        return "None";

    CPLString osRet = "'";

    while (*pszStr)

    {

        if (*pszStr == '\'')

            osRet += "\\'";

        else if (*pszStr == '\\')

            osRet += "\\\\";

        else

            osRet += *pszStr;

        pszStr++;

    }

    osRet += "'";

    return osRet;

}

static CPLString OGRAPISpyGetDSVar(GDALDatasetH hDS)

{

    if (hDS && oMapDS.find(hDS) == oMapDS.end())

    {

        int i = 1;

        while (oSetDSIndex.find(i) != oSetDSIndex.end())

            i++;

        oMapDS[hDS] = DatasetDescription(i);

        oSetDSIndex.insert(i);

    }

    return CPLSPrintf("ds%d", hDS ? oMapDS[hDS].iDS : 0);

}

static CPLString OGRAPISpyGetLayerVar(OGRLayerH hLayer)

{

    return oGlobalMapLayer[hLayer];

}

static CPLString OGRAPISpyGetAndRegisterLayerVar(GDALDatasetH hDS,

                                                 OGRLayerH hLayer)

{

    DatasetDescription &dd = oMapDS[hDS];

    if (hLayer && dd.oMapLayer.find(hLayer) == dd.oMapLayer.end())

    {

        const int i = static_cast<int>(dd.oMapLayer.size()) + 1;

        dd.oMapLayer[hLayer] = LayerDescription(i);

        oGlobalMapLayer[hLayer] =

            OGRAPISpyGetDSVar(hDS) + "_" + CPLSPrintf("lyr%d", i);

    }

    return OGRAPISpyGetDSVar(hDS) + "_" +

           CPLSPrintf("lyr%d", hLayer ? dd.oMapLayer[hLayer].iLayer : 0);

}

static CPLString OGRAPISpyGetSRS(OGRSpatialReferenceH hSpatialRef)

{

    if (hSpatialRef == nullptr)

        return "None";

    char *pszWKT = nullptr;

    OGRSpatialReference::FromHandle(hSpatialRef)->exportToWkt(&pszWKT);

    const char *pszRet =

        CPLSPrintf(R"(osr.SpatialReference("""%s"""))", pszWKT);

    CPLFree(pszWKT);

    return pszRet;

}

static CPLString OGRAPISpyGetGeom(OGRGeometryH hGeom)

{

    if (hGeom == nullptr)

        return "None";

    char *pszWKT = nullptr;

    OGRGeometry::FromHandle(hGeom)->exportToWkt(&pszWKT);

    const char *pszRet = CPLSPrintf("ogr.CreateGeometryFromWkt('%s')", pszWKT);

    CPLFree(pszWKT);

    return pszRet;

}

#define casePrefixOgrDot(x)                                                    \

    case x:                                                                    \

        return "ogr." #x;

static CPLString OGRAPISpyGetGeomType(OGRwkbGeometryType eType)

{

    switch (eType)

    {

        casePrefixOgrDot(wkbUnknown) casePrefixOgrDot(wkbPoint) casePrefixOgrDot(wkbLineString) casePrefixOgrDot(

            wkbPolygon) casePrefixOgrDot(wkbMultiPoint) casePrefixOgrDot(wkbMultiLineString)

            casePrefixOgrDot(wkbMultiPolygon) casePrefixOgrDot(wkbGeometryCollection) casePrefixOgrDot(

                wkbCircularString) casePrefixOgrDot(wkbCompoundCurve) casePrefixOgrDot(wkbCurvePolygon)

                casePrefixOgrDot(wkbMultiCurve) casePrefixOgrDot(wkbMultiSurface) casePrefixOgrDot(

                    wkbCurve) casePrefixOgrDot(wkbSurface) casePrefixOgrDot(wkbNone) casePrefixOgrDot(wkbLinearRing)

                    casePrefixOgrDot(wkbCircularStringZ) casePrefixOgrDot(wkbCompoundCurveZ) casePrefixOgrDot(

                        wkbCurvePolygonZ) casePrefixOgrDot(wkbMultiCurveZ) casePrefixOgrDot(wkbMultiSurfaceZ)

                        casePrefixOgrDot(wkbCurveZ) casePrefixOgrDot(wkbSurfaceZ) casePrefixOgrDot(

                            wkbPoint25D) casePrefixOgrDot(wkbLineString25D) casePrefixOgrDot(wkbPolygon25D)

                            casePrefixOgrDot(wkbMultiPoint25D) casePrefixOgrDot(wkbMultiLineString25D) casePrefixOgrDot(

                                wkbMultiPolygon25D) casePrefixOgrDot(wkbGeometryCollection25D)

                                casePrefixOgrDot(wkbPolyhedralSurface) casePrefixOgrDot(

                                    wkbTIN) casePrefixOgrDot(wkbTriangle) casePrefixOgrDot(wkbPolyhedralSurfaceZ)

                                    casePrefixOgrDot(wkbTINZ) casePrefixOgrDot(wkbTriangleZ) casePrefixOgrDot(

                                        wkbPointM) casePrefixOgrDot(wkbLineStringM) casePrefixOgrDot(wkbPolygonM)

                                        casePrefixOgrDot(wkbMultiPointM) casePrefixOgrDot(

                                            wkbMultiLineStringM) casePrefixOgrDot(wkbMultiPolygonM)

                                            casePrefixOgrDot(wkbGeometryCollectionM) casePrefixOgrDot(

                                                wkbCircularStringM) casePrefixOgrDot(wkbCompoundCurveM)

                                                casePrefixOgrDot(wkbCurvePolygonM) casePrefixOgrDot(

                                                    wkbMultiCurveM) casePrefixOgrDot(wkbMultiSurfaceM)

                                                    casePrefixOgrDot(wkbCurveM) casePrefixOgrDot(

                                                        wkbSurfaceM) casePrefixOgrDot(wkbPolyhedralSurfaceM)

                                                        casePrefixOgrDot(wkbTINM) casePrefixOgrDot(

                                                            wkbTriangleM) casePrefixOgrDot(wkbPointZM)

                                                            casePrefixOgrDot(wkbLineStringZM) casePrefixOgrDot(

                                                                wkbPolygonZM) casePrefixOgrDot(wkbMultiPointZM)

                                                                casePrefixOgrDot(wkbMultiLineStringZM) casePrefixOgrDot(

                                                                    wkbMultiPolygonZM) casePrefixOgrDot(wkbGeometryCollectionZM)

                                                                    casePrefixOgrDot(wkbCircularStringZM) casePrefixOgrDot(

                                                                        wkbCompoundCurveZM)

                                                                        casePrefixOgrDot(wkbCurvePolygonZM) casePrefixOgrDot(

                                                                            wkbMultiCurveZM)

                                                                            casePrefixOgrDot(

                                                                                wkbMultiSurfaceZM)

                                                                                casePrefixOgrDot(

                                                                                    wkbCurveZM)

                                                                                    casePrefixOgrDot(

                                                                                        wkbSurfaceZM)

                                                                                        casePrefixOgrDot(

                                                                                            wkbPolyhedralSurfaceZM)

                                                                                            casePrefixOgrDot(

                                                                                                wkbTriangleZM)

                                                                                                casePrefixOgrDot(

                                                                                                    wkbTINZM)

    }

    return "error";

}

static CPLString OGRAPISpyGetFieldType(OGRFieldType eType)

{

    switch (eType)

    {

        casePrefixOgrDot(OFTInteger) casePrefixOgrDot(OFTInteger64)

            casePrefixOgrDot(OFTIntegerList) casePrefixOgrDot(OFTInteger64List)

                casePrefixOgrDot(OFTReal) casePrefixOgrDot(OFTRealList)

                    casePrefixOgrDot(OFTString) casePrefixOgrDot(OFTStringList)

                        casePrefixOgrDot(OFTWideString)

                            casePrefixOgrDot(OFTWideStringList)

                                casePrefixOgrDot(OFTBinary)

                                    casePrefixOgrDot(OFTDate)

                                        casePrefixOgrDot(OFTTime)

                                            casePrefixOgrDot(OFTDateTime)

    }

    return "error";

}

#undef casePrefixOgrDot

static CPLString OGRAPISpyGetFeatureDefnVar(OGRFeatureDefnH hFDefn)

{

    std::map<OGRFeatureDefnH, FeatureDefnDescription>::iterator oIter =

        oMapFDefn.find(hFDefn);

    int i = 0;

    if (oIter == oMapFDefn.end())

    {

        i = static_cast<int>(oMapFDefn.size()) + 1;

        oMapFDefn[hFDefn] = FeatureDefnDescription(hFDefn, i);

        // So that we can check when they are no longer used.

        OGRFeatureDefn::FromHandle(hFDefn)->Reference();

    }

    else

    {

        i = oIter->second.iUniqueNumber;

    }

    return CPLSPrintf("fdefn%d", i);

}

static void OGRAPISpyFlushDefered()

{

    OGRAPISpyFileReopen();

    if (hLayerGetLayerDefn != nullptr)

    {

        OGRFeatureDefnH hDefn = OGRFeatureDefn::ToHandle(

            OGRLayer::FromHandle(hLayerGetLayerDefn)->GetLayerDefn());

        fprintf(fpSpyFile, "%s = %s.GetLayerDefn()\n",

                OGRAPISpyGetFeatureDefnVar(hDefn).c_str(),

                OGRAPISpyGetLayerVar(hLayerGetLayerDefn).c_str());

        if (bDeferGetFieldCount)

        {

            fprintf(fpSpyFile, "%s.GetFieldCount()\n",

                    OGRAPISpyGetFeatureDefnVar(hDefn).c_str());

            bDeferGetFieldCount = false;

        }

        hLayerGetLayerDefn = nullptr;

    }

    if (nGetNextFeatureCalls == 1)

    {

        fprintf(fpSpyFile, "%s.GetNextFeature()\n",

                OGRAPISpyGetLayerVar(hLayerGetNextFeature).c_str());

        hLayerGetNextFeature = nullptr;

        nGetNextFeatureCalls = 0;

    }

    else if (nGetNextFeatureCalls > 0)

    {

        fprintf(fpSpyFile, "for i in range(%d):\n", nGetNextFeatureCalls);

        fprintf(fpSpyFile, "    %s.GetNextFeature()\n",

                OGRAPISpyGetLayerVar(hLayerGetNextFeature).c_str());

        hLayerGetNextFeature = nullptr;

        nGetNextFeatureCalls = 0;

    }

}

int OGRAPISpyOpenTakeSnapshot(const char *pszName, int bUpdate)

{

    if (!OGRAPISpyEnabled() || !bUpdate || osSnapshotPath.empty() ||

        aoSetCreatedDS.find(pszName) != aoSetCreatedDS.end())

        return -1;

    OGRAPISpyFlushDefered();

    VSIStatBufL sStat;

    if (VSIStatL(pszName, &sStat) == 0)

    {

        bOGRAPISpyEnabled = -1;

        GDALDatasetH hDS =

            GDALOpenEx(pszName, GDAL_OF_VECTOR, nullptr, nullptr, nullptr);

        char **papszFileList =

            hDS ? GDALDataset::FromHandle(hDS)->GetFileList() : nullptr;

        GDALClose(hDS);

        bOGRAPISpyEnabled = true;

        if (papszFileList)

        {

            int i = 1;

            CPLString osBaseDir;

            CPLString osSrcDir;

            CPLString osWorkingDir;

            while (true)

            {

                osBaseDir = CPLFormFilenameSafe(

                    osSnapshotPath, CPLSPrintf("snapshot_%d", i), nullptr);

                if (VSIStatL(osBaseDir, &sStat) != 0)

                    break;

                i++;

            }

            VSIMkdir(osSnapshotPath, 0777);

            VSIMkdir(osBaseDir, 0777);

            osSrcDir = CPLFormFilenameSafe(osBaseDir, "source", nullptr);

            VSIMkdir(osSrcDir, 0777);

            osWorkingDir = CPLFormFilenameSafe(osBaseDir, "working", nullptr);

            VSIMkdir(osWorkingDir, 0777);

            OGRAPISpyFileReopen();

            fprintf(fpSpyFile, "# Take snapshot of %s\n", pszName);

            fprintf(fpSpyFile, "try:\n");

            fprintf(fpSpyFile, "    shutil.rmtree('%s')\n",

                    osWorkingDir.c_str());

            fprintf(fpSpyFile, "except:\n");

            fprintf(fpSpyFile, "    pass\n");

            fprintf(fpSpyFile, "os.mkdir('%s')\n", osWorkingDir.c_str());

            for (char **papszIter = papszFileList; *papszIter; papszIter++)

            {

                CPLString osSnapshotSrcFile = CPLFormFilenameSafe(

                    osSrcDir, CPLGetFilename(*papszIter), nullptr);

                CPLString osSnapshotWorkingFile = CPLFormFilenameSafe(

                    osWorkingDir, CPLGetFilename(*papszIter), nullptr);

                CPL_IGNORE_RET_VAL(CPLCopyFile(osSnapshotSrcFile, *papszIter));

                CPL_IGNORE_RET_VAL(

                    CPLCopyFile(osSnapshotWorkingFile, *papszIter));

                fprintf(fpSpyFile, "shutil.copy('%s', '%s')\n",

                        osSnapshotSrcFile.c_str(),

                        osSnapshotWorkingFile.c_str());

            }

            CSLDestroy(papszFileList);

            return i;

        }

    }

    return -1;

}

void OGRAPISpyOpen(const char *pszName, int bUpdate, int iSnapshot,

                   GDALDatasetH *phDS)

{

    if (!OGRAPISpyEnabled())

        return;

    CPLMutexHolderD(&hOGRAPISpyMutex);

    OGRAPISpyFlushDefered();

    CPLString osName;

    if (iSnapshot > 0)

    {

        CPLString osBaseDir = CPLFormFilenameSafe(

            osSnapshotPath, CPLSPrintf("snapshot_%d", iSnapshot), nullptr);

        CPLString osWorkingDir =

            CPLFormFilenameSafe(osBaseDir, "working", nullptr);

        osName =

            CPLFormFilenameSafe(osWorkingDir, CPLGetFilename(pszName), nullptr);

        pszName = osName.c_str();

        if (*phDS != nullptr)

        {

            bOGRAPISpyEnabled = -1;

            GDALClose(GDALDataset::FromHandle(*phDS));

            *phDS = GDALOpenEx(pszName, GDAL_OF_VECTOR | GDAL_OF_UPDATE,

                               nullptr, nullptr, nullptr);

            bOGRAPISpyEnabled = true;

        }

    }

    OGRAPISpyFileReopen();

    if (*phDS != nullptr)

        fprintf(fpSpyFile, "%s = ", OGRAPISpyGetDSVar(*phDS).c_str());

    if (bUpdate)

        fprintf(fpSpyFile, "gdal.OpenEx(%s, gdal.OF_VECTOR | gdal.OF_UPDATE)\n",

                OGRAPISpyGetString(pszName).c_str());

    else

        fprintf(fpSpyFile, "gdal.OpenEx(%s, gdal.OF_VECTOR)\n",

                OGRAPISpyGetString(pszName).c_str());

    OGRAPISpyFileClose();

}

void OGRAPISpyPreClose(GDALDatasetH hDS)

{

    if (!OGRAPISpyEnabled())

        return;

    CPLMutexHolderD(&hOGRAPISpyMutex);

    OGRAPISpyFlushDefered();

    fprintf(fpSpyFile, "ds%d = None\n", oMapDS[hDS].iDS);

    oSetDSIndex.erase(oMapDS[hDS].iDS);

    oMapDS.erase(hDS);

    OGRAPISpyFileClose();

}

void OGRAPISpyPostClose()

{

    {

        if (!OGRAPISpyEnabled())

            return;

        CPLMutexHolderD(&hOGRAPISpyMutex);

        std::map<OGRFeatureDefnH, FeatureDefnDescription>::iterator oIter =

            oMapFDefn.begin();

        std::vector<OGRFeatureDefnH> oArray;

        for (; oIter != oMapFDefn.end(); ++oIter)

        {

            FeatureDefnDescription &featureDefnDescription = oIter->second;

            if (OGRFeatureDefn::FromHandle(featureDefnDescription.hFDefn)

                    ->GetReferenceCount() == 1)

            {

                oArray.push_back(featureDefnDescription.hFDefn);

            }

        }

        for (auto &hFDefn : oArray)

        {

            FeatureDefnDescription &featureDefnDescription = oMapFDefn[hFDefn];

            OGRFeatureDefn::FromHandle(featureDefnDescription.hFDefn)

                ->Release();

            featureDefnDescription.Free();

            oMapFDefn.erase(hFDefn);

        }

    }

}

void OGRAPISpyCreateDataSource(GDALDriverH hDriver, const char *pszName,

                               CSLConstList papszOptions, GDALDatasetH hDS)

{

    if (!OGRAPISpyEnabled())

        return;

    CPLMutexHolderD(&hOGRAPISpyMutex);

    OGRAPISpyFlushDefered();

    if (hDS != nullptr)

        fprintf(fpSpyFile, "%s = ", OGRAPISpyGetDSVar(hDS).c_str());

    fprintf(fpSpyFile,

            "ogr.GetDriverByName('%s').CreateDataSource(%s, options=%s)\n",

            GDALGetDriverShortName(hDriver),

            OGRAPISpyGetString(pszName).c_str(),

            OGRAPISpyGetOptions(papszOptions).c_str());

    if (hDS != nullptr)

    {

        aoSetCreatedDS.insert(pszName);

    }

    OGRAPISpyFileClose();

}

void OGRAPISpyDeleteDataSource(GDALDriverH hDriver, const char *pszName)

{

    if (!OGRAPISpyEnabled())

        return;

    CPLMutexHolderD(&hOGRAPISpyMutex);

    OGRAPISpyFlushDefered();

    fprintf(fpSpyFile, "ogr.GetDriverByName('%s').DeleteDataSource(%s)\n",

            GDALGetDriverShortName(hDriver),

            OGRAPISpyGetString(pszName).c_str());

    aoSetCreatedDS.erase(pszName);

    OGRAPISpyFileClose();

}

void OGRAPISpy_DS_GetLayer(GDALDatasetH hDS, int iLayer, OGRLayerH hLayer)

{

    CPLMutexHolderD(&hOGRAPISpyMutex);

    OGRAPISpyFlushDefered();

    if (hLayer != nullptr)

        fprintf(fpSpyFile,

                "%s = ", OGRAPISpyGetAndRegisterLayerVar(hDS, hLayer).c_str());

    fprintf(fpSpyFile, "%s.GetLayer(%d)\n", OGRAPISpyGetDSVar(hDS).c_str(),

            iLayer);

    OGRAPISpyFileClose();

}

void OGRAPISpy_DS_GetLayerCount(GDALDatasetH hDS)

{

    CPLMutexHolderD(&hOGRAPISpyMutex);

    OGRAPISpyFlushDefered();

    fprintf(fpSpyFile, "%s.GetLayerCount()\n", OGRAPISpyGetDSVar(hDS).c_str());

    OGRAPISpyFileClose();

}

void OGRAPISpy_DS_GetLayerByName(GDALDatasetH hDS, const char *pszLayerName,

                                 OGRLayerH hLayer)

{

    CPLMutexHolderD(&hOGRAPISpyMutex);

    OGRAPISpyFlushDefered();

    if (hLayer != nullptr)

        fprintf(fpSpyFile,

                "%s = ", OGRAPISpyGetAndRegisterLayerVar(hDS, hLayer).c_str());

    fprintf(fpSpyFile, "%s.GetLayerByName(%s)\n",

            OGRAPISpyGetDSVar(hDS).c_str(),

            OGRAPISpyGetString(pszLayerName).c_str());

    OGRAPISpyFileClose();

}

void OGRAPISpy_DS_ExecuteSQL(GDALDatasetH hDS, const char *pszStatement,

                             OGRGeometryH hSpatialFilter,

                             const char *pszDialect, OGRLayerH hLayer)

{

    CPLMutexHolderD(&hOGRAPISpyMutex);

    OGRAPISpyFlushDefered();

    if (hLayer != nullptr)

        fprintf(fpSpyFile,

                "%s = ", OGRAPISpyGetAndRegisterLayerVar(hDS, hLayer).c_str());

    fprintf(fpSpyFile, "%s.ExecuteSQL(%s, %s, %s)\n",

            OGRAPISpyGetDSVar(hDS).c_str(),

            OGRAPISpyGetString(pszStatement).c_str(),

            OGRAPISpyGetGeom(hSpatialFilter).c_str(),

            OGRAPISpyGetString(pszDialect).c_str());

    OGRAPISpyFileClose();

}

void OGRAPISpy_DS_ReleaseResultSet(GDALDatasetH hDS, OGRLayerH hLayer)

{

    CPLMutexHolderD(&hOGRAPISpyMutex);

    OGRAPISpyFlushDefered();

    fprintf(fpSpyFile, "%s.ReleaseResultSet(%s)\n",

            OGRAPISpyGetDSVar(hDS).c_str(),

            (hLayer) ? OGRAPISpyGetLayerVar(hLayer).c_str() : "None");

    DatasetDescription &dd = oMapDS[hDS];

    dd.oMapLayer.erase(hLayer);

    oGlobalMapLayer.erase(hLayer);

    OGRAPISpyFileClose();

}

void OGRAPISpy_DS_CreateLayer(GDALDatasetH hDS, const char *pszName,

                              OGRSpatialReferenceH hSpatialRef,

                              OGRwkbGeometryType eType,

                              CSLConstList papszOptions, OGRLayerH hLayer)

{

    CPLMutexHolderD(&hOGRAPISpyMutex);

    OGRAPISpyFlushDefered();

    if (hLayer != nullptr)

        fprintf(fpSpyFile,

                "%s = ", OGRAPISpyGetAndRegisterLayerVar(hDS, hLayer).c_str());

    fprintf(fpSpyFile, "%s.CreateLayer(%s, srs=%s, geom_type=%s, options=%s)\n",

            OGRAPISpyGetDSVar(hDS).c_str(), OGRAPISpyGetString(pszName).c_str(),

            OGRAPISpyGetSRS(hSpatialRef).c_str(),

            OGRAPISpyGetGeomType(eType).c_str(),

            OGRAPISpyGetOptions(papszOptions).c_str());

    OGRAPISpyFileClose();

}

void OGRAPISpy_DS_DeleteLayer(GDALDatasetH hDS, int iLayer)

{

    CPLMutexHolderD(&hOGRAPISpyMutex);

    OGRAPISpyFlushDefered();

    fprintf(fpSpyFile, "%s.DeleteLayer(%d)\n", OGRAPISpyGetDSVar(hDS).c_str(),

            iLayer);

    // Should perhaps remove from the maps.

    OGRAPISpyFileClose();

}

void OGRAPISpy_Dataset_StartTransaction(GDALDatasetH hDS, int bForce)

{

    CPLMutexHolderD(&hOGRAPISpyMutex);

    OGRAPISpyFlushDefered();

    fprintf(fpSpyFile, "%s.StartTransaction(%d)\n",

            OGRAPISpyGetDSVar(hDS).c_str(), bForce);

    OGRAPISpyFileClose();

}

void OGRAPISpy_Dataset_CommitTransaction(GDALDatasetH hDS)

{

    CPLMutexHolderD(&hOGRAPISpyMutex);

    OGRAPISpyFlushDefered();

    fprintf(fpSpyFile, "%s.CommitTransaction()\n",

            OGRAPISpyGetDSVar(hDS).c_str());

    OGRAPISpyFileClose();

}

void OGRAPISpy_Dataset_RollbackTransaction(GDALDatasetH hDS)

{

    CPLMutexHolderD(&hOGRAPISpyMutex);

    OGRAPISpyFlushDefered();

    fprintf(fpSpyFile, "%s.RollbackTransaction()\n",

            OGRAPISpyGetDSVar(hDS).c_str());

    OGRAPISpyFileClose();

}

void OGRAPISpy_L_GetFeatureCount(OGRLayerH hLayer, int bForce)

{

    CPLMutexHolderD(&hOGRAPISpyMutex);

    OGRAPISpyFlushDefered();

    fprintf(fpSpyFile, "%s.GetFeatureCount(force=%d)\n",

            OGRAPISpyGetLayerVar(hLayer).c_str(), bForce);

    OGRAPISpyFileClose();

}

void OGRAPISpy_L_GetExtent(OGRLayerH hLayer, int bForce)

{

    CPLMutexHolderD(&hOGRAPISpyMutex);

    OGRAPISpyFlushDefered();

    fprintf(fpSpyFile, "%s.GetExtent(force=%d)\n",

            OGRAPISpyGetLayerVar(hLayer).c_str(), bForce);

    OGRAPISpyFileClose();

}

void OGRAPISpy_L_GetExtentEx(OGRLayerH hLayer, int iGeomField, int bForce)

{

    CPLMutexHolderD(&hOGRAPISpyMutex);

    OGRAPISpyFlushDefered();

    fprintf(fpSpyFile, "%s.GetExtent(geom_field=%d, force=%d)\n",

            OGRAPISpyGetLayerVar(hLayer).c_str(), iGeomField, bForce);

    OGRAPISpyFileClose();

}

void OGRAPISpy_L_GetExtent3D(OGRLayerH hLayer, int iGeomField, int bForce)

{

    CPLMutexHolderD(&hOGRAPISpyMutex);

    OGRAPISpyFlushDefered();

    fprintf(fpSpyFile, "%s.GetExtent3D(geom_field=%d, force=%d)\n",

            OGRAPISpyGetLayerVar(hLayer).c_str(), iGeomField, bForce);

    OGRAPISpyFileClose();

}

void OGRAPISpy_L_SetAttributeFilter(OGRLayerH hLayer, const char *pszFilter)

{

    CPLMutexHolderD(&hOGRAPISpyMutex);

    OGRAPISpyFlushDefered();

    fprintf(fpSpyFile, "%s.SetAttributeFilter(%s)\n",

            OGRAPISpyGetLayerVar(hLayer).c_str(),

            OGRAPISpyGetString(pszFilter).c_str());

    OGRAPISpyFileClose();

}

void OGRAPISpy_L_GetFeature(OGRLayerH hLayer, GIntBig nFeatureId)

{

    CPLMutexHolderD(&hOGRAPISpyMutex);

    OGRAPISpyFlushDefered();

    fprintf(fpSpyFile, "%s.GetFeature(" CPL_FRMT_GIB ")\n",

            OGRAPISpyGetLayerVar(hLayer).c_str(), nFeatureId);

    OGRAPISpyFileClose();

}

void OGRAPISpy_L_SetNextByIndex(OGRLayerH hLayer, GIntBig nIndex)

{

    CPLMutexHolderD(&hOGRAPISpyMutex);

    OGRAPISpyFlushDefered();

    fprintf(fpSpyFile, "%s.SetNextByIndex(" CPL_FRMT_GIB ")\n",

            OGRAPISpyGetLayerVar(hLayer).c_str(), nIndex);

    OGRAPISpyFileClose();

}

void OGRAPISpy_L_GetNextFeature(OGRLayerH hLayer)

{

    CPLMutexHolderD(&hOGRAPISpyMutex);

    if (hLayerGetNextFeature != hLayer)

    {

        OGRAPISpyFlushDefered();

        OGRAPISpyFileClose();

    }

    hLayerGetNextFeature = hLayer;

    nGetNextFeatureCalls++;

}

static void OGRAPISpyDumpFeature(OGRFeatureH hFeat)

{

    OGRFeature *poFeature = OGRFeature::FromHandle(hFeat);

    fprintf(fpSpyFile, "f = ogr.Feature(%s)\n",

            OGRAPISpyGetFeatureDefnVar(

                OGRFeatureDefn::ToHandle(

                    const_cast<OGRFeatureDefn *>(poFeature->GetDefnRef())))

                .c_str());

    if (poFeature->GetFID() != -1)

        fprintf(fpSpyFile, "f.SetFID(" CPL_FRMT_GIB ")\n", poFeature->GetFID());

    for (int i = 0; i < poFeature->GetFieldCount(); i++)

    {

        if (poFeature->IsFieldNull(i))

        {

            fprintf(fpSpyFile, "f.SetFieldNull(%d)\n", i);

        }

        else if (poFeature->IsFieldSet(i))

        {

            switch (poFeature->GetFieldDefnRef(i)->GetType())

            {

                case OFTInteger:

                    fprintf(fpSpyFile, "f.SetField(%d, %d)\n", i,

                            poFeature->GetFieldAsInteger(i));

                    break;

                case OFTReal:

                    fprintf(fpSpyFile, "%s",

                            CPLSPrintf("f.SetField(%d, %.16g)\n", i,

                                       poFeature->GetFieldAsDouble(i)));

                    break;

                case OFTString:

                    fprintf(fpSpyFile, "f.SetField(%d, %s)\n", i,

                            OGRAPISpyGetString(poFeature->GetFieldAsString(i))

                                .c_str());

                    break;

                default:

                    fprintf(fpSpyFile, "f.SetField(%d, %s) #FIXME\n", i,

                            OGRAPISpyGetString(poFeature->GetFieldAsString(i))

                                .c_str());

                    break;

            }

        }

    }

    for (int i = 0; i < poFeature->GetGeomFieldCount(); i++)

    {

        OGRGeometry *poGeom = poFeature->GetGeomFieldRef(i);

        if (poGeom != nullptr)

        {

            fprintf(fpSpyFile, "f.SetGeomField(%d, %s)\n", i,

                    OGRAPISpyGetGeom(OGRGeometry::ToHandle(poGeom)).c_str());

        }

    }

    const char *pszStyleString = poFeature->GetStyleString();

    if (pszStyleString != nullptr)