"""!
@brief Preparation of parameters for drivers, which download it, and managing
    downloaded data.

List of classes:
 - wms_base::WMSBase
 - wms_base::GRASSImporter
 - wms_base::WMSDriversInfo

(C) 2012-2019 by the GRASS Development Team

This program is free software under the GNU General Public License
(>=v2). Read the file COPYING that comes with GRASS for details.

@author Stepan Turek <stepan.turek seznam.cz> (Mentor: Martin Landa)
"""

import base64
import os
from http.client import HTTPException
from math import ceil
from urllib.request import Request, urlopen
from urllib.error import HTTPError


import grass.script as grass
from grass.exceptions import CalledModuleError


class WMSBase:
    def __init__(self):
        # these variables are information for destructor
        self.temp_files_to_cleanup = []

        self.params = {}
        self.tile_size = {"bbox": None}

        self.temp_map = None
        self.temp_warpmap = None

    def __del__(self):
        # tries to remove temporary files, all files should be
        # removed before, implemented just in case of unexpected
        # stop of module
        for temp_file in self.temp_files_to_cleanup:
            grass.try_remove(temp_file)

    def _debug(self, fn, msg):
        grass.debug("%s.%s: %s" % (self.__class__.__name__, fn, msg))

    def _initializeParameters(self, options, flags):
        self._debug("_initialize_parameters", "started")

        # initialization of module parameters (options, flags)
        self.params["driver"] = options["driver"]
        drv_info = WMSDriversInfo()

        driver_props = drv_info.GetDrvProperties(options["driver"])
        self._checkIgnoeredParams(options, flags, driver_props)

        self.params["capfile"] = options["capfile"].strip()

        for key in ["url", "layers", "styles", "method"]:
            self.params[key] = options[key].strip()

        self.flags = flags

        if self.flags["o"]:
            self.params["transparent"] = "FALSE"
        else:
            self.params["transparent"] = "TRUE"

        for key in ["password", "username", "urlparams"]:
            self.params[key] = options[key]

        if (self.params["password"] and self.params["username"] == "") or (
            self.params["password"] == "" and self.params["username"]
        ):
            grass.fatal(
                _(
                    "Please insert both %s and %s parameters or none of them."
                    % ("password", "username")
                )
            )

        self.params["bgcolor"] = options["bgcolor"].strip()

        if (
            options["format"] == "jpeg"
            and "format" not in driver_props["ignored_params"]
        ):
            if not flags["o"] and "WMS" in self.params["driver"]:
                grass.warning(_("JPEG format does not support transparency"))

        self.params["format"] = drv_info.GetFormat(options["format"])
        if not self.params["format"]:
            self.params["format"] = self.params["format"]

        # TODO: get srs from Tile Service file in OnEarth_GRASS driver
        self.params["srs"] = int(options["srs"])
        if self.params["srs"] <= 0 and "srs" not in driver_props["ignored_params"]:
            grass.fatal(_("Invalid EPSG code %d") % self.params["srs"])

        self.params["wms_version"] = options["wms_version"]
        if (
            "CRS" in GetSRSParamVal(self.params["srs"])
            and self.params["wms_version"] == "1.1.1"
        ):
            self.params["wms_version"] = "1.3.0"
            grass.warning(
                _(
                    "WMS version <1.3.0> will be used, because version <1.1.1> does "
                    "not support <%s>projection"
                )
                % GetSRSParamVal(self.params["srs"])
            )

        if self.params["wms_version"] == "1.3.0":
            self.params["proj_name"] = "CRS"
        else:
            self.params["proj_name"] = "SRS"

        # read projection info
        self.proj_location = grass.read_command("g.proj", flags="jf").rstrip("\n")
        self.proj_location = self._modifyProj(self.proj_location)

        self.source_epsg = str(GetEpsg(self.params["srs"]))
        self.target_epsg = None
        target_crs = grass.parse_command("g.proj", flags="g", delimiter="=")
        if "epsg" in target_crs.keys():
            self.target_epsg = target_crs["epsg"]
            if self.source_epsg != self.target_epsg:
                grass.warning(
                    _(
                        "SRS differences: WMS source EPSG %s != location EPSG %s (use "
                        "srs=%s to adjust)"
                    )
                    % (self.source_epsg, self.target_epsg, self.target_epsg)
                )

        self.proj_srs = grass.read_command(
            "g.proj", flags="jf", epsg=str(GetEpsg(self.params["srs"]))
        )
        self.proj_srs = self.proj_srs.rstrip("\n")

        self.proj_srs = self._modifyProj(self.proj_srs)

        if not self.proj_srs or not self.proj_location:
            grass.fatal(_("Unable to get projection info"))

        self.region = options["region"]

        min_tile_size = 100
        maxcols = int(options["maxcols"])
        if maxcols <= min_tile_size:
            grass.fatal(_("Maxcols must be greater than 100"))

        maxrows = int(options["maxrows"])
        if maxrows <= min_tile_size:
            grass.fatal(_("Maxrows must be greater than 100"))

        # setting optimal tile size according to maxcols and maxrows constraint
        # and region cols and rows
        self.tile_size["cols"] = int(
            self.region["cols"] / ceil(self.region["cols"] / float(maxcols))
        )
        self.tile_size["rows"] = int(
            self.region["rows"] / ceil(self.region["rows"] / float(maxrows))
        )

        # default format for GDAL library
        self.gdal_drv_format = "GTiff"

        self._debug("_initialize_parameters", "finished")

    def _modifyProj(self, proj):
        """!Modify proj.4 string for usage in this module"""

        # add +wktext parameter to avoid dropping of +nadgrids parameter (if presented)
        # in gdalwarp
        if "+nadgrids=" in proj and " +wktext" not in proj:
            proj += " +wktext"

        return proj

    def _checkIgnoeredParams(self, options, flags, driver_props):
        """!Write warnings for set parameters and flags, which chosen driver does not
        use."""

        not_relevant_params = []
        for i_param in driver_props["ignored_params"]:
            if (
                i_param in options
                and options[i_param]
                and i_param not in ["srs", "wms_version", "format"]
            ):  # params with default value
                not_relevant_params.append("<" + i_param + ">")

        if len(not_relevant_params) > 0:
            grass.warning(
                _(
                    "These parameter are ignored: %s\n\
                             %s driver does not support the parameters."
                    % (",".join(not_relevant_params), options["driver"])
                )
            )

        not_relevant_flags = []
        for i_flag in driver_props["ignored_flags"]:
            if flags[i_flag]:
                not_relevant_flags.append("<" + i_flag + ">")

        if len(not_relevant_flags) > 0:
            grass.warning(
                _(
                    "These flags are ignored: %s\n\
                             %s driver does not support the flags."
                    % (",".join(not_relevant_flags), options["driver"])
                )
            )

    def GetMap(self, options, flags):
        """!Download data from WMS server."""

        self._initializeParameters(options, flags)
        self.bbox = self._computeBbox()

        self.temp_map = self._download()

        if not self.temp_map:
            return

        self._reprojectMap()

        return self.temp_warpmap

    def _fetchCapabilities(self, options):
        """!Download capabilities from WMS server"""
        cap_url = options["url"].strip()

        if "?" in cap_url:
            cap_url += "&"
        else:
            cap_url += "?"

        if "WMTS" in options["driver"]:
            cap_url += "SERVICE=WMTS&REQUEST=GetCapabilities&VERSION=1.0.0"
        elif "OnEarth" in options["driver"]:
            cap_url += "REQUEST=GetTileService"
        else:
            cap_url += (
                "SERVICE=WMS&REQUEST=GetCapabilities&VERSION=" + options["wms_version"]
            )

        if options["urlparams"]:
            cap_url += "&" + options["urlparams"]

        grass.debug("Fetching capabilities file.\n%s" % cap_url)

        try:
            cap = self._fetchDataFromServer(
                cap_url, options["username"], options["password"]
            )
        except (OSError, HTTPException) as e:
            if isinstance(e, HTTPError) and e.code == 401:
                grass.fatal(
                    _("Authorization failed to <%s> when fetching capabilities")
                    % options["url"]
                )
            else:
                msg = _("Unable to fetch capabilities from <{0}>. Reason: ").format(
                    options["url"]
                )

                if hasattr(e, "reason"):
                    msg += "{0}".format(e.reason)
                else:
                    msg += "{0}".format(e)

                grass.fatal(msg)

        grass.debug("Fetching capabilities OK")
        return grass.decode(cap.read())

    def _fetchDataFromServer(self, url, username=None, password=None):
        """!Fetch data from server"""
        request = Request(url)
        if username and password:
            base64string = base64.encodestring("%s:%s" % (username, password)).replace(
                "\n", ""
            )
            request.add_header("Authorization", "Basic %s" % base64string)

        try:
            return urlopen(request)
        except ValueError as error:
            grass.fatal("%s" % error)

    def GetCapabilities(self, options):
        """!Get capabilities from WMS server"""
        cap = self._fetchCapabilities(options)
        capfile_output = options["capfile_output"].strip()

        # save to file
        if capfile_output:
            try:
                with open(capfile_output, "w") as temp:
                    temp.write(cap)
                return
            except OSError as error:
                grass.fatal(
                    _("Unable to open file '%s'.\n%s\n" % (capfile_output, error))
                )

        # print to output
        print(cap)

    def _computeBbox(self):
        """!Get region extent for WMS query (bbox)"""
        self._debug("_computeBbox", "started")

        bbox_region_items = {"maxy": "n", "miny": "s", "maxx": "e", "minx": "w"}
        bbox = {}

        if self.proj_srs == self.proj_location:  # TODO: do it better
            for bbox_item, region_item in bbox_region_items.items():
                bbox[bbox_item] = self.region[region_item]

        # if location projection and wms query projection are
        # different, corner points of region are transformed into wms
        # projection and then bbox is created from extreme coordinates
        # of the transformed points
        else:
            for bbox_item, region_item in bbox_region_items.items():
                bbox[bbox_item] = None

            temp_region = self._tempfile()

            try:
                temp_region_opened = open(temp_region, "w")
                temp_region_opened.write(
                    "%f %f\n%f %f\n%f %f\n%f %f\n"
                    % (
                        self.region["e"],
                        self.region["n"],
                        self.region["w"],
                        self.region["n"],
                        self.region["w"],
                        self.region["s"],
                        self.region["e"],
                        self.region["s"],
                    )
                )
            except OSError:
                grass.fatal(_("Unable to write data into tempfile"))
            finally:
                temp_region_opened.close()
            try:
                points = grass.read_command(
                    "m.proj",
                    flags="d",
                    proj_out=self.proj_srs,
                    proj_in=self.proj_location,
                    input=temp_region,
                    quiet=True,
                )  # TODO: stdin
            except CalledModuleError:
                points = None
            finally:
                grass.try_remove(temp_region)

            if not points:
                grass.fatal(_("Unable to determine region, %s failed") % "m.proj")

            points = points.splitlines()
            if len(points) != 4:
                grass.fatal(_("Region definition: 4 points required"))

            for point in points:
                try:
                    point = list(map(float, point.split("|")))
                except ValueError:
                    grass.fatal(_("Reprojection of region using m.proj failed."))
                if not bbox["maxy"]:
                    bbox["maxy"] = point[1]
                    bbox["miny"] = point[1]
                    bbox["maxx"] = point[0]
                    bbox["minx"] = point[0]
                    continue

                if bbox["maxy"] < point[1]:
                    bbox["maxy"] = point[1]
                elif bbox["miny"] > point[1]:
                    bbox["miny"] = point[1]

                if bbox["maxx"] < point[0]:
                    bbox["maxx"] = point[0]
                elif bbox["minx"] > point[0]:
                    bbox["minx"] = point[0]

        self._debug("_computeBbox", "finished -> %s" % bbox)

        # Ordering of coordinates axis of geographic coordinate
        # systems in WMS 1.3.0 is flipped. If  self.tile_size['flip_coords'] is
        # True, coords in bbox need to be flipped in WMS query.

        return bbox

    def _reprojectMap(self):
        """!Reproject data  using gdalwarp if needed"""
        # reprojection of raster
        do_reproject = True
        if (
            self.source_epsg is not None
            and self.target_epsg is not None
            and self.source_epsg == self.target_epsg
        ):
            do_reproject = False
        # TODO: correctly compare source and target crs
        if do_reproject and self.proj_srs == self.proj_location:
            do_reproject = False
        if do_reproject:
            grass.message(_("Reprojecting raster..."))
            self.temp_warpmap = grass.tempfile() + ".tif"

            if int(os.getenv("GRASS_VERBOSE", "2")) <= 2:
                nuldev = open(os.devnull, "w+")
            else:
                nuldev = None

            if self.params["method"] == "nearest":
                gdal_method = "near"
            elif self.params["method"] == "linear":
                gdal_method = "bilinear"
            else:
                gdal_method = self.params["method"]

            # RGB rasters - alpha layer is added for cropping edges of projected raster
            try:
                if self.temp_map_bands_num == 3:
                    ps = grass.Popen(
                        [
                            "gdalwarp",
                            "-s_srs",
                            "%s" % self.proj_srs,
                            "-t_srs",
                            "%s" % self.proj_location,
                            "-r",
                            gdal_method,
                            "-dstalpha",
                            self.temp_map,
                            self.temp_warpmap,
                        ],
                        stdout=nuldev,
                    )
                # RGBA rasters
                else:
                    ps = grass.Popen(
                        [
                            "gdalwarp",
                            "-s_srs",
                            "%s" % self.proj_srs,
                            "-t_srs",
                            "%s" % self.proj_location,
                            "-r",
                            gdal_method,
                            self.temp_map,
                            self.temp_warpmap,
                        ],
                        stdout=nuldev,
                    )
                ps.wait()
            except OSError as e:
                grass.fatal(
                    "%s \nThis can be caused by missing %s utility. " % (e, "gdalwarp")
                )

            if nuldev:
                nuldev.close()

            if ps.returncode != 0:
                grass.fatal(_("%s failed") % "gdalwarp")
            grass.try_remove(self.temp_map)
        # raster projection is same as projection of location
        else:
            self.temp_warpmap = self.temp_map
            self.temp_files_to_cleanup.remove(self.temp_map)

        return self.temp_warpmap

    def _tempfile(self):
        """!Create temp_file and append list self.temp_files_to_cleanup
            with path of file

        @return string path to temp_file
        """
        temp_file = grass.tempfile()
        if temp_file is None:
            grass.fatal(_("Unable to create temporary files"))

        # list of created tempfiles for destructor
        self.temp_files_to_cleanup.append(temp_file)

        return temp_file


