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

 *

 * Project:  MapServer

 * Purpose:  Commandline App to build tile index for raster files.

 * Author:   Frank Warmerdam, warmerdam@pobox.com

 *

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

 * Copyright (c) 2001, Frank Warmerdam, DM Solutions Group Inc

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

 *

 * SPDX-License-Identifier: MIT

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

#include "cpl_port.h"

#include "cpl_conv.h"

#include "cpl_md5.h"

#include "cpl_minixml.h"

#include "cpl_string.h"

#include "cpl_vsi_virtual.h"

#include "gdal_utils.h"

#include "gdal_priv.h"

#include "gdal_utils_priv.h"

#include "ogr_api.h"

#include "ograrrowarrayhelper.h"

#include "ogrsf_frmts.h"

#include "ogr_recordbatch.h"

#include "ogr_spatialref.h"

#include "commonutils.h"

#include "gdalargumentparser.h"

#include <ctype.h>

#include <algorithm>

#include <cmath>

#include <limits>

#include <set>

constexpr const char ARROW_FORMAT_INT32[] = "i";

constexpr const char ARROW_FORMAT_FLOAT32[] = "f";

constexpr const char ARROW_FORMAT_FLOAT64[] = "g";

constexpr const char ARROW_FORMAT_STRING[] = "u";

constexpr const char ARROW_FORMAT_BINARY[] = "z";

constexpr const char ARROW_FORMAT_LIST[] = "+l";

constexpr const char ARROW_FORMAT_STRUCT[] = "+s";

constexpr const char GEOPARQUET_GEOM_COL_NAME[] = "geometry";

constexpr int NUM_ITEMS_PROJ_BBOX = 4;

constexpr int NUM_ITEMS_PROJ_SHAPE = 2;

constexpr int NUM_ITEMS_PROJ_TRANSFORM = 9;

constexpr int ARROW_BUF_VALIDITY = 0;

constexpr int ARROW_BUF_DATA = 1;

constexpr int ARROW_BUF_BYTES = 2;

constexpr int COUNT_STAC_EXTENSIONS = 2;

typedef enum

{

    FORMAT_AUTO,

    FORMAT_WKT,

    FORMAT_EPSG,

    FORMAT_PROJ

} SrcSRSFormat;

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

/*                     GDALTileIndexRasterMetadata                      */

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

struct GDALTileIndexRasterMetadata

{

    OGRFieldType eType = OFTString;

    std::string osFieldName{};

    std::string osRasterItemName{};

};

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

/*                         GDALTileIndexOptions                         */

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

struct GDALTileIndexOptions

{

    bool bInvokedFromGdalRasterIndex = false;

    bool bOverwrite = false;

    bool bSkipErrors = false;

    std::string osFormat{};

    std::string osIndexLayerName{};

    std::string osLocationField = "location";

    CPLStringList aosLCO{};

    std::string osTargetSRS{};

    bool bWriteAbsolutePath = false;

    bool bSkipDifferentProjection = false;

    std::string osSrcSRSFieldName{};

    SrcSRSFormat eSrcSRSFormat = FORMAT_AUTO;

    double xres = std::numeric_limits<double>::quiet_NaN();

    double yres = std::numeric_limits<double>::quiet_NaN();

    double xmin = std::numeric_limits<double>::quiet_NaN();

    double ymin = std::numeric_limits<double>::quiet_NaN();

    double xmax = std::numeric_limits<double>::quiet_NaN();

    double ymax = std::numeric_limits<double>::quiet_NaN();

    std::string osBandCount{};

    std::string osNodata{};

    std::string osColorInterp{};

    std::string osDataType{};

    bool bMaskBand = false;

    std::vector<std::string> aosMetadata{};

    std::string osGTIFilename{};

    bool bRecursive = false;

    double dfMinPixelSize = std::numeric_limits<double>::quiet_NaN();

    double dfMaxPixelSize = std::numeric_limits<double>::quiet_NaN();

    std::vector<GDALTileIndexRasterMetadata> aoFetchMD{};

    std::set<std::string> oSetFilenameFilters{};

    GDALProgressFunc pfnProgress = nullptr;

    void *pProgressData = nullptr;

    std::string osProfile{};         // Only "STAC-GeoParquet" handled

    std::string osBaseURL{};         // Used for "STAC-GeoParquet"

    std::string osIdMethod{};        // Used for "STAC-GeoParquet"

