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

 *

 * Project:  WMS Client Driver

 * Purpose:  Supporting utility functions for GDAL WMS driver.

 * Author:   Adam Nowacki, nowak@xpam.de

 *

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

 * Copyright (c) 2007, Adam Nowacki

 *

 * SPDX-License-Identifier: MIT

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

#include "wmsdriver.h"

OGRSpatialReference ProjToSRS(const CPLString &proj)

{

    OGRSpatialReference sr;

    sr.SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);

    CPLString srs;

    /* We could of course recognize OSGEO:41001 to SetFromUserInput(), but this

     * hackish SRS */

    /* is almost only used in the context of WMS */

    if (strcmp(proj.c_str(), "OSGEO:41001") == 0)

    {

        sr.importFromEPSG(3857);

    }

    else if (EQUAL(proj.c_str(), "EPSG:NONE"))

    {

        // do nothing

    }

    else

    {

        sr.SetFromUserInput(

            proj.c_str(),

            OGRSpatialReference::SET_FROM_USER_INPUT_LIMITATIONS_get());

    }

    return sr;

}

// Terminates an URL base with either ? or &, so extra args can be appended

void URLPrepare(CPLString &url)

{

    if (url.find("?") == std::string::npos)

    {

        url.append("?");

    }

    else

    {

        if (*url.rbegin() != '?' && *url.rbegin() != '&')

            url.append("&");

    }

}

CPLString BufferToVSIFile(GByte *buffer, size_t size)

{

    CPLString file_name(VSIMemGenerateHiddenFilename("wmsresult.dat"));

    VSILFILE *f = VSIFileFromMemBuffer(file_name.c_str(), buffer, size, false);

    if (f == nullptr)

        return CPLString();

    VSIFCloseL(f);

    return file_name;

}

int VersionStringToInt(const char *version)

{

    if (version == nullptr)

        return -1;

    const char *p = version;

    int v = 0;

    for (int i = 3; i >= 0; --i)

    {

        int n = atoi(p);

        if (n < 0 || n >= 100)

            return -1;

        v += (1 << (i * 8)) * n;

        for (; (*p != '\0') && (*p != '.'); ++p)

            ;

        if (*p != '\0')

            ++p;

    }

    return v;

}

int StrToBool(const char *p)

{

    if (p == nullptr)

        return -1;

    if (EQUAL(p, "1") || EQUAL(p, "true") || EQUAL(p, "yes") ||

        EQUAL(p, "enable") || EQUAL(p, "enabled") || EQUAL(p, "on"))

        return 1;

    if (EQUAL(p, "0") || EQUAL(p, "false") || EQUAL(p, "no") ||

        EQUAL(p, "disable") || EQUAL(p, "disabled") || EQUAL(p, "off"))

        return 0;

    return -1;

}

int URLSearchAndReplace(CPLString *base, const char *search, const char *fmt,

                        ...)

{

    CPLString tmp;

    va_list args;

    size_t start = base->find(search);

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

    {

        return -1;

    }

    va_start(args, fmt);

    tmp.vPrintf(fmt, args);

    va_end(args);

    base->replace(start, strlen(search), tmp);

    return static_cast<int>(start);

}

// decode s from base64, XMLencoded or read from the file name s

const char *WMSUtilDecode(CPLString &s, const char *encoding)

{

    if (EQUAL(encoding, "base64"))

    {

        std::vector<char> buffer(s.begin(), s.end());

        buffer.push_back('\0');

        int nSize =

            CPLBase64DecodeInPlace(reinterpret_cast<GByte *>(&buffer[0]));

        s.assign(&buffer[0], nSize);

    }

    else if (EQUAL(encoding, "XMLencoded"))

    {

        int len = static_cast<int>(s.size());

        char *result = CPLUnescapeString(s.c_str(), &len, CPLES_XML);

        s.assign(result, static_cast<size_t>(len));

        CPLFree(result);

    }

    else if (EQUAL(encoding, "file"))

    {  // Not an encoding but an external file

        VSILFILE *f = VSIFOpenL(s.c_str(), "rb");

        s.clear();  // Return an empty string if file can't be opened or read

        if (f)

        {

            VSIFSeekL(f, 0, SEEK_END);

            size_t size = static_cast<size_t>(VSIFTellL(f));

            VSIFSeekL(f, 0, SEEK_SET);

            std::vector<char> buffer(size);

            if (VSIFReadL(reinterpret_cast<void *>(&buffer[0]), size, 1, f))

                s.assign(&buffer[0], buffer.size());

            VSIFCloseL(f);

        }

    }

    return s.c_str();

}