class GRASSImporter:
    def __init__(self, opt_output, cleanup_bands):
        self.cleanup_mask = False
        self.cleanup_bands = cleanup_bands

        # output map name
        self.opt_output = opt_output

        # suffix for existing mask (during overriding will be saved
        # into raster named:self.opt_output + this suffix)
        self.original_mask_suffix = "_temp_MASK"

        # check names of temporary rasters, which module may create
        maps = []
        for suffix in (".red", ".green", ".blue", ".alpha", self.original_mask_suffix):
            rast = self.opt_output + suffix
            if grass.find_file(rast, element="cell", mapset=".")["file"]:
                maps.append(rast)

        if len(maps) != 0:
            grass.fatal(
                _(
                    "Please change output name, or change names of these rasters: %s, "
                    "module needs to create this temporary maps during execution."
                )
                % ",".join(maps)
            )

    def __del__(self):
        # removes temporary mask, used for import transparent or warped temp_map
        if self.cleanup_mask:
            # clear temporary mask, which was set by module
            try:
                grass.run_command("r.mask", quiet=True, flags="r")
            except CalledModuleError:
                grass.fatal(_("%s failed") % "r.mask")

            # restore original mask, if exists
            if grass.find_file(
                self.opt_output + self.original_mask_suffix, element="cell", mapset="."
            )["name"]:
                try:
                    mask_copy = self.opt_output + self.original_mask_suffix
                    grass.run_command("g.copy", quiet=True, raster=mask_copy + ",MASK")
                except CalledModuleError:
                    grass.fatal(_("%s failed") % "g.copy")

        # remove temporary created rasters
        maps = []
        rast = self.opt_output + ".alpha"
        if grass.find_file(rast, element="cell", mapset=".")["file"]:
            maps.append(rast)

        if self.cleanup_bands:
            for suffix in (".red", ".green", ".blue", self.original_mask_suffix):
                rast = self.opt_output + suffix
                if grass.find_file(rast, element="cell", mapset=".")["file"]:
                    maps.append(rast)

        if maps:
            grass.run_command(
                "g.remove", quiet=True, flags="fb", type="raster", name=",".join(maps)
            )

        # delete environmental variable which overrides region
        if "GRASS_REGION" in os.environ.keys():
            os.environ.pop("GRASS_REGION")

        maplist = grass.read_command(
            "g.list",
            type="raster",
            pattern="%s*" % (self.opt_output),
            mapset=".",
            separator=",",
        ).rstrip("\n")

        if len(maplist) == 0:
            grass.fatal(_("WMS import failed, nothing imported"))
        else:
            for raster in maplist.split(","):
                grass.raster_history(raster, overwrite=True)
                grass.run_command(
                    "r.support", map=raster, description="generated by r.in.wms"
                )
                grass.message(_("<%s> created.") % raster)

    def ImportMapIntoGRASS(self, raster):
        """!Import raster into GRASS."""
        # importing temp_map into GRASS
        try:
            # do not use -o flag !
            grass.run_command(
                "r.in.gdal",
                flags="o",
                quiet=True,
                overwrite=True,
                input=raster,
                output=self.opt_output,
            )
        except CalledModuleError:
            grass.fatal(_("%s failed") % "r.in.gdal")

        # information for destructor to cleanup temp_layers, created
        # with r.in.gdal

        # setting region for full extend of imported raster
        if grass.find_file(self.opt_output + ".red", element="cell", mapset=".")[
            "file"
        ]:
            region_map = self.opt_output + ".red"
        else:
            region_map = self.opt_output
        os.environ["GRASS_REGION"] = grass.region_env(rast=region_map)

        # mask created from alpha layer, which describes real extend
        # of warped layer (may not be a rectangle), also mask contains
        # transparent parts of raster
        if grass.find_file(self.opt_output + ".alpha", element="cell", mapset=".")[
            "name"
        ]:
            # saving current mask (if exists) into temp raster
            if grass.find_file("MASK", element="cell", mapset=".")["name"]:
                try:
                    mask_copy = self.opt_output + self.original_mask_suffix
                    grass.run_command("g.copy", quiet=True, raster="MASK," + mask_copy)
                except CalledModuleError:
                    grass.fatal(_("%s failed") % "g.copy")

            # info for destructor
            self.cleanup_mask = True
            try:
                grass.run_command(
                    "r.mask",
                    quiet=True,
                    overwrite=True,
                    maskcats="0",
                    flags="i",
                    raster=self.opt_output + ".alpha",
                )
            except CalledModuleError:
                grass.fatal(_("%s failed") % "r.mask")

            if not self.cleanup_bands:
                # use the MASK to set NULL values
                for suffix in (".red", ".green", ".blue"):
                    rast = self.opt_output + suffix
                    if grass.find_file(rast, element="cell", mapset=".")["file"]:
                        grass.run_command(
                            "g.rename",
                            rast="%s,%s" % (rast, rast + "_null"),
                            quiet=True,
                        )
                        grass.run_command(
                            "r.mapcalc",
                            expression="%s = %s" % (rast, rast + "_null"),
                            quiet=True,
                        )
                        grass.run_command(
                            "g.remove",
                            type="raster",
                            name="%s" % (rast + "_null"),
                            flags="f",
                            quiet=True,
                        )

        # TODO one band + alpha band?
        if (
            grass.find_file(self.opt_output + ".red", element="cell", mapset=".")[
                "file"
            ]
            and self.cleanup_bands
        ):
            try:
                grass.run_command(
                    "r.composite",
                    quiet=True,
                    overwrite=True,
                    red=self.opt_output + ".red",
                    green=self.opt_output + ".green",
                    blue=self.opt_output + ".blue",
                    output=self.opt_output,
                )
            except CalledModuleError:
                grass.fatal(_("%s failed") % "r.composite")


