/******************************************************************************
 *
 * Project:  WMS Client Driver
 * Purpose:  Implementation of Dataset and RasterBand classes for WMS
 *           and other similar services.
 * Author:   Adam Nowacki, nowak@xpam.de
 *
 ******************************************************************************
 * Copyright (c) 2007, Adam Nowacki
 * Copyright (c) 2008-2013, Even Rouault <even dot rouault at spatialys.com>
 * Copyright (c) 2017, Dmitry Baryshnikov, <polimax@mail.ru>
 * Copyright (c) 2017, NextGIS, <info@nextgis.com>
 *
 * SPDX-License-Identifier: MIT
 ****************************************************************************/

#ifndef WMSDRIVER_H_INCLUDED
#define WMSDRIVER_H_INCLUDED

#include <algorithm>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <utility>

#include "cpl_conv.h"
#include "cpl_curl_priv.h"
#include "cpl_http.h"
#include "gdal_alg.h"
#include "gdal_pam.h"
#include "gdalwarper.h"
#include "ogr_spatialref.h"

#include "gdalhttp.h"

class GDALWMSDataset;
class GDALWMSRasterBand;

/* -------------------------------------------------------------------- */
/*      Helper functions.                                               */
/* -------------------------------------------------------------------- */
OGRSpatialReference ProjToSRS(const CPLString &proj);

// Decode s from encoding "base64" or "XMLencoded".
// If encoding is "file", s is the file name on input and file content on output
// If encoding is not recognized, does nothing
const char *WMSUtilDecode(CPLString &s, const char *encoding);

// Ensure that the url ends in ? or &
void URLPrepare(CPLString &url);
// void URLAppend(CPLString *url, const char *s);
// void URLAppendF(CPLString *url, const char *s, ...) CPL_PRINT_FUNC_FORMAT (2,
// 3); void URLAppend(CPLString *url, const CPLString &s);
CPLString BufferToVSIFile(GByte *buffer, size_t size);

int StrToBool(const char *p);
int URLSearchAndReplace(CPLString *base, const char *search, const char *fmt,
                        ...) CPL_PRINT_FUNC_FORMAT(3, 4);
/* Convert a.b.c.d to a * 0x1000000 + b * 0x10000 + c * 0x100 + d */
int VersionStringToInt(const char *version);

class GDALWMSImageRequestInfo
{
  public:
    double m_x0{}, m_y0{};
    double m_x1{}, m_y1{};
    int m_sx{}, m_sy{};
};

class GDALWMSDataWindow
{
  public:
    double m_x0, m_y0;
    double m_x1, m_y1;
    int m_sx, m_sy;
    int m_tx, m_ty, m_tlevel;

    enum
    {
        BOTTOM = -1,
        DEFAULT = 0,
        TOP = 1
    } m_y_origin;

    GDALWMSDataWindow()
        : m_x0(-180), m_y0(90), m_x1(180), m_y1(-90), m_sx(-1), m_sy(-1),
          m_tx(0), m_ty(0), m_tlevel(-1), m_y_origin(DEFAULT)
    {
    }
};

class GDALWMSTiledImageRequestInfo
{
  public:
    int m_x{}, m_y{};
    int m_level{};
};

/************************************************************************/
/*                         Mini Driver Related                          */
/************************************************************************/

class GDALWMSRasterIOHint
{
  public:
    GDALWMSRasterIOHint()
        : m_x0(0), m_y0(0), m_sx(0), m_sy(0), m_overview(0), m_valid(false)
    {
    }

    int m_x0;
    int m_y0;
    int m_sx;
    int m_sy;
    int m_overview;
    bool m_valid;
};

typedef enum
{
    OVERVIEW_ROUNDED,
    OVERVIEW_FLOOR
} GDALWMSOverviewDimComputationMethod;

class WMSMiniDriverCapabilities
{
  public:
    // Default capabilities, suitable in most cases
    WMSMiniDriverCapabilities() = default;

    int m_has_getinfo{0};  // Does it have meaningful implementation
    int m_has_geotransform{1};
    GDALWMSOverviewDimComputationMethod m_overview_dim_computation_method{
        OVERVIEW_ROUNDED};
};

/* All data returned by mini-driver as pointer should remain valid for
   mini-driver lifetime and should be freed by mini-driver destructor unless
   otherwise specified.
 */

// Base class for minidrivers
// A minidriver has to implement at least the Initialize and the
// TiledImageRequest
//
class WMSMiniDriver /* non final */
{
    friend class GDALWMSDataset;

    CPL_DISALLOW_COPY_ASSIGN(WMSMiniDriver)

