/******************************************************************************
 *
 * Project:  GDAL
 * Purpose:  Class to handle TileMatrixSet
 * Author:   Even Rouault, <even dot rouault at spatialys.com>
 *
 ******************************************************************************
 * Copyright (c) 2020, Even Rouault <even dot rouault at spatialys.com>
 *
 * SPDX-License-Identifier: MIT
 ****************************************************************************/

#include "cpl_json.h"
#include "gdal_priv.h"
#include "ogr_spatialref.h"

#include <algorithm>
#include <cmath>
#include <cfloat>
#include <limits>

#include "tilematrixset.hpp"

//! @cond Doxygen_Suppress

namespace gdal
{

/************************************************************************/
/*                   listPredefinedTileMatrixSets()                     */
/************************************************************************/

std::vector<std::string> TileMatrixSet::listPredefinedTileMatrixSets()
{
    std::vector<std::string> l{"GoogleMapsCompatible", "WorldCRS84Quad",
                               "WorldMercatorWGS84Quad", "GoogleCRS84Quad",
                               "PseudoTMS_GlobalMercator"};
    const char *pszSomeFile = CPLFindFile("gdal", "tms_NZTM2000.json");
    if (pszSomeFile)
    {
        std::set<std::string> set;
        CPLStringList aosList(
            VSIReadDir(CPLGetDirnameSafe(pszSomeFile).c_str()));
        for (int i = 0; i < aosList.size(); i++)
        {
            const size_t nLen = strlen(aosList[i]);
            if (nLen > strlen("tms_") + strlen(".json") &&
                STARTS_WITH(aosList[i], "tms_") &&
                EQUAL(aosList[i] + nLen - strlen(".json"), ".json"))
            {
                std::string id(aosList[i] + strlen("tms_"),
                               nLen - (strlen("tms_") + strlen(".json")));
                set.insert(std::move(id));
            }
        }
        for (const std::string &id : set)
            l.push_back(id);
    }
    return l;
}

/************************************************************************/
/*                              parse()                                 */
/************************************************************************/

std::unique_ptr<TileMatrixSet> TileMatrixSet::parse(const char *fileOrDef)
{
    CPLJSONDocument oDoc;
    std::unique_ptr<TileMatrixSet> poTMS(new TileMatrixSet());

    constexpr double HALF_CIRCUMFERENCE = 6378137 * M_PI;

    if (EQUAL(fileOrDef, "GoogleMapsCompatible") ||
        EQUAL(fileOrDef, "WebMercatorQuad") ||
        EQUAL(
            fileOrDef,
            "http://www.opengis.net/def/tilematrixset/OGC/1.0/WebMercatorQuad"))
    {
        /* See http://portal.opengeospatial.org/files/?artifact_id=35326
         * (WMTS 1.0), Annex E.4 */
        // or https://docs.ogc.org/is/17-083r4/17-083r4.html#toc49
        poTMS->mTitle = "GoogleMapsCompatible";
        poTMS->mIdentifier = "GoogleMapsCompatible";
        poTMS->mCrs = "http://www.opengis.net/def/crs/EPSG/0/3857";
        poTMS->mBbox.mCrs = poTMS->mCrs;
        poTMS->mBbox.mLowerCornerX = -HALF_CIRCUMFERENCE;
        poTMS->mBbox.mLowerCornerY = -HALF_CIRCUMFERENCE;
        poTMS->mBbox.mUpperCornerX = HALF_CIRCUMFERENCE;
        poTMS->mBbox.mUpperCornerY = HALF_CIRCUMFERENCE;
        poTMS->mWellKnownScaleSet =
            "http://www.opengis.net/def/wkss/OGC/1.0/GoogleMapsCompatible";
        for (int i = 0; i <= 30; i++)
        {
            TileMatrix tm;
            tm.mId = CPLSPrintf("%d", i);
            tm.mResX = 2 * HALF_CIRCUMFERENCE / 256 / (1 << i);
            tm.mResY = tm.mResX;
            tm.mScaleDenominator = tm.mResX / 0.28e-3;
            tm.mTopLeftX = -HALF_CIRCUMFERENCE;
            tm.mTopLeftY = HALF_CIRCUMFERENCE;
            tm.mTileWidth = 256;
            tm.mTileHeight = 256;
            tm.mMatrixWidth = 1 << i;
            tm.mMatrixHeight = 1 << i;
            poTMS->mTileMatrixList.emplace_back(std::move(tm));
        }
        return poTMS;
    }

    if (EQUAL(fileOrDef, "WorldMercatorWGS84Quad") ||
        EQUAL(fileOrDef, "http://www.opengis.net/def/tilematrixset/OGC/1.0/"
                         "WorldMercatorWGS84Quad"))
    {
        // See https://docs.ogc.org/is/17-083r4/17-083r4.html#toc51
        poTMS->mTitle = "WorldMercatorWGS84Quad";
        poTMS->mIdentifier = "WorldMercatorWGS84Quad";
        poTMS->mCrs = "http://www.opengis.net/def/crs/EPSG/0/3395";
        poTMS->mBbox.mCrs = poTMS->mCrs;
        poTMS->mBbox.mLowerCornerX = -HALF_CIRCUMFERENCE;
        poTMS->mBbox.mLowerCornerY = -HALF_CIRCUMFERENCE;
        poTMS->mBbox.mUpperCornerX = HALF_CIRCUMFERENCE;
        poTMS->mBbox.mUpperCornerY = HALF_CIRCUMFERENCE;
        poTMS->mWellKnownScaleSet =
            "http://www.opengis.net/def/wkss/OGC/1.0/WorldMercatorWGS84Quad";
        for (int i = 0; i <= 30; i++)
        {
            TileMatrix tm;
            tm.mId = CPLSPrintf("%d", i);
            tm.mResX = 2 * HALF_CIRCUMFERENCE / 256 / (1 << i);
            tm.mResY = tm.mResX;
            tm.mScaleDenominator = tm.mResX / 0.28e-3;
            tm.mTopLeftX = -HALF_CIRCUMFERENCE;
            tm.mTopLeftY = HALF_CIRCUMFERENCE;
            tm.mTileWidth = 256;
            tm.mTileHeight = 256;
            tm.mMatrixWidth = 1 << i;
            tm.mMatrixHeight = 1 << i;
            poTMS->mTileMatrixList.emplace_back(std::move(tm));
        }
        return poTMS;
    }

    if (EQUAL(fileOrDef, "PseudoTMS_GlobalMercator"))
    {
        /* See global-mercator at
           http://wiki.osgeo.org/wiki/Tile_Map_Service_Specification */
        poTMS->mTitle = "PseudoTMS_GlobalMercator";
        poTMS->mIdentifier = "PseudoTMS_GlobalMercator";
        poTMS->mCrs = "http://www.opengis.net/def/crs/EPSG/0/3857";
        poTMS->mBbox.mCrs = poTMS->mCrs;
        poTMS->mBbox.mLowerCornerX = -HALF_CIRCUMFERENCE;
        poTMS->mBbox.mLowerCornerY = -HALF_CIRCUMFERENCE;
        poTMS->mBbox.mUpperCornerX = HALF_CIRCUMFERENCE;
        poTMS->mBbox.mUpperCornerY = HALF_CIRCUMFERENCE;
        for (int i = 0; i <= 29; i++)
        {
            TileMatrix tm;
            tm.mId = CPLSPrintf("%d", i);
            tm.mResX = HALF_CIRCUMFERENCE / 256 / (1 << i);
            tm.mResY = tm.mResX;
            tm.mScaleDenominator = tm.mResX / 0.28e-3;
            tm.mTopLeftX = -HALF_CIRCUMFERENCE;
            tm.mTopLeftY = HALF_CIRCUMFERENCE;
            tm.mTileWidth = 256;
            tm.mTileHeight = 256;
            tm.mMatrixWidth = 2 * (1 << i);
            tm.mMatrixHeight = 2 * (1 << i);
            poTMS->mTileMatrixList.emplace_back(std::move(tm));
        }
        return poTMS;
    }

    if (EQUAL(fileOrDef, "InspireCRS84Quad") ||
        EQUAL(fileOrDef, "PseudoTMS_GlobalGeodetic") ||
        EQUAL(fileOrDef, "WorldCRS84Quad") ||
        EQUAL(
            fileOrDef,
            "http://www.opengis.net/def/tilematrixset/OGC/1.0/WorldCRS84Quad"))
    {
        /* See InspireCRS84Quad at
         * http://inspire.ec.europa.eu/documents/Network_Services/TechnicalGuidance_ViewServices_v3.0.pdf
         */
        /* This is exactly the same as PseudoTMS_GlobalGeodetic */
        /* See global-geodetic at
         * http://wiki.osgeo.org/wiki/Tile_Map_Service_Specification */
        // See also http://docs.opengeospatial.org/is/17-083r2/17-083r2.html#76
        poTMS->mTitle = "WorldCRS84Quad";
        poTMS->mIdentifier = "WorldCRS84Quad";
        poTMS->mCrs = "http://www.opengis.net/def/crs/OGC/1.3/CRS84";
        poTMS->mBbox.mCrs = poTMS->mCrs;
        poTMS->mBbox.mLowerCornerX = -180;
        poTMS->mBbox.mLowerCornerY = -90;
        poTMS->mBbox.mUpperCornerX = 180;
        poTMS->mBbox.mUpperCornerY = 90;
        poTMS->mWellKnownScaleSet =
            "http://www.opengis.net/def/wkss/OGC/1.0/GoogleCRS84Quad";
        // Limit to zoom level 29, because at that zoom level nMatrixWidth = 2 * (1 << 29) = 1073741824
        // and at 30 it would overflow int32.
        for (int i = 0; i <= 29; i++)
        {
            TileMatrix tm;
            tm.mId = CPLSPrintf("%d", i);
            tm.mResX = 180. / 256 / (1 << i);
            tm.mResY = tm.mResX;
            tm.mScaleDenominator =
                tm.mResX * (HALF_CIRCUMFERENCE / 180) / 0.28e-3;
            tm.mTopLeftX = -180;
            tm.mTopLeftY = 90;
            tm.mTileWidth = 256;
            tm.mTileHeight = 256;
            tm.mMatrixWidth = 2 * (1 << i);
            tm.mMatrixHeight = 1 << i;
            poTMS->mTileMatrixList.emplace_back(std::move(tm));
        }
        return poTMS;
    }

    if (EQUAL(fileOrDef, "GoogleCRS84Quad") ||
        EQUAL(fileOrDef,
              "http://www.opengis.net/def/wkss/OGC/1.0/GoogleCRS84Quad"))
    {
        /* See http://portal.opengeospatial.org/files/?artifact_id=35326 (WMTS 1.0),
               Annex E.3 */
        poTMS->mTitle = "GoogleCRS84Quad";
        poTMS->mIdentifier = "GoogleCRS84Quad";
        poTMS->mCrs = "http://www.opengis.net/def/crs/OGC/1.3/CRS84";
        poTMS->mBbox.mCrs = poTMS->mCrs;
        poTMS->mBbox.mLowerCornerX = -180;
        poTMS->mBbox.mLowerCornerY = -90;
        poTMS->mBbox.mUpperCornerX = 180;
        poTMS->mBbox.mUpperCornerY = 90;
        poTMS->mWellKnownScaleSet =
            "http://www.opengis.net/def/wkss/OGC/1.0/GoogleCRS84Quad";
        for (int i = 0; i <= 30; i++)
        {
            TileMatrix tm;
            tm.mId = CPLSPrintf("%d", i);
            tm.mResX = 360. / 256 / (1 << i);
            tm.mResY = tm.mResX;
            tm.mScaleDenominator =
                tm.mResX * (HALF_CIRCUMFERENCE / 180) / 0.28e-3;
            tm.mTopLeftX = -180;
            tm.mTopLeftY = 180;
            tm.mTileWidth = 256;
            tm.mTileHeight = 256;
            tm.mMatrixWidth = 1 << i;
            tm.mMatrixHeight = 1 << i;
            poTMS->mTileMatrixList.emplace_back(std::move(tm));
        }
        return poTMS;
    }

    bool loadOk = false;
    if (  // TMS 2.0 spec
        (strstr(fileOrDef, "\"crs\"") &&
         strstr(fileOrDef, "\"tileMatrices\"")) ||
        // TMS 1.0 spec
        (strstr(fileOrDef, "\"type\"") &&
         strstr(fileOrDef, "\"TileMatrixSetType\"")) ||
        (strstr(fileOrDef, "\"identifier\"") &&
         strstr(fileOrDef, "\"boundingBox\"") &&
         strstr(fileOrDef, "\"tileMatrix\"")))
    {
        loadOk = oDoc.LoadMemory(fileOrDef);
    }
    else if (STARTS_WITH_CI(fileOrDef, "http://") ||
             STARTS_WITH_CI(fileOrDef, "https://"))
    {
        const char *const apszOptions[] = {"MAX_FILE_SIZE=1000000", nullptr};
        loadOk = oDoc.LoadUrl(fileOrDef, apszOptions);
    }
    else
    {
        VSIStatBufL sStat;
        if (VSIStatL(fileOrDef, &sStat) == 0)
        {
            loadOk = oDoc.Load(fileOrDef);
        }
        else
        {
            const char *pszFilename = CPLFindFile(
                "gdal", (std::string("tms_") + fileOrDef + ".json").c_str());
            if (pszFilename)
            {
                loadOk = oDoc.Load(pszFilename);
            }
            else
            {
                CPLError(CE_Failure, CPLE_AppDefined,
                         "Invalid tiling matrix set name");
            }
        }
    }
    if (!loadOk)
    {
        return nullptr;
    }

    auto oRoot = oDoc.GetRoot();
    const bool bIsTMSv2 =
        oRoot.GetObj("crs").IsValid() && oRoot.GetObj("tileMatrices").IsValid();

    if (!bIsTMSv2 && oRoot.GetString("type") != "TileMatrixSetType" &&
        !oRoot.GetObj("tileMatrix").IsValid())
    {
        CPLError(CE_Failure, CPLE_AppDefined,
                 "Expected type = TileMatrixSetType");
        return nullptr;
    }

    const auto GetCRS = [](const CPLJSONObject &j)
    {
        if (j.IsValid())
        {
            if (j.GetType() == CPLJSONObject::Type::String)
                return j.ToString();

            else if (j.GetType() == CPLJSONObject::Type::Object)
            {
                std::string osURI = j.GetString("uri");
                if (!osURI.empty())
                    return osURI;

                // Quite a bit of confusion around wkt.
                // See https://github.com/opengeospatial/ogcapi-tiles/issues/170
                const auto jWKT = j.GetObj("wkt");
                if (jWKT.GetType() == CPLJSONObject::Type::String)
                {
                    std::string osWKT = jWKT.ToString();
                    if (!osWKT.empty())
                        return osWKT;
                }
                else if (jWKT.GetType() == CPLJSONObject::Type::Object)
                {
                    std::string osWKT = jWKT.ToString();
                    if (!osWKT.empty())
                        return osWKT;
                }
            }
        }
        return std::string();
    };

    poTMS->mIdentifier = oRoot.GetString(bIsTMSv2 ? "id" : "identifier");
    poTMS->mTitle = oRoot.GetString("title");
    poTMS->mAbstract = oRoot.GetString(bIsTMSv2 ? "description" : "abstract");
    const auto oBbox = oRoot.GetObj("boundingBox");
    if (oBbox.IsValid())
    {
        poTMS->mBbox.mCrs = GetCRS(oBbox.GetObj("crs"));
        const auto oLowerCorner = oBbox.GetArray("lowerCorner");
        if (oLowerCorner.IsValid() && oLowerCorner.Size() == 2)
        {
            poTMS->mBbox.mLowerCornerX = oLowerCorner[0].ToDouble(NaN);
            poTMS->mBbox.mLowerCornerY = oLowerCorner[1].ToDouble(NaN);
        }
        const auto oUpperCorner = oBbox.GetArray("upperCorner");
        if (oUpperCorner.IsValid() && oUpperCorner.Size() == 2)
        {
            poTMS->mBbox.mUpperCornerX = oUpperCorner[0].ToDouble(NaN);
            poTMS->mBbox.mUpperCornerY = oUpperCorner[1].ToDouble(NaN);
        }
    }
    poTMS->mCrs = GetCRS(oRoot.GetObj(bIsTMSv2 ? "crs" : "supportedCRS"));
    poTMS->mWellKnownScaleSet = oRoot.GetString("wellKnownScaleSet");

    OGRSpatialReference oCrs;
    if (oCrs.SetFromUserInput(
            poTMS->mCrs.c_str(),
            OGRSpatialReference::SET_FROM_USER_INPUT_LIMITATIONS) !=
        OGRERR_NONE)
    {
        CPLError(CE_Failure, CPLE_AppDefined, "Cannot parse CRS %s",
                 poTMS->mCrs.c_str());
        return nullptr;
    }
    double dfMetersPerUnit = 1.0;
    if (oCrs.IsProjected())
    {
        dfMetersPerUnit = oCrs.GetLinearUnits();
    }
    else if (oCrs.IsGeographic())
    {
        dfMetersPerUnit = oCrs.GetSemiMajor() * M_PI / 180;
    }

    const auto oTileMatrices =
        oRoot.GetArray(bIsTMSv2 ? "tileMatrices" : "tileMatrix");
    if (oTileMatrices.IsValid())
    {
        double dfLastScaleDenominator = std::numeric_limits<double>::max();
        for (const auto &oTM : oTileMatrices)
        {
            TileMatrix tm;
            tm.mId = oTM.GetString(bIsTMSv2 ? "id" : "identifier");
            tm.mScaleDenominator = oTM.GetDouble("scaleDenominator");
            if (tm.mScaleDenominator >= dfLastScaleDenominator ||
                tm.mScaleDenominator <= 0)
            {
                CPLError(CE_Failure, CPLE_AppDefined,
                         "Invalid scale denominator or non-decreasing series "
                         "of scale denominators");
                return nullptr;
            }
            dfLastScaleDenominator = tm.mScaleDenominator;
            // See note g of Table 2 of
            // http://docs.opengeospatial.org/is/17-083r2/17-083r2.html
            tm.mResX = tm.mScaleDenominator * 0.28e-3 / dfMetersPerUnit;
            tm.mResY = tm.mResX;
            if (bIsTMSv2)
            {
                const auto osCornerOfOrigin = oTM.GetString("cornerOfOrigin");
                if (!osCornerOfOrigin.empty() && osCornerOfOrigin != "topLeft")
                {
                    CPLError(CE_Warning, CPLE_AppDefined,
                             "cornerOfOrigin = %s not supported",
                             osCornerOfOrigin.c_str());
                }
            }
            const auto oTopLeftCorner =
                oTM.GetArray(bIsTMSv2 ? "pointOfOrigin" : "topLeftCorner");
            if (oTopLeftCorner.IsValid() && oTopLeftCorner.Size() == 2)
            {
                tm.mTopLeftX = oTopLeftCorner[0].ToDouble(NaN);
                tm.mTopLeftY = oTopLeftCorner[1].ToDouble(NaN);
            }
            tm.mTileWidth = oTM.GetInteger("tileWidth");
            if (tm.mTileWidth <= 0)
            {
                CPLError(CE_Failure, CPLE_AppDefined, "Invalid tileWidth: %d",
                         tm.mTileWidth);
                return nullptr;
            }
            tm.mTileHeight = oTM.GetInteger("tileHeight");
            if (tm.mTileHeight <= 0)
            {
                CPLError(CE_Failure, CPLE_AppDefined, "Invalid tileHeight: %d",
                         tm.mTileHeight);
                return nullptr;
            }
            if (tm.mTileWidth > INT_MAX / tm.mTileHeight)
            {
                CPLError(CE_Failure, CPLE_AppDefined,
                         "tileWidth(%d) x tileHeight(%d) larger than "
                         "INT_MAX",
                         tm.mTileWidth, tm.mTileHeight);
                return nullptr;
            }
            tm.mMatrixWidth = oTM.GetInteger("matrixWidth");
            if (tm.mMatrixWidth <= 0)
            {
                CPLError(CE_Failure, CPLE_AppDefined, "Invalid matrixWidth: %d",
                         tm.mMatrixWidth);
                return nullptr;
            }
            tm.mMatrixHeight = oTM.GetInteger("matrixHeight");
            if (tm.mMatrixHeight <= 0)
            {
                CPLError(CE_Failure, CPLE_AppDefined,
                         "Invalid matrixHeight: %d", tm.mMatrixHeight);
                return nullptr;
            }

            const auto oVariableMatrixWidths = oTM.GetArray(
                bIsTMSv2 ? "variableMatrixWidths" : "variableMatrixWidth");
            if (oVariableMatrixWidths.IsValid())
            {
                for (const auto &oVMW : oVariableMatrixWidths)
                {
                    TileMatrix::VariableMatrixWidth vmw;
                    vmw.mCoalesce = oVMW.GetInteger("coalesce");
                    vmw.mMinTileRow = oVMW.GetInteger("minTileRow");
                    vmw.mMaxTileRow = oVMW.GetInteger("maxTileRow");
                    tm.mVariableMatrixWidthList.emplace_back(std::move(vmw));
                }
            }

            poTMS->mTileMatrixList.emplace_back(std::move(tm));
        }
    }
    if (poTMS->mTileMatrixList.empty())
    {
        CPLError(CE_Failure, CPLE_AppDefined, "No tileMatrix defined");
        return nullptr;
    }

    return poTMS;
}

/************************************************************************/
/*                       haveAllLevelsSameTopLeft()                     */
/************************************************************************/

bool TileMatrixSet::haveAllLevelsSameTopLeft() const
{
    for (const auto &oTM : mTileMatrixList)
    {
        if (oTM.mTopLeftX != mTileMatrixList[0].mTopLeftX ||
            oTM.mTopLeftY != mTileMatrixList[0].mTopLeftY)
        {
            return false;
        }
    }
    return true;
}

/************************************************************************/
/*                      haveAllLevelsSameTileSize()                     */
/************************************************************************/

bool TileMatrixSet::haveAllLevelsSameTileSize() const
{
    for (const auto &oTM : mTileMatrixList)
    {
        if (oTM.mTileWidth != mTileMatrixList[0].mTileWidth ||
            oTM.mTileHeight != mTileMatrixList[0].mTileHeight)
        {
            return false;
        }
    }
    return true;
}

/************************************************************************/
/*                    hasOnlyPowerOfTwoVaryingScales()                  */
/************************************************************************/

bool TileMatrixSet::hasOnlyPowerOfTwoVaryingScales() const
{
    for (size_t i = 1; i < mTileMatrixList.size(); i++)
    {
        if (mTileMatrixList[i].mScaleDenominator == 0 ||
            std::fabs(mTileMatrixList[i - 1].mScaleDenominator /
                          mTileMatrixList[i].mScaleDenominator -
                      2) > 1e-10)
        {
            return false;
        }
    }
    return true;
}

/************************************************************************/
/*                        hasVariableMatrixWidth()                      */
/************************************************************************/

bool TileMatrixSet::hasVariableMatrixWidth() const
{
    for (const auto &oTM : mTileMatrixList)
    {
        if (!oTM.mVariableMatrixWidthList.empty())
        {
            return true;
        }
    }
    return false;
}

/************************************************************************/
/*                            createRaster()                            */
/************************************************************************/

/* static */
std::unique_ptr<TileMatrixSet>
TileMatrixSet::createRaster(int width, int height, int tileSize,
                            int zoomLevelCount, double dfTopLeftX,
                            double dfTopLeftY, double dfResXFull,
                            double dfResYFull, const std::string &crs)
{
    CPLAssert(width > 0);
    CPLAssert(height > 0);
    CPLAssert(tileSize > 0);
    CPLAssert(zoomLevelCount > 0);
    std::unique_ptr<TileMatrixSet> poTMS(new TileMatrixSet());
    poTMS->mTitle = "raster";
    poTMS->mIdentifier = "raster";
    poTMS->mCrs = crs;
    poTMS->mBbox.mCrs = poTMS->mCrs;
    poTMS->mBbox.mLowerCornerX = dfTopLeftX;
    poTMS->mBbox.mLowerCornerY = dfTopLeftY - height * dfResYFull;
    poTMS->mBbox.mUpperCornerX = dfTopLeftX + width * dfResYFull;
    poTMS->mBbox.mUpperCornerY = dfTopLeftY;
    for (int i = 0; i < zoomLevelCount; i++)
    {
        TileMatrix tm;
        tm.mId = CPLSPrintf("%d", i);
        const int iRev = zoomLevelCount - 1 - i;
        tm.mResX = dfResXFull * (1 << iRev);
        tm.mResY = dfResYFull * (1 << iRev);
        tm.mScaleDenominator = tm.mResX / 0.28e-3;
        tm.mTopLeftX = poTMS->mBbox.mLowerCornerX;
        tm.mTopLeftY = poTMS->mBbox.mUpperCornerY;
        tm.mTileWidth = tileSize;
        tm.mTileHeight = tileSize;
        tm.mMatrixWidth = std::max(1, DIV_ROUND_UP(width >> iRev, tileSize));
        tm.mMatrixHeight = std::max(1, DIV_ROUND_UP(height >> iRev, tileSize));
        poTMS->mTileMatrixList.emplace_back(std::move(tm));
    }
    return poTMS;
}

/************************************************************************/
/*                        exportToTMSJsonV1()                           */
/************************************************************************/

std::string TileMatrixSet::exportToTMSJsonV1() const
{
    CPLJSONObject oRoot;
    oRoot["type"] = "TileMatrixSetType";
    oRoot["title"] = mTitle;
    oRoot["identifier"] = mIdentifier;
    if (!mAbstract.empty())
        oRoot["abstract"] = mAbstract;
    if (!std::isnan(mBbox.mLowerCornerX))
    {
        CPLJSONObject oBbox;
        oBbox["type"] = "BoundingBoxType";
        oBbox["crs"] = mBbox.mCrs;
        oBbox["lowerCorner"] = {mBbox.mLowerCornerX, mBbox.mLowerCornerY};
        oBbox["upperCorner"] = {mBbox.mUpperCornerX, mBbox.mUpperCornerY};
        oRoot["boundingBox"] = std::move(oBbox);
    }
    oRoot["supportedCRS"] = mCrs;
    if (!mWellKnownScaleSet.empty())
        oRoot["wellKnownScaleSet"] = mWellKnownScaleSet;

    CPLJSONArray oTileMatrices;
    for (const auto &tm : mTileMatrixList)
    {
        CPLJSONObject oTM;
        oTM["type"] = "TileMatrixType";
        oTM["identifier"] = tm.mId;
        oTM["scaleDenominator"] = tm.mScaleDenominator;
        oTM["topLeftCorner"] = {tm.mTopLeftX, tm.mTopLeftY};
        oTM["tileWidth"] = tm.mTileWidth;
        oTM["tileHeight"] = tm.mTileHeight;
        oTM["matrixWidth"] = tm.mMatrixWidth;
        oTM["matrixHeight"] = tm.mMatrixHeight;

        if (!tm.mVariableMatrixWidthList.empty())
        {
            CPLJSONArray oVariableMatrixWidths;
            for (const auto &vmw : tm.mVariableMatrixWidthList)
            {
                CPLJSONObject oVMW;
                oVMW["coalesce"] = vmw.mCoalesce;
                oVMW["minTileRow"] = vmw.mMinTileRow;
                oVMW["maxTileRow"] = vmw.mMaxTileRow;
                oVariableMatrixWidths.Add(oVMW);
            }
            oTM["variableMatrixWidth"] = oVariableMatrixWidths;
        }

        oTileMatrices.Add(oTM);
    }
    oRoot["tileMatrix"] = oTileMatrices;
    return CPLString(oRoot.Format(CPLJSONObject::PrettyFormat::Pretty))
        .replaceAll("\\/", '/');
}

}  // namespace gdal

//! @endcond