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

 *

 * Project:  GDAL Utilities

 * Purpose:  Command line application to list info about a file.

 * Author:   Frank Warmerdam, warmerdam@pobox.com

 *

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

 * Copyright (c) 1998, Frank Warmerdam

 * Copyright (c) 2007-2015, Even Rouault <even.rouault at spatialys.com>

 * Copyright (c) 2015, Faza Mahamood

 *

 * SPDX-License-Identifier: MIT

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

#include "cpl_port.h"

#include "gdal_utils.h"

#include "gdal_utils_priv.h"

#include "gdalargumentparser.h"

#include <cmath>

#include <limits>

#include <stdarg.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <new>

#include <string>

#include <vector>

#include "commonutils.h"

#include "cpl_conv.h"

#include "cpl_error.h"

#include "cpl_json_header.h"

#include "cpl_minixml.h"

#include "cpl_progress.h"

#include "cpl_string.h"

#include "cpl_vsi.h"

#include "gdal.h"

#include "gdal_alg.h"

#include "gdal_priv.h"

#include "gdal_rat.h"

#include "ogr_api.h"

#include "ogr_srs_api.h"

#include "ogr_spatialref.h"

#include "ogrlibjsonutils.h"

#include "ogrgeojsongeometry.h"

#include "ogrgeojsonwriter.h"

using std::vector;

/*! output format */

typedef enum

{

    /*! output in text format */ GDALINFO_FORMAT_TEXT = 0,

    /*! output in json format */ GDALINFO_FORMAT_JSON = 1

} GDALInfoFormat;

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

/*                           GDALInfoOptions                            */

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

/** Options for use with GDALInfo(). GDALInfoOptions* must be allocated and

 * freed with GDALInfoOptionsNew() and GDALInfoOptionsFree() respectively.

 */

struct GDALInfoOptions

{

    /*! output format */

    GDALInfoFormat eFormat = GDALINFO_FORMAT_TEXT;

    bool bComputeMinMax = false;

    /*! report histogram information for all bands */

    bool bReportHistograms = false;

    /*! report a PROJ.4 string corresponding to the file's coordinate system */

    bool bReportProj4 = false;

    /*! read and display image statistics. Force computation if no statistics

        are stored in an image */

    bool bStats = false;

    /*! read and display image statistics. Force computation if no statistics

        are stored in an image.  However, they may be computed based on

        overviews or a subset of all tiles. Useful if you are in a hurry and

        don't want precise stats. */

    bool bApproxStats = true;

    bool bSample = false;

    /*! force computation of the checksum for each band in the dataset */

    bool bComputeChecksum = false;

    /*! allow or suppress printing of nodata value */

    bool bShowNodata = true;

    /*! allow or suppress printing of mask information */

    bool bShowMask = true;

    /*! allow or suppress ground control points list printing. It may be useful

        for datasets with huge amount of GCPs, such as L1B AVHRR or HDF4 MODIS

        which contain thousands of them. */

    bool bShowGCPs = true;

    /*! allow or suppress metadata printing. Some datasets may contain a lot of

        metadata strings. */

    bool bShowMetadata = true;

    /*! allow or suppress printing of raster attribute table */

    bool bShowRAT = true;

    /*! allow or suppress printing of color table */

    bool bShowColorTable = true;

    /*! list all metadata domains available for the dataset */

    bool bListMDD = false;

    /*! display the file list or the first file of the file list */

    bool bShowFileList = true;

    /*! report metadata for the specified domains. "all" can be used to report

        metadata in all domains.

        */

    CPLStringList aosExtraMDDomains{};

    /*! WKT format used for SRS */

    std::string osWKTFormat = "WKT2";

    bool bStdoutOutput = false;

    /*! May be set to "gdal-raster-info" */

    std::string osInvokedFrom{};

    /*! Only used when osInvokedFrom is set to "gdal-raster-info" */

    std::string osCRSFormat{"AUTO"};

};

static int GDALInfoReportCorner(const GDALInfoOptions *psOptions,

                                GDALDatasetH hDataset,

                                OGRCoordinateTransformationH hTransform,

                                const char *corner_name, double x, double y,

                                bool bJson, json_object *poCornerCoordinates,

                                json_object *poLongLatExtentCoordinates,

                                CPLString &osStr);