  public:
    WMSMiniDriver() : m_parent_dataset(nullptr)
    {
        m_oSRS.SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);
    }

    virtual ~WMSMiniDriver();

  public:
    // MiniDriver specific initialization from XML, required
    // Called once at the beginning of the dataset initialization
    virtual CPLErr Initialize(CPLXMLNode *config, char **papszOpenOptions) = 0;

    // Called once at the end of the dataset initialization
    virtual CPLErr EndInit()
    {
        return CE_None;
    }

    // Error message returned in url, required
    // Set error message in request.Error
    // If tile doesn't exist serverside, set request.range to "none"
    virtual CPLErr
    TiledImageRequest(CPL_UNUSED WMSHTTPRequest &,
                      CPL_UNUSED const GDALWMSImageRequestInfo &iri,
                      CPL_UNUSED const GDALWMSTiledImageRequestInfo &tiri) = 0;

    // change capabilities to be used by the parent
    virtual void GetCapabilities(CPL_UNUSED WMSMiniDriverCapabilities *caps)
    {
    }

    // signal by setting the m_has_getinfo in the GetCapabilities call
    virtual void
    GetTiledImageInfo(CPL_UNUSED CPLString &url,
                      CPL_UNUSED const GDALWMSImageRequestInfo &iri,
                      CPL_UNUSED const GDALWMSTiledImageRequestInfo &tiri,
                      CPL_UNUSED int nXInBlock, CPL_UNUSED int nYInBlock)
    {
    }

    virtual const OGRSpatialReference &GetSpatialRef() const
    {
        return m_oSRS;
    }

    virtual char **GetMetadataDomainList()
    {
        return nullptr;
    }

  protected:
    CPLString m_base_url{};
    OGRSpatialReference m_oSRS{};
    GDALWMSDataset *m_parent_dataset{};
};

class WMSMiniDriverFactory /* non final */
{
  public:
    virtual ~WMSMiniDriverFactory();
    virtual WMSMiniDriver *New() const = 0;
    CPLString m_name{};

  protected:
    WMSMiniDriverFactory() = default;
};

// Interface with the global mini driver manager
WMSMiniDriver *NewWMSMiniDriver(const CPLString &name);
void WMSRegisterMiniDriverFactory(WMSMiniDriverFactory *mdf);
void WMSDeregisterMiniDrivers(GDALDriver *);

// WARNING: Called by GDALDestructor, unsafe to use any static objects
void WMSDeregister(GDALDriver *);

/************************************************************************/
/*                             GDALWMSCache                             */
/************************************************************************/
enum GDALWMSCacheItemStatus
{
    CACHE_ITEM_NOT_FOUND,
    CACHE_ITEM_OK,
    CACHE_ITEM_EXPIRED
};

class GDALWMSCacheImpl /* non final */
{
  public:
    GDALWMSCacheImpl(const CPLString &soPath, CPLXMLNode * /*pConfig*/)
        : m_soPath(soPath)
    {
    }

    virtual ~GDALWMSCacheImpl();

    virtual CPLErr Insert(const char *pszKey, const CPLString &osFileName) = 0;
    virtual enum GDALWMSCacheItemStatus
    GetItemStatus(const char *pszKey) const = 0;
    virtual GDALDataset *GetDataset(const char *pszKey,
                                    char **papszOpenOptions) const = 0;
    virtual void Clean() = 0;
    virtual int GetCleanThreadRunTimeout() = 0;

  protected:
    CPLString m_soPath;
};

class GDALWMSCache final
{
    friend class GDALWMSDataset;

  public:
    GDALWMSCache();
    ~GDALWMSCache();

  public:
    CPLErr Initialize(const char *pszUrl, CPLXMLNode *pConfig);
    CPLErr Insert(const char *pszKey, const CPLString &osFileName);
    enum GDALWMSCacheItemStatus GetItemStatus(const char *pszKey) const;
    GDALDataset *GetDataset(const char *pszKey, char **papszOpenOptions) const;
    void Clean();

  protected:
    CPLString CachePath() const
    {
        return m_osCachePath;
    }

  protected:
    CPLString m_osCachePath{};
    bool m_bIsCleanThreadRunning = false;
    time_t m_nCleanThreadLastRunTime = 0;

  private:
    GDALWMSCacheImpl *m_poCache = nullptr;
    CPLJoinableThread *m_hThread = nullptr;

    CPL_DISALLOW_COPY_ASSIGN(GDALWMSCache)
};

/************************************************************************/
/*                            GDALWMSDataset                            */
/************************************************************************/

class GDALWMSDataset final : public GDALPamDataset
{
    friend class GDALWMSRasterBand;

    CPL_DISALLOW_COPY_ASSIGN(GDALWMSDataset)

  public:
    GDALWMSDataset();
    ~GDALWMSDataset() override;

    const OGRSpatialReference *GetSpatialRef() const override;
    CPLErr SetSpatialRef(const OGRSpatialReference *poSRS) override;

