/******************************************************************************
 *
 * Project:  OpenGIS Simple Features Reference Implementation
 * Purpose:  The generic portions of the OGRSFDriver class.
 * Author:   Frank Warmerdam, warmerdam@pobox.com
 *
 ******************************************************************************
 * Copyright (c) 1999,  Les Technologies SoftMap Inc.
 * Copyright (c) 2009-2011, Even Rouault <even dot rouault at spatialys.com>
 *
 * SPDX-License-Identifier: MIT
 ****************************************************************************/

#include "ogrsf_frmts.h"
#include "ogr_api.h"
#include "ogr_p.h"
#include "ograpispy.h"

//! @cond Doxygen_Suppress

/************************************************************************/
/*                            ~OGRSFDriver()                            */
/************************************************************************/

OGRSFDriver::~OGRSFDriver()

{
}

/************************************************************************/
/*                          CreateDataSource()                          */
/************************************************************************/

OGRDataSource *OGRSFDriver::CreateDataSource(const char *, char **)

{
    CPLError(CE_Failure, CPLE_NotSupported,
             "CreateDataSource() not supported by this driver.\n");

    return nullptr;
}

/************************************************************************/
/*                      OGR_Dr_CreateDataSource()                       */
/************************************************************************/

OGRDataSourceH OGR_Dr_CreateDataSource(OGRSFDriverH hDriver,
                                       const char *pszName, char **papszOptions)

{
    VALIDATE_POINTER1(hDriver, "OGR_Dr_CreateDataSource", nullptr);

    GDALDriver *poDriver = reinterpret_cast<GDALDriver *>(hDriver);

    /* MapServer had the bad habit of calling with NULL name for a memory
     * datasource */
    if (pszName == nullptr)
        pszName = "";

    OGRDataSourceH hDS = reinterpret_cast<OGRDataSourceH>(
        poDriver->Create(pszName, 0, 0, 0, GDT_Unknown, papszOptions));

#ifdef OGRAPISPY_ENABLED
    OGRAPISpyCreateDataSource(hDriver, pszName, papszOptions,
                              reinterpret_cast<OGRDataSourceH>(hDS));
#endif

    return hDS;
}

/************************************************************************/
/*                          DeleteDataSource()                          */
/************************************************************************/

OGRErr OGRSFDriver::DeleteDataSource(const char *pszDataSource)

{
    (void)pszDataSource;
    CPLError(CE_Failure, CPLE_NotSupported,
             "DeleteDataSource() not supported by this driver.");

    return OGRERR_UNSUPPORTED_OPERATION;
}

/************************************************************************/
/*                      OGR_Dr_DeleteDataSource()                       */
/************************************************************************/

OGRErr OGR_Dr_DeleteDataSource(OGRSFDriverH hDriver, const char *pszDataSource)

{
    VALIDATE_POINTER1(hDriver, "OGR_Dr_DeleteDataSource",
                      OGRERR_INVALID_HANDLE);

#ifdef OGRAPISPY_ENABLED
    OGRAPISpyDeleteDataSource(hDriver, pszDataSource);
#endif

    CPLErr eErr =
        reinterpret_cast<GDALDriver *>(hDriver)->Delete(pszDataSource);
    if (eErr == CE_None)
        return OGRERR_NONE;
    else
        return OGRERR_FAILURE;
}

/************************************************************************/
/*                           OGR_Dr_GetName()                           */
/************************************************************************/

const char *OGR_Dr_GetName(OGRSFDriverH hDriver)

{
    VALIDATE_POINTER1(hDriver, "OGR_Dr_GetName", nullptr);

    return reinterpret_cast<GDALDriver *>(hDriver)->GetDescription();
}

/************************************************************************/
/*                            OGR_Dr_Open()                             */
/************************************************************************/

OGRDataSourceH OGR_Dr_Open(OGRSFDriverH hDriver, const char *pszName,
                           int bUpdate)

{
    VALIDATE_POINTER1(hDriver, "OGR_Dr_Open", nullptr);

    const char *const apszDrivers[] = {
        reinterpret_cast<GDALDriver *>(hDriver)->GetDescription(), nullptr};

#ifdef OGRAPISPY_ENABLED
    int iSnapshot = OGRAPISpyOpenTakeSnapshot(pszName, bUpdate);
#endif

    GDALDatasetH hDS =
        GDALOpenEx(pszName, GDAL_OF_VECTOR | ((bUpdate) ? GDAL_OF_UPDATE : 0),
                   apszDrivers, nullptr, nullptr);

#ifdef OGRAPISPY_ENABLED
    OGRAPISpyOpen(pszName, bUpdate, iSnapshot, &hDS);
#endif

    return reinterpret_cast<OGRDataSourceH>(hDS);
}

/************************************************************************/
/*                       OGR_Dr_TestCapability()                        */
/************************************************************************/

int OGR_Dr_TestCapability(OGRSFDriverH hDriver, const char *pszCap)

{
    VALIDATE_POINTER1(hDriver, "OGR_Dr_TestCapability", 0);
    VALIDATE_POINTER1(pszCap, "OGR_Dr_TestCapability", 0);

    GDALDriver *poDriver = reinterpret_cast<GDALDriver *>(hDriver);
    if (EQUAL(pszCap, ODrCCreateDataSource))
    {
        return poDriver->GetMetadataItem(GDAL_DCAP_CREATE) ||
               poDriver->pfnCreate != nullptr ||
               poDriver->pfnCreateVectorOnly != nullptr;
    }
    else if (EQUAL(pszCap, ODrCDeleteDataSource))
    {
        return poDriver->pfnDelete != nullptr ||
               poDriver->pfnDeleteDataSource != nullptr;
    }
    else
        return FALSE;
}

/************************************************************************/
/*                       OGR_Dr_CopyDataSource()                        */
/************************************************************************/

OGRDataSourceH OGR_Dr_CopyDataSource(OGRSFDriverH hDriver,
                                     OGRDataSourceH hSrcDS,
                                     const char *pszNewName,
                                     char **papszOptions)

{
    VALIDATE_POINTER1(hDriver, "OGR_Dr_CopyDataSource", nullptr);
    VALIDATE_POINTER1(hSrcDS, "OGR_Dr_CopyDataSource", nullptr);
    VALIDATE_POINTER1(pszNewName, "OGR_Dr_CopyDataSource", nullptr);

    GDALDriver *poDriver = reinterpret_cast<GDALDriver *>(hDriver);
    if (!poDriver->GetMetadataItem(GDAL_DCAP_CREATE))
    {
        CPLError(CE_Failure, CPLE_NotSupported,
                 "%s driver does not support data source creation.",
                 poDriver->GetDescription());
        return nullptr;
    }

    GDALDataset *poSrcDS = GDALDataset::FromHandle(hSrcDS);
    GDALDataset *poODS =
        poDriver->Create(pszNewName, 0, 0, 0, GDT_Unknown, papszOptions);
    if (poODS == nullptr)
        return nullptr;

    /* -------------------------------------------------------------------- */
    /*      Process each data source layer.                                 */
    /* -------------------------------------------------------------------- */
    for (int iLayer = 0; iLayer < poSrcDS->GetLayerCount(); iLayer++)
    {
        OGRLayer *poLayer = poSrcDS->GetLayer(iLayer);

        if (poLayer == nullptr)
            continue;

        poODS->CopyLayer(poLayer, poLayer->GetLayerDefn()->GetName(),
                         papszOptions);
    }

    return reinterpret_cast<OGRDataSourceH>(poODS);
}

//! @endcond