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

 *

 * Project:  GDAL

 * Purpose:  gdal "mdim info" 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_mdim_info.h"

#include "cpl_conv.h"

#include "gdal_priv.h"

#include "gdal_utils.h"

//! @cond Doxygen_Suppress

#ifndef _

#define _(x) (x)

#endif

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

/*            GDALMdimInfoAlgorithm::GDALMdimInfoAlgorithm()            */

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

GDALMdimInfoAlgorithm::GDALMdimInfoAlgorithm(bool standaloneStep,

                                             bool openForMixedRasterVector)

    : GDALMdimPipelineStepAlgorithm(

          NAME, DESCRIPTION, HELP_URL,

          ConstructorOptions()

              .SetStandaloneStep(standaloneStep)

              .SetInputDatasetMaxCount(1)

              .SetAddDefaultArguments(false)

              .SetInputDatasetHelpMsg(_("Input multidimensional dataset"))

              .SetInputDatasetAlias("dataset"))

{

    if (standaloneStep)

    {

        AddProgressArg(/* hidden = */ true);

        AddMdimInputArgs(openForMixedRasterVector,

                         /* hiddenForCLI = */ false,

                         /* acceptRaster = */ false);

    }

    else

    {

        AddMdimHiddenInputDatasetArg();

    }

    AddOutputFormatArg(&m_format).SetChoices("json", "text");

    AddArg("summary", 0,

           _("Report only group and array hierarchy, without detailed "

             "information on attributes or dimensions."),

           &m_summary)

        .SetMutualExclusionGroup("structure_detailed");

    AddArg(

        "detailed", 0,

        _("Most verbose output. Report attribute data types and array values."),

        &m_detailed)

        .SetMutualExclusionGroup("structure_detailed");

    AddArrayNameArg(&m_array, _("Name of the array, used to restrict the "

                                "output to the specified array."));

    AddArg("limit", 0,

           _("Number of values in each dimension that is used to limit the "

             "display of array values."),

           &m_limit);

    {

        auto &arg = AddArg("array-option", 0,

                           _("Option passed to GDALGroup::GetMDArrayNames() to "

                             "filter reported arrays."),

                           &m_arrayOptions)

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

                        .SetPackedValuesAllowed(false);

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

                                { return ParseAndValidateKeyValue(arg); });

        arg.SetAutoCompleteFunction(

            [this](const std::string &currentValue)

            {

                std::vector<std::string> ret;

                if (m_inputDataset.size() == 1)

                {

                    if (auto poDS =

                            std::unique_ptr<GDALDataset>(GDALDataset::Open(

                                m_inputDataset[0].GetName().c_str(),

                                GDAL_OF_MULTIDIM_RASTER, nullptr, nullptr,

                                nullptr)))

                    {

                        if (auto poDriver = poDS->GetDriver())

                        {

                            if (const char *pszXML = poDriver->GetMetadataItem(

                                    GDAL_DMD_MULTIDIM_ARRAY_OPENOPTIONLIST))

                            {

                                AddOptionsSuggestions(pszXML, 0, currentValue,

                                                      ret);

                            }

                        }

                    }

                }

                return ret;

            });

    }

    AddArg("stats", 0, _("Read and display image statistics."), &m_stats);

    AddOutputStringArg(&m_output);

    AddStdoutArg(&m_stdout);

}

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

/*                   GDALMdimInfoAlgorithm::RunStep()                   */

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

bool GDALMdimInfoAlgorithm::RunStep(GDALPipelineStepRunContext &)

{

    CPLAssert(m_inputDataset.size() == 1);

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

    CPLAssert(poSrcDS);

    if (m_format.empty())

        m_format = IsCalledFromCommandLine() ? "text" : "json";

    CPLStringList aosOptions;

    aosOptions.AddString("-format");

    aosOptions.AddString(m_format);

    if (m_stdout)

        aosOptions.AddString("-stdout");

    if (m_summary)

        aosOptions.AddString("-summary");

    else if (m_detailed)

        aosOptions.AddString("-detailed");

    if (m_stats)

        aosOptions.AddString("-stats");

    if (m_limit > 0)

    {

        aosOptions.AddString("-limit");

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

    }

    if (!m_array.empty())

    {

        aosOptions.AddString("-array");

        aosOptions.AddString(m_array.c_str());

    }

    for (const std::string &opt : m_arrayOptions)

    {

        aosOptions.AddString("-arrayoption");

        aosOptions.AddString(opt.c_str());

    }

    GDALDatasetH hDS = GDALDataset::ToHandle(poSrcDS);

    GDALMultiDimInfoOptions *psOptions =

        GDALMultiDimInfoOptionsNew(aosOptions.List(), nullptr);

    char *ret = GDALMultiDimInfo(hDS, psOptions);

    GDALMultiDimInfoOptionsFree(psOptions);

    const bool bOK = ret != nullptr;

    if (ret && !m_stdout)

    {

        m_output = ret;

    }

    CPLFree(ret);

    return bOK;

}

GDALMdimInfoAlgorithmStandalone::~GDALMdimInfoAlgorithmStandalone() = default;

//! @endcond