    std::string osIdMetadataItem{};  // Used for "STAC-GeoParquet"

};

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

/*                            ReleaseArray()                            */

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

static void ReleaseArray(struct ArrowArray *array)

{

    CPLAssert(array->release != nullptr);

    if (array->buffers)

    {

        for (int i = 0; i < static_cast<int>(array->n_buffers); ++i)

            VSIFree(const_cast<void *>(array->buffers[i]));

        CPLFree(array->buffers);

    }

    if (array->children)

    {

        for (int i = 0; i < static_cast<int>(array->n_children); ++i)

        {

            if (array->children[i] && array->children[i]->release)

            {

                array->children[i]->release(array->children[i]);

                CPLFree(array->children[i]);

            }

        }

        CPLFree(array->children);

    }

    array->release = nullptr;

}

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

/*                  GDALTileIndexAppOptionsGetParser()                  */

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

static std::unique_ptr<GDALArgumentParser> GDALTileIndexAppOptionsGetParser(

    GDALTileIndexOptions *psOptions,

    GDALTileIndexOptionsForBinary *psOptionsForBinary)

{

    auto argParser = std::make_unique<GDALArgumentParser>(

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

    argParser->add_description(

        _("Build a tile index from a list of datasets."));

    argParser->add_epilog(

        _("For more details, see the full documentation for gdaltindex at\n"

          "https://gdal.org/programs/gdaltindex.html"));

    // Hidden as used by gdal raster index

    argParser->add_argument("--invoked-from-gdal-raster-index")

        .store_into(psOptions->bInvokedFromGdalRasterIndex)

        .hidden();

    // Hidden as used by gdal raster index

    argParser->add_argument("-skip_errors")

        .store_into(psOptions->bSkipErrors)

        .hidden();

    // Hidden as used by gdal raster index

    argParser->add_argument("-profile")

        .store_into(psOptions->osProfile)

        .hidden();

    // Hidden as used by gdal raster index

    argParser->add_argument("--base-url")

        .store_into(psOptions->osBaseURL)

        .hidden();

    // Hidden as used by gdal raster index

    argParser->add_argument("--id-method")

        .store_into(psOptions->osIdMethod)

        .hidden();

    // Hidden as used by gdal raster index

    argParser->add_argument("--id-metadata-item")

        .store_into(psOptions->osIdMetadataItem)

        .hidden();

    argParser->add_argument("-overwrite")

        .flag()

        .store_into(psOptions->bOverwrite)

        .help(_("Overwrite the output tile index file if it already exists."));

    argParser->add_argument("-recursive")

        .flag()

        .store_into(psOptions->bRecursive)

        .help(_("Whether directories specified in <file_or_dir> should be "

                "explored recursively."));

    argParser->add_argument("-filename_filter")

        .metavar("<val>")

        .append()

        .store_into(psOptions->oSetFilenameFilters)

        .help(_("Pattern that the filenames contained in directories pointed "

                "by <file_or_dir> should follow."));

    argParser->add_argument("-min_pixel_size")

        .metavar("<val>")

        .store_into(psOptions->dfMinPixelSize)

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

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

    argParser->add_argument("-max_pixel_size")

        .metavar("<val>")

        .store_into(psOptions->dfMaxPixelSize)

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

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

    argParser->add_output_format_argument(psOptions->osFormat);

    argParser->add_argument("-tileindex")

        .metavar("<field_name>")

        .store_into(psOptions->osLocationField)

        .help(_("Name of the layer in the tile index file."));

    argParser->add_argument("-write_absolute_path")

        .flag()

        .store_into(psOptions->bWriteAbsolutePath)

        .help(_("Write the absolute path of the raster files in the tile index "

                "file."));

    argParser->add_argument("-skip_different_projection")

        .flag()

        .store_into(psOptions->bSkipDifferentProjection)

        .help(_(

            "Only files with the same projection as files already inserted in "

            "the tile index will be inserted (unless -t_srs is specified)."));

    argParser->add_argument("-t_srs")

        .metavar("<srs_def>")

        .store_into(psOptions->osTargetSRS)

        .help(_("Geometries of input files will be transformed to the desired "

                "target coordinate reference system."));

    argParser->add_argument("-src_srs_name")

        .metavar("<field_name>")

        .store_into(psOptions->osSrcSRSFieldName)

        .help(_("Name of the field in the tile index file where the source SRS "

                "will be stored."));

    argParser->add_argument("-src_srs_format")

        .metavar("{AUTO|WKT|EPSG|PROJ}")

        .choices("AUTO", "WKT", "EPSG", "PROJ")

        .action(

            [psOptions](const auto &f)

            {

                if (f == "WKT")

                    psOptions->eSrcSRSFormat = FORMAT_WKT;

                else if (f == "EPSG")

                    psOptions->eSrcSRSFormat = FORMAT_EPSG;

                else if (f == "PROJ")

                    psOptions->eSrcSRSFormat = FORMAT_PROJ;

                else

                    psOptions->eSrcSRSFormat = FORMAT_AUTO;

            })

        .help(_("Format of the source SRS to store in the tile index file."));

    argParser->add_argument("-lyr_name")

        .metavar("<name>")

        .store_into(psOptions->osIndexLayerName)

        .help(_("Name of the layer in the tile index file."));

    argParser->add_layer_creation_options_argument(psOptions->aosLCO);

    // GTI driver options

    argParser->add_argument("-gti_filename")

        .metavar("<filename>")

        .store_into(psOptions->osGTIFilename)

        .help(_("Filename of the XML Virtual Tile Index file to generate."));

    // NOTE: no store_into

    argParser->add_argument("-tr")

        .metavar("<xres> <yres>")

        .nargs(2)

        .scan<'g', double>()

        .help(_("Set target resolution."));

    // NOTE: no store_into

    argParser->add_argument("-te")

        .metavar("<xmin> <ymin> <xmax> <ymax>")

        .nargs(4)

        .scan<'g', double>()

        .help(_("Set target extent in SRS unit."));

    argParser->add_argument("-ot")

        .metavar("<datatype>")

        .store_into(psOptions->osDataType)

        .help(_("Output data type."));

    argParser->add_argument("-bandcount")

        .metavar("<val>")

        .store_into(psOptions->osBandCount)

        .help(_("Number of bands of the tiles of the tile index."));

    argParser->add_argument("-nodata")

        .metavar("<val>")

        .append()

        .store_into(psOptions->osNodata)

        .help(_("Nodata value of the tiles of the tile index."));

    // Should we use choices here?

    argParser->add_argument("-colorinterp")

        .metavar("<val>")

        .append()

        .store_into(psOptions->osColorInterp)

        .help(_("Color interpretation of of the tiles of the tile index: red, "

                "green, blue, alpha, gray, undefined."));

    argParser->add_argument("-mask")

        .flag()

        .store_into(psOptions->bMaskBand)

        .help(_("Add a mask band to the tiles of the tile index."));

    argParser->add_argument("-mo")

        .metavar("<name>=<value>")

        .append()

        .store_into(psOptions->aosMetadata)

        .help(_("Write an arbitrary layer metadata item, for formats that "

                "support layer metadata."));

    // NOTE: no store_into

    argParser->add_argument("-fetch_md")

        .nargs(3)

        .metavar("<gdal_md_name> <fld_name> <fld_type>")

        .append()

        .help("Fetch a metadata item from the raster tile and write it as a "

              "field in the tile index.");

    if (psOptionsForBinary)

    {

        argParser->add_quiet_argument(&psOptionsForBinary->bQuiet);

        argParser->add_argument("index_file")

            .metavar("<index_file>")

            .store_into(psOptionsForBinary->osDest)

            .help(_("The name of the output file to create/append to."));

        argParser->add_argument("file_or_dir")

            .metavar("<file_or_dir>")

            .nargs(argparse::nargs_pattern::at_least_one)

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

                    { psOptionsForBinary->aosSrcFiles.AddString(s.c_str()); })

            .help(_(

                "The input GDAL raster files or directory, can be multiple "

                "locations separated by spaces. Wildcards may also be used."));

    }

    return argParser;

}

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

