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

 *

 * Project:  GDAL

 * Purpose:  "pansharpen" step of "raster pipeline"

 * Author:   Even Rouault <even dot rouault at spatialys.com>

 *

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

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

 *

 * SPDX-License-Identifier: MIT

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

#include "gdalalg_raster_pansharpen.h"

#include "gdal_priv.h"

#include "cpl_minixml.h"

//! @cond Doxygen_Suppress

#ifndef _

#define _(x) (x)

#endif

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

/*        GDALRasterPansharpenAlgorithm::GetConstructorOptions()        */

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

/* static */ GDALRasterPansharpenAlgorithm::ConstructorOptions

GDALRasterPansharpenAlgorithm::GetConstructorOptions(bool standaloneStep)

{

    ConstructorOptions opts;

    opts.SetStandaloneStep(standaloneStep);

    opts.SetAddDefaultArguments(false);

    opts.SetInputDatasetAlias("panchromatic");

    opts.SetInputDatasetHelpMsg(_("Input panchromatic raster dataset"));

    return opts;

}

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

/*    GDALRasterPansharpenAlgorithm::GDALRasterPansharpenAlgorithm()    */

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

GDALRasterPansharpenAlgorithm::GDALRasterPansharpenAlgorithm(

    bool standaloneStep)

    : GDALRasterPipelineStepAlgorithm(NAME, DESCRIPTION, HELP_URL,

                                      GetConstructorOptions(standaloneStep))

{

    const auto AddSpectralDatasetArg = [this]()

    {

        auto &arg = AddArg("spectral", 0, _("Input spectral band dataset"),

                           &m_spectralDatasets)

                        .SetPositional()

                        .SetRequired()

                        .SetMinCount(1)

                        // due to ",band=" comma syntax

                        .SetAutoOpenDataset(false)

                        // due to ",band=" comma syntax

                        .SetPackedValuesAllowed(false)

                        .SetMetaVar("SPECTRAL");

        SetAutoCompleteFunctionForFilename(arg, GDAL_OF_RASTER);

    };

    if (standaloneStep)

    {

        AddRasterInputArgs(false, false);

        AddSpectralDatasetArg();

        AddProgressArg();

        AddRasterOutputArgs(false);

    }

    else

    {

        AddRasterHiddenInputDatasetArg();

        AddSpectralDatasetArg();

    }

    AddArg("resampling", 'r', _("Resampling algorithm"), &m_resampling)

        .SetDefault(m_resampling)

        .SetChoices("nearest", "bilinear", "cubic", "cubicspline", "lanczos",

                    "average");

    AddArg("weights", 0, _("Weight for each input spectral band"), &m_weights);

    AddArg("nodata", 0, _("Override nodata value of input bands"), &m_nodata);

    AddArg("bit-depth", 0, _("Override bit depth of input bands"), &m_bitDepth)

        .SetMinValueIncluded(8);

    AddArg("spatial-extent-adjustment", 0,

           _("Select behavior when bands have not the same extent"),

           &m_spatialExtentAdjustment)

        .SetDefault(m_spatialExtentAdjustment)

        .SetChoices("union", "intersection", "none", "none-without-warning");

    AddNumThreadsArg(&m_numThreads, &m_numThreadsStr);

}

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

/*               GDALRasterPansharpenAlgorithm::RunStep()               */

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

bool GDALRasterPansharpenAlgorithm::RunStep(GDALPipelineStepRunContext &)

