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

 *

 * Project:  GDAL

 * Purpose:  Implementation of derived subdatasets

 * Author:   Julien Michel <julien dot michel at cnes dot fr>

 *

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

 * Copyright (c) 2016 Julien Michel <julien dot michel at cnes dot fr>

 *

 * SPDX-License-Identifier: MIT

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

#include "../vrt/vrtdataset.h"

#include "gdal_frmts.h"

#include "gdal_pam.h"

#include "gdal_priv.h"

#include "derivedlist.h"

class DerivedDataset final : public VRTDataset

{

  public:

    DerivedDataset(int nXSize, int nYSize);

    ~DerivedDataset() override;

    static int Identify(GDALOpenInfo *);

    static GDALDataset *Open(GDALOpenInfo *);

};

DerivedDataset::DerivedDataset(int nXSize, int nYSize)

    : VRTDataset(nXSize, nYSize)

{

    poDriver = nullptr;

    SetWritable(FALSE);

}

DerivedDataset::~DerivedDataset() = default;

int DerivedDataset::Identify(GDALOpenInfo *poOpenInfo)

{

    /* Try to open original dataset */

    CPLString filename(poOpenInfo->pszFilename);

    /* DERIVED_SUBDATASET should be first domain */

    const size_t dsds_pos = filename.find("DERIVED_SUBDATASET:");

    if (dsds_pos != 0)

    {

        /* Unable to Open in this case */

        return FALSE;

    }

    return TRUE;

}

GDALDataset *DerivedDataset::Open(GDALOpenInfo *poOpenInfo)

{

    /* Try to open original dataset */

    CPLString filename(poOpenInfo->pszFilename);

    /* DERIVED_SUBDATASET should be first domain */

    const size_t dsds_pos = filename.find("DERIVED_SUBDATASET:");

    const size_t nPrefixLen = strlen("DERIVED_SUBDATASET:");

    if (dsds_pos != 0)

    {

        /* Unable to Open in this case */

        return nullptr;

    }

    /* Next, we need to now which derived dataset to compute */

    const size_t alg_pos = filename.find(":", nPrefixLen + 1);

    if (alg_pos == std::string::npos)

    {

        /* Unable to Open if we do not find the name of the derived dataset */

        return nullptr;

    }

    CPLString odDerivedName = filename.substr(nPrefixLen, alg_pos - nPrefixLen);

    CPLDebug("DerivedDataset::Open", "Derived dataset requested: %s",

             odDerivedName.c_str());

    CPLString pixelFunctionName = "";

    bool datasetFound = false;

    unsigned int nbSupportedDerivedDS(0);

    GDALDataType type = GDT_Float64;

    const DerivedDatasetDescription *poDDSDesc =

        GDALGetDerivedDatasetDescriptions(&nbSupportedDerivedDS);

    for (unsigned int derivedId = 0; derivedId < nbSupportedDerivedDS;

         ++derivedId)

    {

        if (odDerivedName == poDDSDesc[derivedId].pszDatasetName)

        {

            datasetFound = true;

            pixelFunctionName = poDDSDesc[derivedId].pszPixelFunction;

            type =

                GDALGetDataTypeByName(poDDSDesc[derivedId].pszOutputPixelType);

        }

    }

    if (!datasetFound)

    {

        return nullptr;

    }

    CPLString odFilename =

        filename.substr(alg_pos + 1, filename.size() - alg_pos);

    auto poTmpDS = std::unique_ptr<GDALDataset>(

        GDALDataset::Open(odFilename, GDAL_OF_RASTER | GDAL_OF_VERBOSE_ERROR));

    if (poTmpDS == nullptr)

        return nullptr;

    int nbBands = poTmpDS->GetRasterCount();

    if (nbBands == 0)

    {

        return nullptr;

    }

    int nRows = poTmpDS->GetRasterYSize();

    int nCols = poTmpDS->GetRasterXSize();

    DerivedDataset *poDS = new DerivedDataset(nCols, nRows);

    // Transfer metadata

    poDS->SetMetadata(poTmpDS->GetMetadata());

    char **papszRPC = poTmpDS->GetMetadata("RPC");

    if (papszRPC)

    {

        poDS->SetMetadata(papszRPC, "RPC");

    }

    // Transfer projection

    poDS->SetProjection(poTmpDS->GetProjectionRef());

    // Transfer geotransform

    GDALGeoTransform gt;

    if (poTmpDS->GetGeoTransform(gt) == CE_None)

    {

        poDS->SetGeoTransform(gt);

    }

    // Transfer GCPs

    const char *gcpProjection = poTmpDS->GetGCPProjection();

    int nbGcps = poTmpDS->GetGCPCount();

    poDS->SetGCPs(nbGcps, poTmpDS->GetGCPs(), gcpProjection);

    // Map bands

    for (int nBand = 1; nBand <= nbBands; ++nBand)

    {

        VRTDerivedRasterBand *poBand =

            new VRTDerivedRasterBand(poDS, nBand, type, nCols, nRows);

        poDS->SetBand(nBand, poBand);

        poBand->SetPixelFunctionName(pixelFunctionName);

        poBand->SetSourceTransferType(

            poTmpDS->GetRasterBand(nBand)->GetRasterDataType());

        poBand->AddComplexSource(odFilename, nBand, 0, 0, nCols, nRows, 0, 0,

                                 nCols, nRows);

    }

    // If dataset is a real file, initialize overview manager

    VSIStatBufL sStat;

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

    {

        CPLString path = CPLGetPathSafe(odFilename);

        CPLString ovrFileName = "DERIVED_DATASET_" + odDerivedName + "_" +

                                CPLGetFilename(odFilename);

        CPLString ovrFilePath = CPLFormFilenameSafe(path, ovrFileName, nullptr);

        poDS->oOvManager.Initialize(poDS, ovrFilePath);

    }

    return poDS;

}

void GDALRegister_Derived()

{

    if (GDALGetDriverByName("DERIVED") != nullptr)

        return;

    GDALDriver *poDriver = new GDALDriver();

    poDriver->SetDescription("DERIVED");

#ifdef GDAL_DCAP_RASTER

    poDriver->SetMetadataItem(GDAL_DCAP_RASTER, "YES");

#endif

    poDriver->SetMetadataItem(GDAL_DMD_LONGNAME,

                              "Derived datasets using VRT pixel functions");

    poDriver->SetMetadataItem(GDAL_DMD_HELPTOPIC,

                              "drivers/raster/derived.html");

    poDriver->SetMetadataItem(GDAL_DMD_SUBDATASETS, "NO");

    poDriver->pfnOpen = DerivedDataset::Open;

    poDriver->pfnIdentify = DerivedDataset::Identify;

    GetGDALDriverManager()->RegisterDriver(poDriver);

}