/*                   GDALTileIndexAppGetParserUsage()                   */

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

std::string GDALTileIndexAppGetParserUsage()

{

    try

    {

        GDALTileIndexOptions sOptions;

        GDALTileIndexOptionsForBinary sOptionsForBinary;

        auto argParser =

            GDALTileIndexAppOptionsGetParser(&sOptions, &sOptionsForBinary);

        return argParser->usage();

    }

    catch (const std::exception &err)

    {

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

                 err.what());

        return std::string();

    }

}

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

/*                      GDALTileIndexTileIterator                       */

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

struct GDALTileIndexTileIterator

{

    const GDALTileIndexOptions *psOptions = nullptr;

    int nSrcCount = 0;

    const char *const *papszSrcDSNames = nullptr;

    std::string osCurDir{};

    int iCurSrc = 0;

    VSIDIR *psDir = nullptr;

    CPL_DISALLOW_COPY_ASSIGN(GDALTileIndexTileIterator)

    GDALTileIndexTileIterator(const GDALTileIndexOptions *psOptionsIn,

                              int nSrcCountIn,

                              const char *const *papszSrcDSNamesIn)

        : psOptions(psOptionsIn), nSrcCount(nSrcCountIn),

          papszSrcDSNames(papszSrcDSNamesIn)