    CPLErr GetGeoTransform(GDALGeoTransform &gt) const override;
    CPLErr SetGeoTransform(const GDALGeoTransform &gt) override;
    CPLErr AdviseRead(int x0, int y0, int sx, int sy, int bsx, int bsy,
                      GDALDataType bdt, int band_count, int *band_map,
                      CSLConstList options) override;

    char **GetMetadataDomainList() override;
    virtual const char *GetMetadataItem(const char *pszName,
                                        const char *pszDomain = "") override;

    void SetColorTable(GDALColorTable *pct)
    {
        m_poColorTable = pct;
    }

    void mSetBand(int i, GDALRasterBand *band)
    {
        SetBand(i, band);
    }

    GDALWMSRasterBand *mGetBand(int i)
    {
        return reinterpret_cast<GDALWMSRasterBand *>(GetRasterBand(i));
    }

    const GDALWMSDataWindow *WMSGetDataWindow() const
    {
        return &m_data_window;
    }

    void WMSSetBlockSize(int x, int y)
    {
        m_block_size_x = x;
        m_block_size_y = y;
    }

    void WMSSetRasterSize(int x, int y)
    {
        nRasterXSize = x;
        nRasterYSize = y;
    }

    void WMSSetBandsCount(int count)
    {
        nBands = count;
    }

    void WMSSetClamp(bool flag = true)
    {
        m_clamp_requests = flag;
    }

    void WMSSetDataType(GDALDataType type)
    {
        m_data_type = type;
    }

    void WMSSetDataWindow(const GDALWMSDataWindow &window)
    {
        m_data_window = window;
    }

    void WMSSetDefaultBlockSize(int x, int y)
    {
        m_default_block_size_x = x;
        m_default_block_size_y = y;
    }

    void WMSSetDefaultDataWindowCoordinates(double x0, double y0, double x1,
                                            double y1)
    {
        m_default_data_window.m_x0 = x0;
        m_default_data_window.m_y0 = y0;
        m_default_data_window.m_x1 = x1;
        m_default_data_window.m_y1 = y1;
    }

    void WMSSetDefaultTileCount(int tilecountx, int tilecounty)
    {
        m_default_tile_count_x = tilecountx;
        m_default_tile_count_y = tilecounty;
    }

    void WMSSetDefaultTileLevel(int tlevel)
    {
        m_default_data_window.m_tlevel = tlevel;
    }

    void WMSSetDefaultOverviewCount(int overview_count)
    {
        m_default_overview_count = overview_count;
    }

    void WMSSetNeedsDataWindow(bool flag)
    {
        m_bNeedsDataWindow = flag;
    }

    static void list2vec(std::vector<double> &v, const char *pszList)
    {
        if ((pszList == nullptr) || (pszList[0] == 0))
            return;
        char **papszTokens = CSLTokenizeString2(
            pszList, " \t\n\r", CSLT_STRIPLEADSPACES | CSLT_STRIPENDSPACES);
        v.clear();
        for (int i = 0; i < CSLCount(papszTokens); i++)
            v.push_back(CPLStrtod(papszTokens[i], nullptr));
        CSLDestroy(papszTokens);
    }

    void WMSSetNoDataValue(const char *pszNoData)
    {
        list2vec(vNoData, pszNoData);
    }

    void WMSSetMinValue(const char *pszMin)
    {
        list2vec(vMin, pszMin);
    }

    void WMSSetMaxValue(const char *pszMax)
    {
        list2vec(vMax, pszMax);
    }

    // Set open options for tiles
    // Works like a <set>, only one entry with a give name can exist, last one
    // set wins If the value is null, the entry is deleted
    void SetTileOO(const char *pszName, const char *pszValue);

    void SetXML(const char *psz)
    {
        m_osXML.clear();
        if (psz)
            m_osXML = psz;
    }

    static GDALDataset *Open(GDALOpenInfo *poOpenInfo);
    static GDALDataset *CreateCopy(const char *pszFilename,
                                   GDALDataset *poSrcDS, int bStrict,
                                   CSLConstList papszOptions,
                                   GDALProgressFunc pfnProgress,
                                   void *pProgressData);

    const char *const *GetHTTPRequestOpts();

    static const char *GetServerConfig(const char *URI,
                                       char **papszHTTPOptions);
    static void DestroyCfgMutex();
    static void ClearConfigCache();

  protected:
    CPLErr IRasterIO(GDALRWFlag rw, int x0, int y0, int sx, int sy,
                     void *buffer, int bsx, int bsy, GDALDataType bdt,
                     int band_count, BANDMAP_TYPE band_map,
                     GSpacing nPixelSpace, GSpacing nLineSpace,
                     GSpacing nBandSpace,
                     GDALRasterIOExtraArg *psExtraArg) override;
    CPLErr Initialize(CPLXMLNode *config, char **papszOpenOptions);