static void GDALInfoReportMetadata(const GDALInfoOptions *psOptions,

                                   GDALMajorObjectH hObject, bool bIsBand,

                                   bool bJson, json_object *poMetadata,

                                   CPLString &osStr);

#ifndef Concat_defined

#define Concat_defined

static void Concat(CPLString &osRet, bool bStdoutOutput, const char *pszFormat,

                   ...) CPL_PRINT_FUNC_FORMAT(3, 4);

static void Concat(CPLString &osRet, bool bStdoutOutput, const char *pszFormat,

                   ...)

{

    va_list args;

    va_start(args, pszFormat);

    if (bStdoutOutput)

    {

        vfprintf(stdout, pszFormat, args);

    }

    else

    {

        try

        {

            CPLString osTarget;

            osTarget.vPrintf(pszFormat, args);

            osRet += osTarget;

        }

        catch (const std::bad_alloc &)

        {

            CPLError(CE_Failure, CPLE_OutOfMemory, "Out of memory");

        }

    }

    va_end(args);

}

#endif

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

/*         gdal_json_object_new_double_or_str_for_non_finite()          */

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

static json_object *

gdal_json_object_new_double_or_str_for_non_finite(double dfVal, int nPrecision)

{

    if (std::isinf(dfVal))

        return json_object_new_string(dfVal < 0 ? "-Infinity" : "Infinity");

    else if (std::isnan(dfVal))

        return json_object_new_string("NaN");

    else

        return json_object_new_double_with_precision(dfVal, nPrecision);

}

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

/*           gdal_json_object_new_double_significant_digits()           */

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

static json_object *

gdal_json_object_new_double_significant_digits(double dfVal,

                                               int nSignificantDigits)

{

    if (std::isinf(dfVal))

        return json_object_new_string(dfVal < 0 ? "-Infinity" : "Infinity");

    else if (std::isnan(dfVal))

        return json_object_new_string("NaN");

    else

        return json_object_new_double_with_significant_figures(

            dfVal, nSignificantDigits);

}

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

/*                    GDALWarpAppOptionsGetParser()                     */

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

static std::unique_ptr<GDALArgumentParser>

GDALInfoAppOptionsGetParser(GDALInfoOptions *psOptions,

                            GDALInfoOptionsForBinary *psOptionsForBinary)