class WMSDriversInfo:
    def __init__(self):
        """!Provides information about driver parameters."""

        # format labels
        self.f_labels = ["geotiff", "tiff", "png", "jpeg", "gif", "png8"]

        # form for request
        self.formats = [
            "image/geotiff",
            "image/tiff",
            "image/png",
            "image/jpeg",
            "image/gif",
            "image/png8",
        ]

        self.srs = ("epsg", "ogc")

    def GetDrvProperties(self, driver):
        """!Get information about driver parameters."""
        if driver == "WMS_GDAL":
            return self._GDALDrvProperties()
        if "WMS" in driver:
            return self._WMSProperties()
        if "WMTS" in driver:
            return self._WMTSProperties()
        if "OnEarth" in driver:
            return self._OnEarthProperties()

    def _OnEarthProperties(self):
        props = {}
        props["ignored_flags"] = ["o"]
        props["ignored_params"] = [
            "bgcolor",
            "styles",
            "capfile_output",
            "format",
            "srs",
            "wms_version",
        ]
        props["req_multiple_layers"] = False

        return props

    def _WMSProperties(self):
        props = {}
        props["ignored_params"] = ["capfile"]
        props["ignored_flags"] = []
        props["req_multiple_layers"] = True

        return props

    def _WMTSProperties(self):
        props = {}
        props["ignored_flags"] = ["o"]
        props["ignored_params"] = ["urlparams", "bgcolor", "wms_version"]
        props["req_multiple_layers"] = False

        return props

    def _GDALDrvProperties(self):
        props = {}
        props["ignored_flags"] = []
        props["ignored_params"] = [
            "urlparams",
            "bgcolor",
            "capfile",
            "capfile_output",
            "username",
            "password",
        ]
        props["req_multiple_layers"] = True

        return props

    def GetFormatLabel(self, format):
        """!Convert format request form to value in parameter 'format'."""
        if format in self.formats:
            return self.f_labels[self.formats.index(format)]
        return None

    def GetFormat(self, label):
        """!Convert value in parameter 'format' to format request form."""
        if label in self.f_labels:
            return self.formats[self.f_labels.index(label)]
        return None

    def GetSrs(self):
        """!Get supported srs prefixes (e.g. epsg/crs)

        @todo filter according to version and driver params
        """
        return self.srs


# TODO move to utils?
def GetSRSParamVal(srs):
    """!Decides whether to use CRS or EPSG prefix according to srs number."""

    if srs in [84, 83, 27]:
        return "OGC:CRS{}".format(srs)
    else:
        return "EPSG:{}".format(srs)


def GetEpsg(srs):
    """
    @return EPSG number
            If srs is CRS number, return EPSG number which corresponds to CRS number.
    """
    if srs == 84:
        return 4326
    if srs == 83:
        return 4269
    if srs == 27:
        return 4267

    return srs