    GDALWMSDataWindow m_data_window{};
    WMSMiniDriver *m_mini_driver{};
    WMSMiniDriverCapabilities m_mini_driver_caps{};
    GDALWMSCache *m_cache{};
    OGRSpatialReference m_oSRS{};
    GDALColorTable *m_poColorTable{};
    std::vector<double> vNoData{};
    std::vector<double> vMin{};
    std::vector<double> vMax{};
    GDALDataType m_data_type{GDT_Unknown};
    int m_block_size_x{};
    int m_block_size_y{};
    GDALWMSRasterIOHint m_hint{};
    int m_use_advise_read{};
    int m_verify_advise_read{};
    int m_offline_mode{};
    int m_http_max_conn{};
    int m_http_timeout{};
    char **m_http_options{};
    // Open Option list for tiles
    char **m_tileOO{};
    int m_clamp_requests{};
    int m_unsafeSsl{};
    std::set<int> m_http_zeroblock_codes{};
    int m_zeroblock_on_serverexceptions{};
    CPLString m_osUserAgent{};
    CPLString m_osReferer{};
    CPLString m_osUserPwd{};
    std::string m_osAccept{};  // HTTP Accept header

    GDALWMSDataWindow m_default_data_window{};
    int m_default_block_size_x{};
    int m_default_block_size_y{};
    int m_default_tile_count_x{};
    int m_default_tile_count_y{};
    int m_default_overview_count{};

    bool m_bNeedsDataWindow{};

    CPLString m_osXML{};

    // Per session cache of server configurations
    typedef std::map<CPLString, CPLString> StringMap_t;
    static CPLMutex *cfgmtx;
    static StringMap_t cfg;
};

/************************************************************************/
/*                          GDALWMSRasterBand                           */
/************************************************************************/

class GDALWMSRasterBand final : public GDALPamRasterBand
{
    friend class GDALWMSDataset;
    void ComputeRequestInfo(GDALWMSImageRequestInfo &iri,
                            GDALWMSTiledImageRequestInfo &tiri, int x, int y);

    CPLString osMetadataItem{};
    CPLString osMetadataItemURL{};

    CPL_DISALLOW_COPY_ASSIGN(GDALWMSRasterBand)

  public:
    GDALWMSRasterBand(GDALWMSDataset *parent_dataset, int band, double scale);
    ~GDALWMSRasterBand() override;
    bool AddOverview(double scale);
    double GetNoDataValue(int *) override;
    double GetMinimum(int *) override;
    double GetMaximum(int *) override;
    GDALColorTable *GetColorTable() override;
    CPLErr AdviseRead(int x0, int y0, int sx, int sy, int bsx, int bsy,
                      GDALDataType bdt, CSLConstList options) override;

    GDALColorInterp GetColorInterpretation() override;
    CPLErr SetColorInterpretation(GDALColorInterp) override;
    CPLErr IReadBlock(int x, int y, void *buffer) override;
    CPLErr IRasterIO(GDALRWFlag rw, int x0, int y0, int sx, int sy,
                     void *buffer, int bsx, int bsy, GDALDataType bdt,
                     GSpacing nPixelSpace, GSpacing nLineSpace,
                     GDALRasterIOExtraArg *psExtraArg) override;
    int HasArbitraryOverviews() override;
    int GetOverviewCount() override;
    GDALRasterBand *GetOverview(int n) override;

    char **GetMetadataDomainList() override;
    virtual const char *GetMetadataItem(const char *pszName,
                                        const char *pszDomain = "") override;

  protected:
    CPLErr ReadBlocks(int x, int y, void *buffer, int bx0, int by0, int bx1,
                      int by1, int advise_read);
    bool IsBlockInCache(int x, int y);
    CPLErr AskMiniDriverForBlock(WMSHTTPRequest &request, int x, int y);
    CPLErr ReadBlockFromCache(const char *pszKey, int x, int y,
                              int to_buffer_band, void *buffer,
                              int advise_read);
    CPLErr ReadBlockFromFile(const CPLString &soFileName, int x, int y,
                             int to_buffer_band, void *buffer, int advise_read);
    CPLErr ReadBlockFromDataset(GDALDataset *ds, int x, int y,
                                int to_buffer_band, void *buffer,
                                int advise_read);
    CPLErr EmptyBlock(int x, int y, int to_buffer_band, void *buffer);
    static CPLErr ReportWMSException(const char *file_name);

  protected:
    GDALWMSDataset *m_parent_dataset{};
    double m_scale{};
    std::vector<GDALWMSRasterBand *> m_overviews{};
    int m_overview{};
    GDALColorInterp m_color_interp{};
    int m_nAdviseReadBX0{};
    int m_nAdviseReadBY0{};
    int m_nAdviseReadBX1{};
    int m_nAdviseReadBY1{};
};

#endif /* notdef WMSDRIVER_H_INCLUDED */
