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

 *

 * Project:  GDAL

 * Purpose:  gdal "raster index" subcommand

 * 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_index.h"

#include "cpl_conv.h"

#include "gdal_priv.h"

#include "gdal_utils_priv.h"

#include "ogrsf_frmts.h"

//! @cond Doxygen_Suppress

#ifndef _

#define _(x) (x)

#endif

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

/*          GDALRasterIndexAlgorithm::GDALRasterIndexAlgorithm()        */

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

GDALRasterIndexAlgorithm::GDALRasterIndexAlgorithm()

    : GDALVectorOutputAbstractAlgorithm(NAME, DESCRIPTION, HELP_URL)

{

    AddProgressArg();

    AddInputDatasetArg(&m_inputDatasets, GDAL_OF_RASTER)

        .SetAutoOpenDataset(false)

        .SetDatasetInputFlags(GADV_NAME);

    GDALVectorOutputAbstractAlgorithm::AddAllOutputArgs();

    AddCommonOptions();

    AddArg("source-crs-field-name", 0,

           _("Name of the field to store the CRS of each dataset"),

           &m_sourceCrsName)

        .SetMinCharCount(1);

    AddArg("source-crs-format", 0,

           _("Format in which the CRS of each dataset must be written"),

           &m_sourceCrsFormat)

        .SetMinCharCount(1)

        .SetDefault(m_sourceCrsFormat)

        .SetChoices("auto", "WKT", "EPSG", "PROJ");

}

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

/*          GDALRasterIndexAlgorithm::GDALRasterIndexAlgorithm()        */

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

GDALRasterIndexAlgorithm::GDALRasterIndexAlgorithm(

    const std::string &name, const std::string &description,

    const std::string &helpURL)

    : GDALVectorOutputAbstractAlgorithm(name, description, helpURL)

{

}

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

/*              GDALRasterIndexAlgorithm::AddCommonOptions()            */

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

void GDALRasterIndexAlgorithm::AddCommonOptions()

{

    AddArg("recursive", 0,

           _("Whether input directories should be explored recursively."),

           &m_recursive);

    AddArg("filename-filter", 0,

           _("Pattern that the filenames in input directories should follow "

             "('*' and '?' wildcard)"),

           &m_filenameFilter);

    AddArg("min-pixel-size", 0,

           _("Minimum pixel size in term of geospatial extent per pixel "

             "(resolution) that a raster should have to be selected."),

           &m_minPixelSize)

        .SetMinValueExcluded(0);

    AddArg("max-pixel-size", 0,

           _("Maximum pixel size in term of geospatial extent per pixel "

             "(resolution) that a raster should have to be selected."),

           &m_maxPixelSize)

        .SetMinValueExcluded(0);

    AddArg("location-name", 0, _("Name of the field with the raster path"),

           &m_locationName)

        .SetDefault(m_locationName)

        .SetMinCharCount(1);

    AddAbsolutePathArg(

        &m_writeAbsolutePaths,

        _("Whether the path to the input datasets should be stored as an "

          "absolute path"));

    AddArg("dst-crs", 0, _("Destination CRS"), &m_crs)

        .SetIsCRSArg()

        .AddHiddenAlias("t_srs");

    {

        auto &arg =

            AddArg("metadata", 0, _("Add dataset metadata item"), &m_metadata)

                .SetMetaVar("<KEY>=<VALUE>")

                .SetPackedValuesAllowed(false);

        arg.AddValidationAction([this, &arg]()

                                { return ParseAndValidateKeyValue(arg); });

        arg.AddHiddenAlias("mo");

    }

    AddArg("skip-errors", 0, _("Skip errors related to input datasets"),

           &m_skipErrors);

}

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

/*                   GDALRasterIndexAlgorithm::RunImpl()                */

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

bool GDALRasterIndexAlgorithm::RunImpl(GDALProgressFunc pfnProgress,

                                       void *pProgressData)

{

    CPLStringList aosSources;

    for (auto &srcDS : m_inputDatasets)

    {

        if (srcDS.GetDatasetRef())

        {

            ReportError(

                CE_Failure, CPLE_IllegalArg,

                "Input datasets must be provided by name, not as object");

            return false;

        }

        aosSources.push_back(srcDS.GetName());

    }

    auto setupRet = SetupOutputDataset();

    if (!setupRet.outDS)

        return false;

    if (!SetDefaultOutputLayerNameIfNeeded(setupRet.outDS))

        return false;

    CPLStringList aosOptions;

    aosOptions.push_back("--invoked-from-gdal-raster-index");

    if (m_skipErrors)

    {

        aosOptions.push_back("-skip_errors");

    }

    if (m_recursive)

    {

        aosOptions.push_back("-recursive");

    }

    for (const std::string &s : m_filenameFilter)

    {

        aosOptions.push_back("-filename_filter");

        aosOptions.push_back(s);

    }

    if (m_minPixelSize > 0)

    {

        aosOptions.push_back("-min_pixel_size");

        aosOptions.push_back(CPLSPrintf("%.17g", m_minPixelSize));

    }

    if (m_maxPixelSize > 0)

    {

        aosOptions.push_back("-max_pixel_size");

        aosOptions.push_back(CPLSPrintf("%.17g", m_maxPixelSize));

    }

    if (!m_outputLayerName.empty())

    {

        aosOptions.push_back("-lyr_name");

        aosOptions.push_back(m_outputLayerName);

    }

    aosOptions.push_back("-tileindex");

    aosOptions.push_back(m_locationName);

    if (m_writeAbsolutePaths)

    {

        aosOptions.push_back("-write_absolute_path");

    }

    if (m_crs.empty())

    {

        if (m_sourceCrsName.empty())

            aosOptions.push_back("-skip_different_projection");

    }

    else

    {

        aosOptions.push_back("-t_srs");

        aosOptions.push_back(m_crs);

    }

    if (!m_sourceCrsName.empty())

    {

        aosOptions.push_back("-src_srs_name");

        aosOptions.push_back(m_sourceCrsName);

        aosOptions.push_back("-src_srs_format");

        aosOptions.push_back(CPLString(m_sourceCrsFormat).toupper());

    }

    for (const std::string &s : m_metadata)

    {

        aosOptions.push_back("-mo");

        aosOptions.push_back(s);

    }

    if (!AddExtraOptions(aosOptions))

        return false;

    std::unique_ptr<GDALTileIndexOptions, decltype(&GDALTileIndexOptionsFree)>

        options(GDALTileIndexOptionsNew(aosOptions.List(), nullptr),

                GDALTileIndexOptionsFree);

    if (options)

    {

        GDALTileIndexOptionsSetProgress(options.get(), pfnProgress,

                                        pProgressData);

    }

    const bool ret =

        options && GDALTileIndexInternal(m_outputDataset.GetName().c_str(),

                                         GDALDataset::ToHandle(setupRet.outDS),

                                         OGRLayer::ToHandle(setupRet.layer),

                                         aosSources.size(), aosSources.List(),

                                         options.get(), nullptr) != nullptr;

    if (ret && setupRet.newDS)

    {

        m_outputDataset.Set(std::move(setupRet.newDS));

    }

    return ret;

}

//! @endcond