{

    auto argParser = std::make_unique<GDALArgumentParser>(

        "gdalinfo", /* bForBinary=*/psOptionsForBinary != nullptr);

    argParser->add_description(_("Raster dataset information utility."));

    argParser->add_epilog(

        _("For more details, consult https://gdal.org/programs/gdalinfo.html"));

    // Hidden: only for gdal raster info

    argParser->add_argument("--invoked-from")

        .store_into(psOptions->osInvokedFrom)

        .hidden();

    // Hidden: only for gdal raster info

    argParser->add_argument("--crs-format")

        .choices("AUTO", "WKT2", "PROJJSON")

        .store_into(psOptions->osCRSFormat)

        .hidden();

    argParser->add_argument("-json")

        .flag()

        .action([psOptions](const auto &)

                { psOptions->eFormat = GDALINFO_FORMAT_JSON; })

        .help(_("Display the output in json format."));

    argParser->add_argument("-mm")

        .store_into(psOptions->bComputeMinMax)

        .help(_("Force computation of the actual min/max values for each band "

                "in the dataset."));

    {

        auto &group = argParser->add_mutually_exclusive_group();

        group.add_argument("-stats")

            .store_into(psOptions->bStats)

            .help(_("Read and display image statistics computing exact values "

                    "if required."));

        group.add_argument("-approx_stats")

            .store_into(psOptions->bApproxStats)

            .help(

                _("Read and display image statistics computing approximated "

                  "values on overviews or a subset of all tiles if required."));

    }

    argParser->add_argument("-hist")

        .store_into(psOptions->bReportHistograms)

        .help(_("Report histogram information for all bands."));

    argParser->add_usage_newline();

    argParser->add_inverted_logic_flag(

        "-nogcp", &psOptions->bShowGCPs,

        _("Suppress ground control points list printing."));

    argParser->add_inverted_logic_flag("-nomd", &psOptions->bShowMetadata,

                                       _("Suppress metadata printing."));

    argParser->add_inverted_logic_flag(

        "-norat", &psOptions->bShowRAT,

        _("Suppress printing of raster attribute table."));

    argParser->add_inverted_logic_flag("-noct", &psOptions->bShowColorTable,

                                       _("Suppress printing of color table."));

    argParser->add_inverted_logic_flag("-nofl", &psOptions->bShowFileList,

                                       _("Suppress display of the file list."));

    argParser->add_inverted_logic_flag(

        "-nonodata", &psOptions->bShowNodata,

        _("Suppress nodata printing (implies -nomask)."));

    argParser->add_inverted_logic_flag("-nomask", &psOptions->bShowMask,

                                       _("Suppress mask printing."));

    argParser->add_usage_newline();

    argParser->add_argument("-checksum")

        .flag()

        .store_into(psOptions->bComputeChecksum)

        .help(_(

            "Force computation of the checksum for each band in the dataset."));

    argParser->add_argument("-listmdd")

        .flag()

        .store_into(psOptions->bListMDD)

        .help(_("List all metadata domains available for the dataset."));

    argParser->add_argument("-proj4")

        .flag()

        .store_into(psOptions->bReportProj4)

        .help(_("Report a PROJ.4 string corresponding to the file's coordinate "

                "system."));

    argParser->add_argument("-wkt_format")

        .metavar("<WKT1|WKT1_ESRI|WKT2|WKT2_2015|WKT2_2018|WKT2_2019>")

        .choices("WKT1", "WKT1_ESRI", "WKT2", "WKT2_2015", "WKT2_2018",

                 "WKT2_2019")

        .store_into(psOptions->osWKTFormat)

        .help(_("WKT format used for SRS."));

    if (psOptionsForBinary)

    {

        argParser->add_argument("-sd")

            .metavar("<n>")

            .store_into(psOptionsForBinary->nSubdataset)

            .help(_(

                "Use subdataset of specified index (starting at 1), instead of "

                "the source dataset itself."));

    }

    argParser->add_argument("-oo")

        .metavar("<NAME>=<VALUE>")

        .append()

        .action(

            [psOptionsForBinary](const std::string &s)

            {

                if (psOptionsForBinary)

                    psOptionsForBinary->aosOpenOptions.AddString(s.c_str());

            })

        .help(_("Open option(s) for dataset."));

    argParser->add_input_format_argument(

        psOptionsForBinary ? &psOptionsForBinary->aosAllowedInputDrivers

                           : nullptr);

    argParser->add_argument("-mdd")

        .metavar("<domain>|all")

        .action(

            [psOptions](const std::string &value)

            {

                psOptions->aosExtraMDDomains =

                    CSLAddString(psOptions->aosExtraMDDomains, value.c_str());

            })

        .help(_("Report metadata for the specified domains. 'all' can be used "

                "to report metadata in all domains."));

    /* Not documented: used by gdalinfo_bin.cpp only */

    argParser->add_argument("-stdout").flag().hidden().store_into(

        psOptions->bStdoutOutput);

    if (psOptionsForBinary)

    {

        argParser->add_argument("dataset_name")

            .metavar("<dataset_name>")

            .store_into(psOptionsForBinary->osFilename)

            .help("Input dataset.");

    }

    return argParser;

}

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

/*                     GDALInfoAppGetParserUsage()                      */

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

std::string GDALInfoAppGetParserUsage()

{

    try

    {

        GDALInfoOptions sOptions;

        GDALInfoOptionsForBinary sOptionsForBinary;

        auto argParser =

            GDALInfoAppOptionsGetParser(&sOptions, &sOptionsForBinary);

        return argParser->usage();

    }

    catch (const std::exception &err)

    {

        CPLError(CE_Failure, CPLE_AppDefined, "Unexpected exception: %s",

                 err.what());

        return std::string();

    }

}

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

/*                     GetKnownCRSAuthNameAndCode()                     */

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

static std::pair<const char *, const char *>

GetKnownCRSAuthNameAndCode(const OGRSpatialReference *poSRS)

{

    const char *pszAuthName = poSRS->GetAuthorityName();

    const char *pszAuthCode = poSRS->GetAuthorityCode();

    if (pszAuthName && pszAuthCode)

    {

        OGRSpatialReference oSRSFromAuthCode;

        CPLErrorStateBackuper oBackuper(CPLQuietErrorHandler);

        const char *const apszComparisonCriteria[] = {

            "IGNORE_DATA_AXIS_TO_SRS_AXIS_MAPPING=YES",

            "CRITERION=EQUIVALENT_EXCEPT_AXIS_ORDER_GEOGCRS",

            "IGNORE_COORDINATE_EPOCH=YES", nullptr};

        if (oSRSFromAuthCode.SetFromUserInput(std::string(pszAuthName)

                                                  .append(":")

                                                  .append(pszAuthCode)

                                                  .c_str()) == OGRERR_NONE &&

            oSRSFromAuthCode.IsSame(poSRS, apszComparisonCriteria))

        {

            return {pszAuthName, pszAuthCode};

        }

    }

    return {nullptr, nullptr};

}

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

