"""
Download geo-referenced raster tiles images.
Modified from https://github.com/gumblex/tms2geotiff/

BSD 2-Clause License

Copyright (c) 2019, Dingyuan Wang
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""

import concurrent.futures
import io
import itertools
import math
import re
import sqlite3
import time

from PIL import Image

from src import app_logger
from src.utilities.constants import EARTH_EQUATORIAL_RADIUS


Image.MAX_IMAGE_PIXELS = None

try:
    import httpx

    SESSION = httpx.Client()
except ImportError:
    import requests

    SESSION = requests.Session()

SESSION.headers.update({
    "Accept": "*/*",
    "Accept-Encoding": "gzip, deflate",
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; rv:91.0) Gecko/20100101 Firefox/91.0",
})

re_coords_split = re.compile('[ ,;]+')


def from4326_to3857(lat, lon):
    xtile = math.radians(lon) * EARTH_EQUATORIAL_RADIUS
    ytile = math.log(math.tan(math.radians(45 + lat / 2.0))) * EARTH_EQUATORIAL_RADIUS
    return xtile, ytile


def deg2num(lat, lon, zoom):
    n = 2 ** zoom
    xtile = ((lon + 180) / 360 * n)
    ytile = (1 - math.asinh(math.tan(math.radians(lat))) / math.pi) * n / 2
    return xtile, ytile


def is_empty(im):
    extrema = im.getextrema()
    if len(extrema) >= 3:
        if len(extrema) > 3 and extrema[-1] == (0, 0):
            return True
        for ext in extrema[:3]:
            if ext != (0, 0):
                return False
        return True
    else:
        return extrema[0] == (0, 0)


def mbtiles_init(dbname):
    db = sqlite3.connect(dbname, isolation_level=None)
    cur = db.cursor()
    cur.execute("BEGIN")
    cur.execute("CREATE TABLE IF NOT EXISTS metadata (name TEXT PRIMARY KEY, value TEXT)")
    cur.execute("CREATE TABLE IF NOT EXISTS tiles ("
                "zoom_level INTEGER NOT NULL, "
                "tile_column INTEGER NOT NULL, "
                "tile_row INTEGER NOT NULL, "
                "tile_data BLOB NOT NULL, "
                "UNIQUE (zoom_level, tile_column, tile_row)"
                ")")
    cur.execute("COMMIT")
    return db


def paste_tile(bigim, base_size, tile, corner_xy, bbox):
    if tile is None:
        return bigim
    im = Image.open(io.BytesIO(tile))
    mode = 'RGB' if im.mode == 'RGB' else 'RGBA'
    size = im.size
    if bigim is None:
        base_size[0] = size[0]
        base_size[1] = size[1]
        newim = Image.new(mode, (
            size[0] * (bbox[2] - bbox[0]), size[1] * (bbox[3] - bbox[1])))
    else:
        newim = bigim

    dx = abs(corner_xy[0] - bbox[0])
    dy = abs(corner_xy[1] - bbox[1])
    xy0 = (size[0] * dx, size[1] * dy)
    if mode == 'RGB':
        newim.paste(im, xy0)
    else:
        if im.mode != mode:
            im = im.convert(mode)
        if not is_empty(im):
            newim.paste(im, xy0)
    im.close()
    return newim


def get_tile(url):
    retry = 3
    while 1:
        try:
            r = SESSION.get(url, timeout=60)
            break
        except Exception as request_tile_exception:
            app_logger.error(f"retry {retry}, request_tile_exception:{request_tile_exception}.")
            retry -= 1
            if not retry:
                raise
    if r.status_code == 404:
        return None
    elif not r.content:
        return None
    r.raise_for_status()
    return r.content


def print_progress(progress, total, done=False):
    if done:
        app_logger.info('Downloaded image %d/%d, %.2f%%' % (progress, total, progress * 100 / total))


def mbtiles_save(db, img_data, xy, zoom, img_format):
    if not img_data:
        return
    im = Image.open(io.BytesIO(img_data))
    if im.format == 'PNG':
        current_format = 'png'
    elif im.format == 'JPEG':
        current_format = 'jpg'
    elif im.format == 'WEBP':
        current_format = 'webp'
    else:
        current_format = 'image/' + im.format.lower()
    x, y = xy
    y = 2 ** zoom - 1 - y
    cur = db.cursor()
    if img_format is None or img_format == current_format:
        cur.execute("REPLACE INTO tiles VALUES (?,?,?,?)", (
            zoom, x, y, img_data))
        return img_format or current_format
    buf = io.BytesIO()
    if img_format == 'png':
        im.save(buf, 'PNG')
    elif img_format == 'jpg':
        im.save(buf, 'JPEG', quality=93)
    elif img_format == 'webp':
        im.save(buf, 'WEBP')
    else:
        im.save(buf, img_format.split('/')[-1].upper())
    cur.execute("REPLACE INTO tiles VALUES (?,?,?,?)", (
        zoom, x, y, buf.getvalue()))
    return img_format


def download_extent(
        source, lat0, lon0, lat1, lon1, zoom,
        mbtiles=None, save_image=True,
        progress_callback=print_progress,
        callback_interval=0.05
):
    x0, y0 = deg2num(lat0, lon0, zoom)
    x1, y1 = deg2num(lat1, lon1, zoom)
    if x0 > x1:
        x0, x1 = x1, x0
    if y0 > y1:
        y0, y1 = y1, y0

    db = None
    mbt_img_format = None
    if mbtiles:
        db = mbtiles_init(mbtiles)
        cur = db.cursor()
        cur.execute("BEGIN")
        cur.execute("REPLACE INTO metadata VALUES ('name', ?)", (source,))
        cur.execute("REPLACE INTO metadata VALUES ('type', 'overlay')")
        cur.execute("REPLACE INTO metadata VALUES ('version', '1.1')")
        cur.execute("REPLACE INTO metadata VALUES ('description', ?)", (source,))
        cur.execute("SELECT value FROM metadata WHERE name='format'")
        row = cur.fetchone()
        if row and row[0]:
            mbt_img_format = row[0]
        else:
            cur.execute("REPLACE INTO metadata VALUES ('format', 'png')")

        lat_min = min(lat0, lat1)
        lat_max = max(lat0, lat1)
        lon_min = min(lon0, lon1)
        lon_max = max(lon0, lon1)
        bounds = [lon_min, lat_min, lon_max, lat_max]
        cur.execute("SELECT value FROM metadata WHERE name='bounds'")
        row = cur.fetchone()
        if row and row[0]:
            last_bounds = [float(x) for x in row[0].split(',')]
            bounds[0] = min(last_bounds[0], bounds[0])
            bounds[1] = min(last_bounds[1], bounds[1])
            bounds[2] = max(last_bounds[2], bounds[2])
            bounds[3] = max(last_bounds[3], bounds[3])
        cur.execute("REPLACE INTO metadata VALUES ('bounds', ?)", (
            ",".join(map(str, bounds)),))
        cur.execute("REPLACE INTO metadata VALUES ('center', ?)", ("%s,%s,%d" % (
            (lon_max + lon_min) / 2, (lat_max + lat_min) / 2, zoom),))
        cur.execute("""
            INSERT INTO metadata VALUES ('minzoom', ?)
            ON CONFLICT(name) DO UPDATE SET value=excluded.value
            WHERE CAST(excluded.value AS INTEGER)<CAST(metadata.value AS INTEGER)
        """, (str(zoom),))
        cur.execute("""
            INSERT INTO metadata VALUES ('maxzoom', ?)
            ON CONFLICT(name) DO UPDATE SET value=excluded.value
            WHERE CAST(excluded.value AS INTEGER)>CAST(metadata.value AS INTEGER)
        """, (str(zoom),))
        cur.execute("COMMIT")

    corners = tuple(itertools.product(
        range(math.floor(x0), math.ceil(x1)),
        range(math.floor(y0), math.ceil(y1))))
    totalnum = len(corners)
    futures = {}
    done_num = 0
    progress_callback(done_num, totalnum, False)
    last_done_num = 0
    last_callback = time.monotonic()
    cancelled = False
    with concurrent.futures.ThreadPoolExecutor(5) as executor:
        for x, y in corners:
            future = executor.submit(get_tile, source.format(z=zoom, x=x, y=y))
            futures[future] = (x, y)
        bbox = (math.floor(x0), math.floor(y0), math.ceil(x1), math.ceil(y1))
        bigim = None
        base_size = [256, 256]
        while futures:
            done, not_done = concurrent.futures.wait(
                futures.keys(), timeout=callback_interval,
                return_when=concurrent.futures.FIRST_COMPLETED
            )
            cur = None
            if mbtiles:
                cur = db.cursor()
                cur.execute("BEGIN")
            for fut in done:
                img_data = fut.result()
                xy = futures[fut]
                if save_image:
                    bigim = paste_tile(bigim, base_size, img_data, xy, bbox)
                if mbtiles:
                    new_format = mbtiles_save(db, img_data, xy, zoom, mbt_img_format)
                    if not mbt_img_format:
                        cur.execute(
                            "UPDATE metadata SET value=? WHERE name='format'",
                            (new_format,))
                        mbt_img_format = new_format
                del futures[fut]
                done_num += 1
            if mbtiles:
                cur.execute("COMMIT")
            if time.monotonic() > last_callback + callback_interval:
                try:
                    progress_callback(done_num, totalnum, (done_num > last_done_num))
                except TaskCancelled:
                    for fut in futures.keys():
                        fut.cancel()
                    futures.clear()
                    cancelled = True
                    break
                last_callback = time.monotonic()
                last_done_num = done_num
    if cancelled:
        raise TaskCancelled()
    progress_callback(done_num, totalnum, True)

    if not save_image:
        return None, None

    xfrac = x0 - bbox[0]
    yfrac = y0 - bbox[1]
    x2 = round(base_size[0] * xfrac)
    y2 = round(base_size[1] * yfrac)
    imgw = round(base_size[0] * (x1 - x0))
    imgh = round(base_size[1] * (y1 - y0))
    retim = bigim.crop((x2, y2, x2 + imgw, y2 + imgh))
    if retim.mode == 'RGBA' and retim.getextrema()[3] == (255, 255):
        retim = retim.convert('RGB')
    bigim.close()
    xp0, yp0 = from4326_to3857(lat0, lon0)
    xp1, yp1 = from4326_to3857(lat1, lon1)
    pwidth = abs(xp1 - xp0) / retim.size[0]
    pheight = abs(yp1 - yp0) / retim.size[1]
    matrix = (min(xp0, xp1), pwidth, 0, max(yp0, yp1), 0, -pheight)
    return retim, matrix


class TaskCancelled(RuntimeError):
    pass