{

    auto poPanDS = m_inputDataset[0].GetDatasetRef();

    CPLAssert(poPanDS);

    CPLAssert(m_outputDataset.GetName().empty());

    CPLAssert(!m_outputDataset.GetDatasetRef());

    if (poPanDS->GetRasterCount() != 1)

    {

        ReportError(CE_Failure, CPLE_AppDefined,

                    "Input panchromatic dataset must have a single band");

        return false;

    }

    // to keep in this scope to keep datasets of spectral bands open until

    // GDALCreatePansharpenedVRT() runs

    std::vector<std::unique_ptr<GDALDataset, GDALDatasetUniquePtrReleaser>>

        apoDatasetsToReleaseRef;

    std::vector<GDALRasterBandH> ahSpectralBands;

    for (auto &spectralDataset : m_spectralDatasets)

    {

        if (auto poSpectralDS = spectralDataset.GetDatasetRef())

        {

            for (int i = 1; i <= poSpectralDS->GetRasterCount(); ++i)

            {

                ahSpectralBands.push_back(

                    GDALRasterBand::ToHandle(poSpectralDS->GetRasterBand(i)));

            }

        }

        else

        {

            const auto &name = spectralDataset.GetName();

            std::string dsName(name);

            const auto pos = name.find(",band=");

            int iBand = 0;

            if (pos != std::string::npos)

            {

                dsName.resize(pos);

                iBand = atoi(name.c_str() + pos + strlen(",band="));

            }

            std::unique_ptr<GDALDataset, GDALDatasetUniquePtrReleaser> poDS(

                GDALDataset::Open(dsName.c_str(),

                                  GDAL_OF_RASTER | GDAL_OF_VERBOSE_ERROR));

            if (!poDS)

                return false;

            if (iBand <= 0)

            {

                for (int i = 1; i <= poDS->GetRasterCount(); ++i)

                {

                    ahSpectralBands.push_back(

                        GDALRasterBand::ToHandle(poDS->GetRasterBand(i)));

                }

            }

            else if (iBand > poDS->GetRasterCount())

            {

                ReportError(CE_Failure, CPLE_IllegalArg, "Illegal band in '%s'",

                            name.c_str());

                return false;

            }

            else

            {

                ahSpectralBands.push_back(

                    GDALRasterBand::ToHandle(poDS->GetRasterBand(iBand)));

            }

            apoDatasetsToReleaseRef.push_back(std::move(poDS));

        }

    }

    CPLXMLTreeCloser root(CPLCreateXMLNode(nullptr, CXT_Element, "VRTDataset"));

    for (int i = 0; i < static_cast<int>(ahSpectralBands.size()); ++i)

    {

        auto psBandNode =

            CPLCreateXMLNode(root.get(), CXT_Element, "VRTRasterBand");

        CPLAddXMLAttributeAndValue(

            psBandNode, "dataType",

            GDALGetDataTypeName(GDALGetRasterDataType(ahSpectralBands[i])));

        CPLAddXMLAttributeAndValue(psBandNode, "band", CPLSPrintf("%d", i + 1));

        CPLAddXMLAttributeAndValue(psBandNode, "subClass",

                                   "VRTPansharpenedRasterBand");

    }

    CPLAddXMLAttributeAndValue(root.get(), "subClass",

                               "VRTPansharpenedDataset");

    auto psPansharpeningOptionsNode =

        CPLCreateXMLNode(root.get(), CXT_Element, "PansharpeningOptions");

    if (!m_weights.empty())

    {

        auto psAlgorithmOptionsNode = CPLCreateXMLNode(

            psPansharpeningOptionsNode, CXT_Element, "AlgorithmOptions");

        std::string osWeights;

        for (double w : m_weights)

        {

            if (!osWeights.empty())

                osWeights += ',';

            osWeights += CPLSPrintf("%.17g", w);

        }

        CPLCreateXMLElementAndValue(psAlgorithmOptionsNode, "Weights",

                                    osWeights.c_str());

    }

    CPLCreateXMLElementAndValue(psPansharpeningOptionsNode, "Resampling",

                                m_resampling.c_str());

    CPLCreateXMLElementAndValue(psPansharpeningOptionsNode, "NumThreads",

                                m_numThreadsStr.c_str());

    if (m_bitDepth > 0)

    {

        CPLCreateXMLElementAndValue(psPansharpeningOptionsNode, "BitDepth",

                                    CPLSPrintf("%d", m_bitDepth));

    }

    if (GetArg("nodata")->IsExplicitlySet())

    {

        CPLCreateXMLElementAndValue(psPansharpeningOptionsNode, "NoData",

                                    CPLSPrintf("%.17g", m_nodata));

    }

    CPLCreateXMLElementAndValue(

        psPansharpeningOptionsNode, "SpatialExtentAdjustment",

        CPLString(m_spatialExtentAdjustment).replaceAll('-', 0).c_str());

    for (int i = 0; i < static_cast<int>(ahSpectralBands.size()); ++i)

    {

        auto psSpectraBandNode = CPLCreateXMLNode(psPansharpeningOptionsNode,

                                                  CXT_Element, "SpectralBand");

        CPLAddXMLAttributeAndValue(psSpectraBandNode, "dstBand",

                                   CPLSPrintf("%d", i + 1));

    }

    CPLCharUniquePtr pszXML(CPLSerializeXMLTree(root.get()));

    auto poVRTDS = std::unique_ptr<GDALDataset>(

        GDALDataset::FromHandle(GDALCreatePansharpenedVRT(

            pszXML.get(), GDALRasterBand::ToHandle(poPanDS->GetRasterBand(1)),

            static_cast<int>(ahSpectralBands.size()), ahSpectralBands.data())));

    const bool bRet = poVRTDS != nullptr;

    if (poVRTDS)

    {

        m_outputDataset.Set(std::move(poVRTDS));

    }

    return bRet;

}

GDALRasterPansharpenAlgorithmStandalone::

    ~GDALRasterPansharpenAlgorithmStandalone() = default;

//! @endcond