/*                              GetCRSId()                              */

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

static std::string GetCRSId(const char *pszAuthName, const char *pszAuthCode)

{

    std::string osCRSId;

    if (STARTS_WITH_CI(pszAuthName, "IAU_"))

    {

        osCRSId = "urn:ogc:def:crs:IAU:";

        osCRSId += pszAuthName + strlen("IAU_");

        osCRSId += ':';

        osCRSId += pszAuthCode;

    }

    else

    {

        osCRSId = pszAuthName;

        osCRSId += ':';

        osCRSId += pszAuthCode;

    }

    return osCRSId;

}

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

/*                        EmitSimplifiedOutput()                        */

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

static void EmitSimplifiedOutput(

    const OGRSpatialReference *poSRS, const char *pszIndent,

    const char *pszAuthName, const char *pszAuthCode,

    const std::function<void(const std::string &)> &printFunction)

{

    printFunction(CPLSPrintf("%s- name: %s\n", pszIndent, poSRS->GetName()));

    if (pszAuthName && pszAuthCode)

        printFunction(CPLSPrintf("%s- ID: %s\n", pszIndent,

                                 GetCRSId(pszAuthName, pszAuthCode).c_str()));

    const char *pszType = "Other";

    if (poSRS->IsCompound())

    {

        pszType = "Compound";

    }

    else if (poSRS->IsGeographic())

    {

        if (poSRS->GetAxesCount() == 3)

            pszType = "Geographic 3D";

        else

            pszType = "Geographic 2D";

    }

    else if (poSRS->IsGeocentric())

        pszType = "Geocentric";

    else if (poSRS->IsProjected())

        pszType = "Projected";

    else if (poSRS->IsVertical())

        pszType = "Vertical";

    printFunction(CPLSPrintf("%s- type: %s\n", pszIndent, pszType));

    if (poSRS->IsProjected() && !poSRS->IsCompound())

    {

        // Create a copy since we want to force the internal

        // WKT tree model to be WKT2 as we are going to

        // request CONVERSION

        OGRSpatialReference oSRS(*poSRS);

        const char *pszConversion = oSRS.GetAttrValue("CONVERSION");

        const std::string osConversion = pszConversion ? pszConversion : "";

        const char *pszMethod = oSRS.GetAttrValue("CONVERSION|METHOD");

        const std::string osMethod = pszMethod ? pszMethod : "";

        if (!osConversion.empty() && !osMethod.empty())

        {

            // A bit of name laundering done to deal with EPSG:3857 where

            // osConversion = "Popular Visualisation Pseudo-Mercator"

            // osMethod = "Popular Visualisation Pseudo Mercator"

            // A bit unfortunate to have to do that workaround, but as it

            // is apparently ... popular ... let's do it.

            if (CPLString(osConversion).replaceAll('-', ' ') ==

                CPLString(osMethod).replaceAll('-', ' '))

            {

                printFunction(CPLSPrintf("%s- projection type: %s\n", pszIndent,

                                         osConversion.c_str()));

            }

            else

            {

                printFunction(CPLSPrintf("%s- projection type: %s, %s\n",

                                         pszIndent, osConversion.c_str(),

                                         osMethod.c_str()));

            }

        }

        const char *pszLinearUnits = nullptr;

        poSRS->GetLinearUnits(&pszLinearUnits);

        if (pszLinearUnits)

        {

            printFunction(

                CPLSPrintf("%s- units: %s\n", pszIndent, pszLinearUnits));

        }

    }

    else if (poSRS->IsVertical() && !poSRS->IsCompound())

    {

        const char *pszLinearUnits = nullptr;

        poSRS->GetTargetLinearUnits("VERT_CS", &pszLinearUnits);

        if (pszLinearUnits)

        {

            printFunction(

                CPLSPrintf("%s- units: %s\n", pszIndent, pszLinearUnits));

        }

    }

    double dfWest = 0;

    double dfSouth = 0;

    double dfEast = 0;

    double dfNorth = 0;

    const char *pszAreaName = nullptr;

    if (poSRS->GetAreaOfUse(&dfWest, &dfSouth, &dfEast, &dfNorth, &pszAreaName))

    {

        if (pszAreaName && pszAreaName[0])

        {

            std::string osAreaOfUse(pszAreaName);

            if (osAreaOfUse.back() == '.')

                osAreaOfUse.pop_back();

            if (osAreaOfUse.size() > 40)

            {

                auto nPos = osAreaOfUse.find(" - ");

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

                    nPos = osAreaOfUse.find(", ");

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

                    nPos = osAreaOfUse.find(' ');

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

                    nPos = 40;

                osAreaOfUse.resize(nPos);

                osAreaOfUse += "...";

            }

            printFunction(CPLSPrintf("%s- area "

                                     "of use: %s, west %.2f, south %.2f, "

                                     "east %.2f, north %.2f\n",

                                     pszIndent, osAreaOfUse.c_str(), dfWest,

                                     dfSouth, dfEast, dfNorth));

        }

        else

        {

            printFunction(CPLSPrintf("%s- area "

                                     "of use: west %.2f, south %.2f, "

                                     "east %.2f, north %.2f\n",

                                     pszIndent, dfWest, dfSouth, dfEast,

                                     dfNorth));

        }

    }

}

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