    {

    }

    void reset()

    {

        if (psDir)

            VSICloseDir(psDir);

        psDir = nullptr;

        iCurSrc = 0;

    }

    std::string next()

    {

        while (true)

        {

            if (!psDir)

            {

                if (iCurSrc == nSrcCount)

                {

                    break;

                }

                VSIStatBufL sStatBuf;

                const char *pszCurName = papszSrcDSNames[iCurSrc++];

                if (VSIStatL(pszCurName, &sStatBuf) == 0 &&

                    VSI_ISDIR(sStatBuf.st_mode))

                {

                    auto poSrcDS = std::unique_ptr<GDALDataset>(

                        GDALDataset::Open(pszCurName, GDAL_OF_RASTER, nullptr,

                                          nullptr, nullptr));

                    if (poSrcDS)

                        return pszCurName;

                    osCurDir = pszCurName;

                    psDir = VSIOpenDir(

                        osCurDir.c_str(),

                        /*nDepth=*/psOptions->bRecursive ? -1 : 0, nullptr);

                    if (!psDir)

                    {

                        CPLError(CE_Failure, CPLE_AppDefined,

                                 "Cannot open directory %s", osCurDir.c_str());

                        return std::string();

                    }

                }

                else

                {

                    return pszCurName;

                }

            }

            auto psEntry = VSIGetNextDirEntry(psDir);

            if (!psEntry)

            {

                VSICloseDir(psDir);

                psDir = nullptr;

                continue;

            }

            if (!psOptions->oSetFilenameFilters.empty())

            {

                bool bMatchFound = false;

                const std::string osFilenameOnly =

                    CPLGetFilename(psEntry->pszName);

                for (const auto &osFilter : psOptions->oSetFilenameFilters)

                {

                    if (GDALPatternMatch(osFilenameOnly.c_str(),

                                         osFilter.c_str()))

                    {

                        bMatchFound = true;

                        break;

                    }

                }

                if (!bMatchFound)

                    continue;

            }

            std::string osFilename = CPLFormFilenameSafe(

                osCurDir.c_str(), psEntry->pszName, nullptr);

            if (VSI_ISDIR(psEntry->nMode))

            {

                auto poSrcDS = std::unique_ptr<GDALDataset>(

                    GDALDataset::Open(osFilename.c_str(), GDAL_OF_RASTER,

                                      nullptr, nullptr, nullptr));

                if (poSrcDS)

                {

                    return osFilename;

                }

                continue;

            }

            return osFilename;

        }

        return std::string();

    }

};

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

/*                           GDALTileIndex()                            */

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

/* clang-format off */

/**

 * Build a tile index from a list of datasets.

 *

 * This is the equivalent of the

 * <a href="/programs/gdaltindex.html">gdaltindex</a> utility.

 *

 * GDALTileIndexOptions* must be allocated and freed with

 * GDALTileIndexOptionsNew() and GDALTileIndexOptionsFree() respectively.

 *

 * @param pszDest the destination dataset path.

 * @param nSrcCount the number of input datasets.

 * @param papszSrcDSNames the list of input dataset names

 * @param psOptionsIn the options struct returned by GDALTileIndexOptionsNew() or

 * NULL.

 * @param pbUsageError pointer to a integer output variable to store if any

 * usage error has occurred.

 * @return the output dataset (new dataset that must be closed using

 * GDALClose()) or NULL in case of error.

 *

 * @since GDAL3.9

 */

/* clang-format on */

GDALDatasetH GDALTileIndex(const char *pszDest, int nSrcCount,

                           const char *const *papszSrcDSNames,

                           const GDALTileIndexOptions *psOptionsIn,

                           int *pbUsageError)

