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

 *

 * Project:  GDAL

 * Purpose:  "hillshade" 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_hillshade.h"

#include "gdalalg_raster_write.h"

#include "gdal_priv.h"

#include "gdal_utils.h"

#include <cmath>

//! @cond Doxygen_Suppress

#ifndef _

#define _(x) (x)

#endif

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

/*     GDALRasterHillshadeAlgorithm::GDALRasterHillshadeAlgorithm()     */

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

GDALRasterHillshadeAlgorithm::GDALRasterHillshadeAlgorithm(bool standaloneStep)

    : GDALRasterPipelineStepAlgorithm(NAME, DESCRIPTION, HELP_URL,

                                      standaloneStep)

{

    SetOutputVRTCompatible(false);

    AddBandArg(&m_band).SetDefault(m_band);

    AddArg("zfactor", 'z',

           _("Vertical exaggeration used to pre-multiply the elevations"),

           &m_zfactor)

        .SetMinValueExcluded(0);

    AddArg("xscale", 0, _("Ratio of vertical units to horizontal X axis units"),

           &m_xscale)

        .SetMinValueExcluded(0);

    AddArg("yscale", 0, _("Ratio of vertical units to horizontal Y axis units"),

           &m_yscale)

        .SetMinValueExcluded(0);

    AddArg("azimuth", 0, _("Azimuth of the light, in degrees"), &m_azimuth)

        .SetDefault(m_azimuth);

    AddArg("altitude", 0, _("Altitude of the light, in degrees"), &m_altitude)

        .SetDefault(m_altitude)

        .SetMinValueIncluded(0)

        .SetMaxValueIncluded(90);

    AddArg("gradient-alg", 0, _("Algorithm used to compute terrain gradient"),

           &m_gradientAlg)

        .SetChoices("Horn", "ZevenbergenThorne")

        .SetDefault(m_gradientAlg);

    AddArg("variant", 0, _("Variant of the hillshading algorithm"), &m_variant)

        .SetChoices("regular", "combined", "multidirectional", "Igor")

        .SetDefault(m_variant);

    AddArg("no-edges", 0,

           _("Do not try to interpolate values at dataset edges or close to "

             "nodata values"),

           &m_noEdges);

}

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

/*          GDALRasterHillshadeAlgorithm::CanHandleNextStep()           */

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

bool GDALRasterHillshadeAlgorithm::CanHandleNextStep(

    GDALPipelineStepAlgorithm *poNextStep) const

{

    return poNextStep->GetName() == GDALRasterWriteAlgorithm::NAME &&

           poNextStep->GetOutputFormat() != "stream";

}

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

/*               GDALRasterHillshadeAlgorithm::RunStep()                */

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

bool GDALRasterHillshadeAlgorithm::RunStep(GDALPipelineStepRunContext &ctxt)

{

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

    CPLAssert(poSrcDS);

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

    CPLAssert(!m_outputDataset.GetDatasetRef());

    CPLStringList aosOptions;

    std::string outputFilename;

    if (ctxt.m_poNextUsableStep)

    {

        CPLAssert(CanHandleNextStep(ctxt.m_poNextUsableStep));

        outputFilename = ctxt.m_poNextUsableStep->GetOutputDataset().GetName();

        const auto &format = ctxt.m_poNextUsableStep->GetOutputFormat();

        if (!format.empty())

        {

            aosOptions.AddString("-of");

            aosOptions.AddString(format.c_str());

        }

        for (const std::string &co :

             ctxt.m_poNextUsableStep->GetCreationOptions())

        {

            aosOptions.AddString("-co");

            aosOptions.AddString(co.c_str());

        }

    }

    else

    {

        aosOptions.AddString("-of");

        aosOptions.AddString("stream");

    }

    aosOptions.AddString("-b");

    aosOptions.AddString(CPLSPrintf("%d", m_band));

    aosOptions.AddString("-z");

    aosOptions.AddString(CPLSPrintf("%.17g", m_zfactor));

    if (!std::isnan(m_xscale))

    {

        aosOptions.AddString("-xscale");

        aosOptions.AddString(CPLSPrintf("%.17g", m_xscale));

    }

    if (!std::isnan(m_yscale))

    {

        aosOptions.AddString("-yscale");

        aosOptions.AddString(CPLSPrintf("%.17g", m_yscale));

    }

    if (m_variant == "multidirectional")

    {

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

        {

            CPLError(CE_Failure, CPLE_AppDefined,

                     "'azimuth' argument cannot be used with multidirectional "

                     "variant");

            return false;

        }

    }

    else

    {

        aosOptions.AddString("-az");

        aosOptions.AddString(CPLSPrintf("%.17g", m_azimuth));

    }

    if (m_variant == "Igor")

    {

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

        {

            CPLError(CE_Failure, CPLE_AppDefined,

                     "'altitude' argument cannot be used with Igor variant");

            return false;

        }

    }

    else

    {

        aosOptions.AddString("-alt");

        aosOptions.AddString(CPLSPrintf("%.17g", m_altitude));

    }

    aosOptions.AddString("-alg");

    aosOptions.AddString(m_gradientAlg.c_str());

    if (m_variant == "combined")

        aosOptions.AddString("-combined");

    else if (m_variant == "multidirectional")

        aosOptions.AddString("-multidirectional");

    else if (m_variant == "Igor")

        aosOptions.AddString("-igor");

    if (!m_noEdges)

        aosOptions.AddString("-compute_edges");

    GDALDEMProcessingOptions *psOptions =

        GDALDEMProcessingOptionsNew(aosOptions.List(), nullptr);

    bool bOK = false;

    if (psOptions)

    {

        if (ctxt.m_poNextUsableStep)

        {

            GDALDEMProcessingOptionsSetProgress(psOptions, ctxt.m_pfnProgress,

                                                ctxt.m_pProgressData);

        }

        auto poOutDS = std::unique_ptr<GDALDataset>(GDALDataset::FromHandle(

            GDALDEMProcessing(outputFilename.c_str(),

                              GDALDataset::ToHandle(poSrcDS), "hillshade",

                              nullptr, psOptions, nullptr)));

        GDALDEMProcessingOptionsFree(psOptions);

        bOK = poOutDS != nullptr;

        if (poOutDS)

        {

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

        }

    }

    return bOK;

}

GDALRasterHillshadeAlgorithmStandalone::

    ~GDALRasterHillshadeAlgorithmStandalone() = default;

//! @endcond