/*                        EmitTextDisplayOfCRS()                        */

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

void EmitTextDisplayOfCRS(

    const OGRSpatialReference *poSRS, const std::string &osCRSFormat,

    const std::string &osIntroText,

    std::function<void(const std::string &)> printFunction)

{

    bool bSimplifyOutput = false;

    const auto [pszAuthName, pszAuthCode] = GetKnownCRSAuthNameAndCode(poSRS);

    std::unique_ptr<OGRSpatialReference> poHorizPart, poVertPart;

    const char *pszHorizAuthName = nullptr;

    const char *pszHorizAuthCode = nullptr;

    const char *pszVertAuthName = nullptr;

    const char *pszVertAuthCode = nullptr;

    if (osCRSFormat == "AUTO")

    {

        bSimplifyOutput = pszAuthName && pszAuthCode;

        if (poSRS->IsCompound())

        {

            poHorizPart = poSRS->GetCompoundComponent(0);

            poVertPart = poSRS->GetCompoundComponent(1);

            if (poHorizPart && poVertPart)

            {

                std::tie(pszHorizAuthName, pszHorizAuthCode) =

                    GetKnownCRSAuthNameAndCode(poHorizPart.get());

                std::tie(pszVertAuthName, pszVertAuthCode) =

                    GetKnownCRSAuthNameAndCode(poVertPart.get());

                if (!bSimplifyOutput)

                    bSimplifyOutput = pszHorizAuthName && pszHorizAuthCode &&

                                      pszVertAuthName && pszVertAuthCode;

            }

        }

    }

    if (bSimplifyOutput)

    {

        printFunction(osIntroText);

        printFunction(":\n");

        EmitSimplifiedOutput(poSRS, "  ", pszAuthName, pszAuthCode,

                             printFunction);

        if (pszHorizAuthName && pszHorizAuthCode && pszVertAuthName &&

            pszVertAuthCode)

        {

            printFunction("  - Horizontal part:\n");

            EmitSimplifiedOutput(poHorizPart.get(), "    ", pszHorizAuthName,

                                 pszHorizAuthCode, printFunction);

            printFunction("  - Vertical part:\n");

            EmitSimplifiedOutput(poVertPart.get(), "    ", pszVertAuthName,

                                 pszVertAuthCode, printFunction);

        }

    }

    else

    {

        if (osCRSFormat == "PROJJSON")

        {

            char *pszProjJson = nullptr;

            poSRS->exportToPROJJSON(&pszProjJson, nullptr);

            printFunction(osIntroText);

            printFunction(" PROJJSON:");

            if (pszProjJson)

            {

                printFunction("\n");

                printFunction(pszProjJson);

                printFunction("\n");

            }

            else

            {

                printFunction(" ERROR while exporting it to PROJJSON!\n");

            }

            CPLFree(pszProjJson);

        }

        else

        {

            const char *const apszWKTOptions[] = {"FORMAT=WKT2_2019",

                                                  "MULTILINE=YES", nullptr};

            printFunction(osIntroText);

            printFunction(" WKT:\n");

            printFunction(poSRS->exportToWkt(apszWKTOptions));

            printFunction("\n");

        }

    }

}

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