{

    return GDALTileIndexInternal(pszDest, nullptr, nullptr, nSrcCount,

                                 papszSrcDSNames, psOptionsIn, pbUsageError);

}

GDALDatasetH GDALTileIndexInternal(const char *pszDest,

                                   GDALDatasetH hTileIndexDS, OGRLayerH hLayer,

                                   int nSrcCount,

                                   const char *const *papszSrcDSNames,

                                   const GDALTileIndexOptions *psOptionsIn,

                                   int *pbUsageError)

{

    if (nSrcCount == 0)

    {

        CPLError(CE_Failure, CPLE_AppDefined, "No input dataset specified.");

        if (pbUsageError)

            *pbUsageError = TRUE;

        return nullptr;

    }

    auto psOptions = psOptionsIn

                         ? std::make_unique<GDALTileIndexOptions>(*psOptionsIn)

                         : std::make_unique<GDALTileIndexOptions>();

    GDALTileIndexTileIterator oGDALTileIndexTileIterator(

        psOptions.get(), nSrcCount, papszSrcDSNames);

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

    /*      Create and validate target SRS if given.                        */

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

    OGRSpatialReference oTargetSRS;

    if (!psOptions->osTargetSRS.empty())

    {

        if (psOptions->bSkipDifferentProjection)

        {

            CPLError(CE_Warning, CPLE_AppDefined,

                     "-skip_different_projections does not apply "

                     "when -t_srs is requested.");

        }

        oTargetSRS.SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);

        // coverity[tainted_data]

        oTargetSRS.SetFromUserInput(psOptions->osTargetSRS.c_str());

    }

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

    /*      Open or create the target datasource                            */

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

    std::unique_ptr<GDALDataset> poTileIndexDSUnique;

    GDALDataset *poTileIndexDS = GDALDataset::FromHandle(hTileIndexDS);

    OGRLayer *poLayer = OGRLayer::FromHandle(hLayer);

    bool bExistingLayer = false;

    std::string osFormat;

    if (!hTileIndexDS)

    {

        if (psOptions->bOverwrite)

        {

            CPLPushErrorHandler(CPLQuietErrorHandler);

            auto hDriver = GDALIdentifyDriver(pszDest, nullptr);

            if (hDriver)

                GDALDeleteDataset(hDriver, pszDest);

            else

                VSIUnlink(pszDest);

            CPLPopErrorHandler();

        }

        poTileIndexDSUnique.reset(

            GDALDataset::Open(pszDest, GDAL_OF_VECTOR | GDAL_OF_UPDATE, nullptr,

                              nullptr, nullptr));

        if (poTileIndexDSUnique != nullptr)

        {

            auto poDriver = poTileIndexDSUnique->GetDriver();

            if (poDriver)

                osFormat = poDriver->GetDescription();

            if (poTileIndexDSUnique->GetLayerCount() == 1)

            {

                poLayer = poTileIndexDSUnique->GetLayer(0);

            }

            else

            {

                if (psOptions->osIndexLayerName.empty())

                {

                    CPLError(CE_Failure, CPLE_AppDefined,

                             "Multiple layers detected: -lyr_name must be "

                             "specified.");

                    if (pbUsageError)

                        *pbUsageError = true;

                    return nullptr;

                }

                CPLPushErrorHandler(CPLQuietErrorHandler);

                poLayer = poTileIndexDSUnique->GetLayerByName(

                    psOptions->osIndexLayerName.c_str());

                CPLPopErrorHandler();

            }

        }

        else

        {

            if (psOptions->osFormat.empty())

            {

                const auto aoDrivers =

                    GetOutputDriversFor(pszDest, GDAL_OF_VECTOR);

                if (aoDrivers.empty())

                {

                    CPLError(CE_Failure, CPLE_AppDefined,

                             "Cannot guess driver for %s", pszDest);

                    return nullptr;

                }

                else

                {

                    if (aoDrivers.size() > 1)

                    {

                        CPLError(

                            CE_Warning, CPLE_AppDefined,

                            "Several drivers matching %s extension. Using %s",

                            CPLGetExtensionSafe(pszDest).c_str(),

                            aoDrivers[0].c_str());

                    }

                    osFormat = aoDrivers[0];

                }

            }

            else

            {

                osFormat = psOptions->osFormat;

            }

            auto poDriver =

                GetGDALDriverManager()->GetDriverByName(osFormat.c_str());

            if (poDriver == nullptr)

            {

                CPLError(CE_Warning, CPLE_AppDefined,

                         "%s driver not available.", osFormat.c_str());

                return nullptr;

            }

            poTileIndexDSUnique.reset(

                poDriver->Create(pszDest, 0, 0, 0, GDT_Unknown, nullptr));

            if (!poTileIndexDSUnique)

                return nullptr;

        }

        poTileIndexDS = poTileIndexDSUnique.get();

    }

    const bool bIsSTACGeoParquet =

        EQUAL(psOptions->osProfile.c_str(), "STAC-GeoParquet");

    auto poOutDrv = poTileIndexDS->GetDriver();

    if (osFormat.empty() && poOutDrv)

        osFormat = poOutDrv->GetDescription();

    const char *pszVal =

        poOutDrv ? poOutDrv->GetMetadataItem(GDAL_DMD_MAX_STRING_LENGTH)

                 : nullptr;

    const int nMaxFieldSize = pszVal ? atoi(pszVal) : 0;

    const bool bFailOnErrors =

        psOptions->bInvokedFromGdalRasterIndex && !psOptions->bSkipErrors;

    bool bSkipFirstTile = false;

    // Configurable mostly/only for autotest purposes.

    const int nMaxBatchSize = std::max(

        1, atoi(CPLGetConfigOption("GDAL_RASTER_INDEX_BATCH_SIZE", "65536")));

    std::vector<ArrowSchema> topSchemas;

    std::vector<ArrowSchema *> topSchemasPointers;

    std::vector<std::unique_ptr<ArrowSchema>> auxSchemas;

    std::vector<ArrowSchema *> stacExtensionsSchemaChildren,

        linksSchemaChildren, linksItemSchemaChildren, assetsSchemaChildren,

        imageAssetSchemaChildren, imageAssetRolesSchemaChildren,

        bandsSchemaChildren, bandsItemSchemaChildren, projBboxSchemaChildren,

        projShapeSchemaChildren, projTransformSchemaChildren;

    ArrowSchema topSchema{};

    const auto noop_release = [](struct ArrowSchema *) {};

    const auto AddTopSchema = [&topSchemas, &noop_release]() -> ArrowSchema &

    {

        topSchemas.push_back(ArrowSchema{});

        topSchemas.back().release = noop_release;

        return topSchemas.back();

    };

    if (poLayer)

    {

        bExistingLayer = true;

    }

    else

    {

        std::string osLayerName;

        if (psOptions->osIndexLayerName.empty())

        {

            VSIStatBuf sStat;

            if (EQUAL(osFormat.c_str(), "ESRI Shapefile") ||

                VSIStat(pszDest, &sStat) == 0)

            {

                osLayerName = CPLGetBasenameSafe(pszDest);

            }

            else

            {

                CPLError(CE_Failure, CPLE_AppDefined,

                         "-lyr_name must be specified.");

                if (pbUsageError)

                    *pbUsageError = true;

                return nullptr;

            }

        }

        else

        {

            if (psOptions->bOverwrite)

            {

                for (int i = 0; i < poTileIndexDS->GetLayerCount(); ++i)

                {

                    auto poExistingLayer = poTileIndexDS->GetLayer(i);

                    if (poExistingLayer && poExistingLayer->GetName() ==

                                               psOptions->osIndexLayerName)

                    {

                        if (poTileIndexDS->DeleteLayer(i) != OGRERR_NONE)

                            return nullptr;

                        break;

                    }

                }

            }

            osLayerName = psOptions->osIndexLayerName;

        }

        /* get spatial reference for output file from target SRS (if set) */

        /* or from first input file */

        OGRSpatialReference oSRS;

        if (!oTargetSRS.IsEmpty())

        {

            oSRS = oTargetSRS;

        }

        else

        {

            std::string osFilename = oGDALTileIndexTileIterator.next();

            if (osFilename.empty())

            {

                CPLError(CE_Failure, CPLE_AppDefined, "Cannot find any tile");

                return nullptr;

            }

            oGDALTileIndexTileIterator.reset();

            std::unique_ptr<CPLTurnFailureIntoWarningBackuper>

                poFailureIntoWarning;

            if (!bFailOnErrors)

                poFailureIntoWarning =

                    std::make_unique<CPLTurnFailureIntoWarningBackuper>();

            CPL_IGNORE_RET_VAL(poFailureIntoWarning);

            auto poSrcDS = std::unique_ptr<GDALDataset>(GDALDataset::Open(

                osFilename.c_str(), GDAL_OF_RASTER | GDAL_OF_VERBOSE_ERROR,

                nullptr, nullptr, nullptr));

            if (!poSrcDS)

            {

                CPLError(bFailOnErrors ? CE_Failure : CE_Warning,

                         CPLE_AppDefined, "Unable to open %s%s.",

                         osFilename.c_str(), bFailOnErrors ? "" : ", skipping");

                if (bFailOnErrors)

                    return nullptr;

                bSkipFirstTile = true;

            }

            else

            {

                auto poSrcSRS = poSrcDS->GetSpatialRef();

                if (poSrcSRS)

                    oSRS = *poSrcSRS;

            }

        }

        if (bIsSTACGeoParquet)

        {

            psOptions->aosLCO.SetNameValue("ROW_GROUP_SIZE",

                                           CPLSPrintf("%d", nMaxBatchSize));

            psOptions->aosLCO.SetNameValue("GEOMETRY_ENCODING", "WKB");

            psOptions->aosLCO.SetNameValue("GEOMETRY_NAME",

                                           GEOPARQUET_GEOM_COL_NAME);

            psOptions->aosLCO.SetNameValue("FID", "");

            psOptions->aosLCO.SetNameValue("WRITE_COVERING_BBOX", "YES");

            psOptions->aosLCO.SetNameValue("COVERING_BBOX_NAME", "bbox");

            if (CPLTestBool(

                    psOptions->aosLCO.FetchNameValueDef("SORT_BY_BBOX", "NO")))

            {

                CPLError(CE_Failure, CPLE_AppDefined,

                         "SORT_BY_BBOX=YES is not compatible with "

                         "STAC-GeoParquet profile");

                return nullptr;

            }

        }

        poLayer = poTileIndexDS->CreateLayer(

            osLayerName.c_str(), oSRS.IsEmpty() ? nullptr : &oSRS, wkbPolygon,

            psOptions->aosLCO.List());

        if (!poLayer)

            return nullptr;

        if (bIsSTACGeoParquet)

        {

            const auto AddAuxSchema = [&auxSchemas, &noop_release]()

            {

                auto newSchema = std::make_unique<ArrowSchema>(ArrowSchema{});

                newSchema->release = noop_release;

                auxSchemas.push_back(std::move(newSchema));

                return auxSchemas.back().get();

            };

            // "id" field

            {

                auto &schema = AddTopSchema();

                schema.format = ARROW_FORMAT_STRING;

                schema.name = "id";

                if (!poLayer->CreateFieldFromArrowSchema(&schema))

                    return nullptr;

            }

            // "stac_extensions" field

            {

                auto &schema = AddTopSchema();

                auto &sub_schema = *AddAuxSchema();

                stacExtensionsSchemaChildren.push_back(&sub_schema);

                schema.format = ARROW_FORMAT_LIST;

                schema.name = "stac_extensions";

                schema.n_children = 1;

                schema.children = stacExtensionsSchemaChildren.data();

                sub_schema.format = ARROW_FORMAT_STRING;

                sub_schema.name = "item";

                if (!poLayer->CreateFieldFromArrowSchema(&schema))

                    return nullptr;

            }

            // "links" field

            {

                auto &links = AddTopSchema();

                auto &item = *AddAuxSchema();

                linksSchemaChildren.push_back(&item);

                auto &href = *AddAuxSchema();

                linksItemSchemaChildren.push_back(&href);

                auto &rel = *AddAuxSchema();

                linksItemSchemaChildren.push_back(&rel);

                auto &type = *AddAuxSchema();

                linksItemSchemaChildren.push_back(&type);

                auto &title = *AddAuxSchema();

                linksItemSchemaChildren.push_back(&title);

                links.format = ARROW_FORMAT_LIST;

                links.name = "links";

                links.n_children = linksSchemaChildren.size();

                links.children = linksSchemaChildren.data();

                item.format = ARROW_FORMAT_STRUCT;

                item.name = "item";

                item.n_children = linksItemSchemaChildren.size();

                item.children = linksItemSchemaChildren.data();

                href.format = ARROW_FORMAT_STRING;

                href.name = "href";

                rel.format = ARROW_FORMAT_STRING;

                rel.name = "rel";