/*                              GDALInfo()                              */

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

/**

 * Lists various information about a GDAL supported raster dataset.

 *

 * This is the equivalent of the <a href="/programs/gdalinfo.html">gdalinfo</a>

 * utility.

 *

 * GDALInfoOptions* must be allocated and freed with GDALInfoOptionsNew()

 * and GDALInfoOptionsFree() respectively.

 *

 * @param hDataset the dataset handle.

 * @param psOptions the options structure returned by GDALInfoOptionsNew() or

 * NULL.

 * @return string corresponding to the information about the raster dataset

 * (must be freed with CPLFree()), or NULL in case of error.

 *

 * @since GDAL 2.1

 */

char *GDALInfo(GDALDatasetH hDataset, const GDALInfoOptions *psOptions)

{

    if (hDataset == nullptr)

        return nullptr;

    GDALInfoOptions *psOptionsToFree = nullptr;

    if (psOptions == nullptr)

    {

        psOptionsToFree = GDALInfoOptionsNew(nullptr, nullptr);

        psOptions = psOptionsToFree;

    }

    CPLString osStr;

    json_object *poJsonObject = nullptr;

    json_object *poBands = nullptr;

    json_object *poMetadata = nullptr;

    json_object *poStac = nullptr;

    json_object *poStacRasterBands = nullptr;

    json_object *poStacEOBands = nullptr;

    const bool bJson = psOptions->eFormat == GDALINFO_FORMAT_JSON;

    /* -------------------------------------------------------------------- */

    /*      Report general info.                                            */

    /* -------------------------------------------------------------------- */

    GDALDriverH hDriver = GDALGetDatasetDriver(hDataset);

    if (bJson)

    {

        json_object *poDescription =

            json_object_new_string(GDALGetDescription(hDataset));

        poJsonObject = json_object_new_object();

        poBands = json_object_new_array();

        poMetadata = json_object_new_object();

        poStac = json_object_new_object();

        poStacRasterBands = json_object_new_array();

        poStacEOBands = json_object_new_array();

        json_object_object_add(poJsonObject, "description", poDescription);

        if (hDriver)

        {

            json_object *poDriverShortName =

                json_object_new_string(GDALGetDriverShortName(hDriver));

            json_object *poDriverLongName =

                json_object_new_string(GDALGetDriverLongName(hDriver));

            json_object_object_add(poJsonObject, "driverShortName",

                                   poDriverShortName);

            json_object_object_add(poJsonObject, "driverLongName",

                                   poDriverLongName);

        }

    }

    else if (hDriver)

    {

        Concat(osStr, psOptions->bStdoutOutput, "Driver: %s/%s\n",

               GDALGetDriverShortName(hDriver), GDALGetDriverLongName(hDriver));

    }

    if (psOptions->bShowFileList)

    {

        // The list of files of a raster FileGDB is not super useful and potentially

        // super long, so omit it, unless the -json mode is enabled

        char **papszFileList =

            (!bJson && hDriver &&

             EQUAL(GDALGetDriverShortName(hDriver), "OpenFileGDB"))

                ? nullptr

                : GDALGetFileList(hDataset);

        if (!papszFileList || *papszFileList == nullptr)

        {

            if (bJson)

            {

                json_object *poFiles = json_object_new_array();

                json_object_object_add(poJsonObject, "files", poFiles);

            }

            else

            {

                Concat(osStr, psOptions->bStdoutOutput,

                       "Files: none associated\n");

            }

        }

        else

        {

            if (bJson)

            {

                json_object *poFiles = json_object_new_array();

                for (int i = 0; papszFileList[i] != nullptr; i++)

                {

                    json_object *poFile =

                        json_object_new_string(papszFileList[i]);

                    json_object_array_add(poFiles, poFile);

                }

                json_object_object_add(poJsonObject, "files", poFiles);

            }

            else

            {

                Concat(osStr, psOptions->bStdoutOutput, "Files: %s\n",

                       papszFileList[0]);

                for (int i = 1; papszFileList[i] != nullptr; i++)

                    Concat(osStr, psOptions->bStdoutOutput, "       %s\n",

                           papszFileList[i]);

            }

        }

        CSLDestroy(papszFileList);

    }

    if (bJson)

    {

        {

            json_object *poSize = json_object_new_array();

            json_object *poSizeX =

                json_object_new_int(GDALGetRasterXSize(hDataset));

            json_object *poSizeY =

                json_object_new_int(GDALGetRasterYSize(hDataset));

            // size is X, Y ordered

            json_object_array_add(poSize, poSizeX);

            json_object_array_add(poSize, poSizeY);

            json_object_object_add(poJsonObject, "size", poSize);

        }

        {

            json_object *poStacSize = json_object_new_array();

            json_object *poSizeX =

                json_object_new_int(GDALGetRasterXSize(hDataset));

            json_object *poSizeY =

                json_object_new_int(GDALGetRasterYSize(hDataset));

            // ... but ... proj:shape is Y, X ordered.

            json_object_array_add(poStacSize, poSizeY);

            json_object_array_add(poStacSize, poSizeX);

            json_object_object_add(poStac, "proj:shape", poStacSize);

        }

    }

    else

    {

        Concat(osStr, psOptions->bStdoutOutput, "Size is %d, %d\n",

               GDALGetRasterXSize(hDataset), GDALGetRasterYSize(hDataset));

    }

    CPLString osWKTFormat("FORMAT=");

    osWKTFormat += psOptions->osWKTFormat;

    const char *const apszWKTOptions[] = {osWKTFormat.c_str(), "MULTILINE=YES",

                                          nullptr};

    /* -------------------------------------------------------------------- */

    /*      Report projection.                                              */

    /* -------------------------------------------------------------------- */

    auto hSRS = GDALGetSpatialRef(hDataset);

    if (hSRS != nullptr)

    {

        const OGRSpatialReference *poSRS =

            OGRSpatialReference::FromHandle(hSRS);

        json_object *poCoordinateSystem = nullptr;

        if (bJson)

            poCoordinateSystem = json_object_new_object();

        const std::string osWkt = poSRS->exportToWkt(apszWKTOptions);

        const std::vector<int> anAxes = poSRS->GetDataAxisToSRSAxisMapping();

        const double dfCoordinateEpoch = poSRS->GetCoordinateEpoch();

        const char *pszAuthCode = poSRS->GetAuthorityCode();

        const char *pszAuthName = poSRS->GetAuthorityName();

        if (bJson)

        {

            json_object *poWkt = json_object_new_string(osWkt.c_str());

            if (psOptions->osWKTFormat == "WKT2")

            {

                json_object *poStacWkt = nullptr;

                json_object_deep_copy(poWkt, &poStacWkt, nullptr);

                json_object_object_add(poStac, "proj:wkt2", poStacWkt);

            }

            json_object_object_add(poCoordinateSystem, "wkt", poWkt);

            if (pszAuthCode && pszAuthName && EQUAL(pszAuthName, "EPSG"))

            {

                json_object *poEPSG = json_object_new_int64(atoi(pszAuthCode));

                json_object_object_add(poStac, "proj:epsg", poEPSG);

            }

            else

            {

                // Setting it to null is mandated by the

                // https://github.com/stac-extensions/projection#projepsg

                // when setting proj:projjson or proj:wkt2

                json_object_object_add(poStac, "proj:epsg", nullptr);

            }

            {

                char *pszProjJson = nullptr;

                OGRErr result = poSRS->exportToPROJJSON(&pszProjJson, nullptr);

                if (result == OGRERR_NONE)

                {

                    json_object *poStacProjJson =

                        json_tokener_parse(pszProjJson);

                    json_object_object_add(poStac, "proj:projjson",

                                           poStacProjJson);

                    CPLFree(pszProjJson);

                }

            }

            json_object *poAxisMapping = json_object_new_array();

            for (int nMapping : anAxes)

            {

                json_object_array_add(poAxisMapping,

                                      json_object_new_int(nMapping));

            }

            json_object_object_add(poCoordinateSystem,

                                   "dataAxisToSRSAxisMapping", poAxisMapping);

            if (dfCoordinateEpoch > 0)

            {

                json_object_object_add(

                    poJsonObject, "coordinateEpoch",

                    json_object_new_double(dfCoordinateEpoch));

            }

        }

        else

        {

            if (psOptions->osInvokedFrom == "gdal-raster-info")

            {

                EmitTextDisplayOfCRS(poSRS, psOptions->osCRSFormat,

                                     "Coordinate Reference System",