import urllib.request
import json
import os
import datetime
from imageio import imread
import cv2
import numpy as np
import loca_data
import duamel_model
import matplotlib.pyplot as plt
import sher_duam_class
import dateutil.parser

class DMRLPrecFile():

    def __init__(self,
            _geo_lan = 44.417242,
            _geo_lon = 38.72287,
            _size = 256,
            _lan_scale = 79497.3714882,
            _lon_scale = 111162.6,
            _pixel_size = 152.8740566,
            _polygon = [],
            _corr_geo_lan = 44.417242,
            _corr_geo_lon = 38.72287,
            _radar_a = 200,
            _radar_n = 1.6,
            _FILE_MODE=False,
            _UID = "1a69563a-4d37-45df-98c4-4e72370efb1e"):

        self.FILE_MODE = _FILE_MODE     # РЕЖИМ ЧТЕНИЯ ДАННЫХ ИЗ ФАЙЛОВ
        self.UID = _UID                 # Уникальный идентификатор измерителя
        self.geo_lan = _geo_lan         # ГеоКоординаты центра (широта), число  - CALC FROM POLYGON
        self.geo_lon = _geo_lon         # ГеоКоординаты (долгота), число        - CALC FROM POLYGON
        self.size = _size               # Размеры квадратной картинки, пикселей по широте и высоте - CONST=256
        self.lan_scale = _lan_scale     # Длина дуги по широте (метров на градус)   - CALC
        self.lon_scale = _lon_scale     # Длина дуги по долготе (метров на градус)  - CALC
        self.pixel_size = _pixel_size   # Размер пикселя, метров на пиксель     - CALC FROM SCALE
        self.polygon = _polygon         # Водосборный полигон, ([[id, name, lan, lon], [id, name, lan, lon], [id, name, lan, lon]...]) - INPUT
        self.radar_a = _radar_a         # Параметр А для расчёта осадков по ДБЗ - INPUT
        self.radar_n = _radar_n         # Параметр Н для расчета осадков по ДБЗ - INPUT
        self.corr_geo_lan = _corr_geo_lan # Координаты АГК для корректировки (широта)
        self.corr_geo_lon = _corr_geo_lon # Координаты АГК для корректировки (долгота)

        self.xy_poligon = []                    # Полигон в виде массива линейных координат (х, у) - CALC
        self.grad_by_px_lon = 0                 # Количество градусов в одном пикселе по долготе - CALC
        self.grad_by_px_lan = 0                 # Количество градусов в одном пикселе по широте - CALC
        self.min_lon = 0                        # Минимальная долгота картинки - CALC
        self.min_lan = 0                        # Минимальная широта картинки - CALC
        self.max_lon = 0                        # Максимальная долгота картинки - CALC
        self.max_lan = 0                        # Максимальная широта картинки - CALC
        self.corr_x = -1                        # Координаты корректировочного осадкомера (x)
        self.corr_y = -1                        # Координаты корректировочного осадкомера (y)
        self.squere = 0.0                       # Общая площадь водосбора

        self.grad_by_px_lon = self.pixel_size / self.lon_scale  # Количество градусов в одном пикселе по долготе
        self.grad_by_px_lan = self.pixel_size / self.lan_scale  # Количество градусов в одном пикселе по широте
        self.min_lon = self.geo_lon - ((self.size / 2) * self.grad_by_px_lon) # Минимальная долгота картинки
        self.min_lan = self.geo_lan - ((self.size / 2) * self.grad_by_px_lan) # Минимальная широта картинки
        self.max_lon = self.geo_lon + ((self.size / 2) * self.grad_by_px_lon) # Максимальная долгота картинки
        self.max_lan = self.geo_lan + ((self.size / 2) * self.grad_by_px_lan) # Максимальная широта картинки


        # Параметры для корректировки
        self.k_point_correction = 1                                         # Коэффициент корректировки точечный (интенсивность на осадкомере к интенсивносьти по радару в точке)
        self.k_reserv_volume_store = dict(max_prec = -500.0, values = {})   # Резервное хранилище истории для поиска объёмов при отсутствии данных от ДМРЛ

        # Определяем координаты Х,У для окорректировочного осадкомера
        corr_point = self.GetXYPoint(self.corr_geo_lon, self.corr_geo_lan)
        self.corr_x = corr_point["x"]
        self.corr_y = corr_point["y"]

        # Проверка параметров
        self.CheckData()

        # Генерируем полигон вида (х, у)
        for point in self.polygon:
            xy_point = self.GetXYPoint(point[3], point[2])
            if xy_point["x"] != -1 and xy_point["y"] != -1:
                self.xy_poligon.append((xy_point["x"], xy_point["y"] ))

        # Считаем площадь водосбора
        img = np.zeros((self.size,self.size,4), np.uint8)

        for yy in img:
                for xx in yy:
                    xx[0] = 100
                    xx[1] = 100
                    xx[2] = 100
                    xx[3] = 100

        img_mask = np.zeros(img.shape, dtype=np.uint8)
        img_roi_corners = np.array([self.xy_poligon], dtype=np.int32)
        img_ignore_mask_color = (255,)*4
        cv2.fillPoly(img_mask, img_roi_corners, img_ignore_mask_color)
        img_masked_image = cv2.bitwise_and(img, img_mask)

        ###########################################
        # TODO Delete!!!!
        #cv2.imwrite(os.path.abspath(os.curdir) + r'\result\all_squere.png', img_masked_image)
        ###########################################

        pcx_square_count = 0
        counter = 0

        for yy in img_masked_image:
                for xx in yy:
                    counter = counter + 1
                    if xx[0] == 100:
                        pcx_square_count = pcx_square_count + 1

        self.squere = self.pixel_size * self.pixel_size * pcx_square_count

    # Проверка параметров
    def CheckData(self):
        if len(self.polygon) == 0:
            raise BaseException("Полигон не указан")

        if self.corr_geo_lan < 0 or self.corr_geo_lon < 0:
            raise BaseException("Не удалось найти осадкомер с данными для корректировки")

        if self.corr_geo_lon < self.min_lon or self.corr_geo_lon > self.max_lon or self.corr_geo_lan < self.min_lan or self.corr_geo_lan > self.max_lan:
            raise BaseException("Координаты осадкомера для корректировки выходят за рамки исследуемой области:lon={}({}-{}), lan={}({}-{})".format(
                self.corr_geo_lon, self.min_lon, self.max_lon, self.corr_geo_lan, self.min_lan, self.max_lan))

        for point in self.polygon:
            if point[3] < self.min_lon or point[3] > self.max_lon or point[2] < self.min_lan or point[2] > self.max_lan:
                raise BaseException("Координаты одной из точки полигона {} выходят за рамки исследуемой области:lon={}({}-{}), lan={}({}-{})".format(
                    point[1], point[3], self.min_lon, self.max_lon, point[2], self.min_lan, self.max_lan))

        return

    # Получить осадки по значению dbZ
    def GetPrecByDBZ(self, _dbz):
        result = 0

        if _dbz == 0 or _dbz > 127:
            return result

        step1 = (_dbz - 32) / 10
        step2 = 10 ** step1
        step3 = step2 / self.radar_a
        step4 = step3 ** (1.0/self.radar_n)
        result = step4
        return result

    # Получить точку (х, у) точке полигона в географических координатах
    def GetXYPoint(self, _geo_lon, _geo_lan):

        if _geo_lan < self.min_lan or _geo_lan > self.max_lan:
            return dict(x = 0, y = -1)

        if _geo_lon < self.min_lon or _geo_lon > self.max_lon:
            return dict(x = -1, y = 0)

        lon_delta = _geo_lon - self.min_lon
        lan_delta = _geo_lan - self.max_lan

        y_delta = lan_delta * self.lan_scale
        x_delta = lon_delta * self.lon_scale

        my = y_delta // self.pixel_size
        mx = x_delta // self.pixel_size

        result = dict(x = abs(mx), y = abs(my))
        return result

    # Получить матрицу (из файла или онлайн)
    def GetMatrix(self, _datetime):
        result = None

        #############################################################
        # Для файлового режима
        if self.FILE_MODE == True:
            # 1. Выделяем величину времени из даты
            timestamp = int(_datetime.timestamp())
            file_path = r"\png\dj_286m_{}.png".format(timestamp)

            # 2. Ищем файл и формируем матрицу
            if not os.path.exists(os.path.abspath(os.curdir) + file_path):
                return result

            result = imread(os.path.abspath(os.curdir) + file_path)
        #############################################################
        #############################################################

        #############################################################
        # Для web-режима
        else:

            # Определяем текущий тайм-слот
            _datetime = datetime.datetime.now()
            cur_min = (_datetime.minute // 10) * 10
            current_ts = datetime.datetime(_datetime.year, _datetime.month, _datetime.day, _datetime.hour, cur_min, 0, 0)
            current_ts_ts = current_ts.timestamp()
            last_ts = int(current_ts.timestamp()) + 600

            while datetime.datetime.now().timestamp() < last_ts:

                time_result = None
                time_url = 'https://tilecache.rainviewer.com/api/maps.json'
                time_result = json.load(urllib.request.urlopen(time_url))

                if time_result is None or len(time_result) < 1 or current_ts_ts not in time_result:
                    print("{}  No data...".format(datetime.datetime.now()))
                    time.sleep(30)
                    continue

                img = None

                try:
                    png_data_url = 'https://tilecache.rainviewer.com/v2/radar/{time}/256/10/{lan}/{lon}/0/0_0.png'.format(
                        time=current_ts_ts,
                        lan=self.geo_lan,
                        lon=self.geo_lon)

                    img = imread(png_data_url)
                except:
                    continue

                if img is not None:
                    result = img

        if result is not None:
            try:
                mask = np.zeros(result.shape, dtype=np.uint8)
                roi_corners = np.array([self.xy_poligon], dtype=np.int32)
                l_shape = len(result.shape)
                channel_count = result.shape[l_shape - 1]                             # i.e. 3 or 4 depending on your image
                ignore_mask_color = (255,)*channel_count
                cv2.fillPoly(mask, roi_corners, ignore_mask_color)
                masked_image = cv2.bitwise_and(result, mask)
                result = masked_image
            except(BaseException):
                print("ERROR in file {}".format(os.path.abspath(os.curdir) + file_path))
                print(str(BaseException))
                return None

        return result

    # Получить данные по осадкам при отсутствии данных от ДМРЛ
    def GetReservDataByPrec(self, _prec_value):
        result = 0.0

        if _prec_value == 0.32:
            print("kosyak....")

        x1 = -1.0
        x2 = -1.0
        y1 = -1.0
        y2 = -1.0
        u_sort_keys = sorted(self.k_reserv_volume_store["values"].keys(), reverse=True)
        sort_keys = sorted(self.k_reserv_volume_store["values"].keys(), reverse=False)

        if _prec_value > self.k_reserv_volume_store["max_prec"]:
            x1 = u_sort_keys[1]
            x2 = u_sort_keys[0]
        else:
            if _prec_value in sort_keys:
                result = self.k_reserv_volume_store["values"][_prec_value]["volume"]
                return result
            else:
                counter = -1
                for key in sort_keys:
                    if key > _prec_value:
                        x1 = sort_keys[counter]
                        x2 = key
                        break
                    counter = counter + 1

        y1 = self.k_reserv_volume_store["values"][x1]["volume"]
        y2 = self.k_reserv_volume_store["values"][x2]["volume"]

        result = ((x2 * y1 - x1 * y2) / (x2 - x1)) - (y1 - y2) * _prec_value
        result = (((y2-y1)/(x2-x1)) * (_prec_value - x1)) + y1

        if result < 0.0:
            result = 0.0

        return result

    # Добавить в историю резервных коэффициентов новое значение
    def SetNewReservKoefficient(self, _prec, _volume):

        if _prec == 0 and _volume == 0:
            return

        if _prec > self.k_reserv_volume_store["max_prec"]:
            self.k_reserv_volume_store["max_prec"] = _prec

        # 1. Если такого показателя осадков нет
        if _prec not in self.k_reserv_volume_store["values"].keys():
            self.k_reserv_volume_store["values"][_prec] = dict(volume = _volume, counter = 1)
            return

        if _prec in self.k_reserv_volume_store["values"].keys():
            ex_volume = self.k_reserv_volume_store["values"][_prec]["volume"]
            ex_counter =  self.k_reserv_volume_store["values"][_prec]["counter"]
            new_volume = ((ex_volume * ex_counter) + _volume) / (ex_counter + 1)
            self.k_reserv_volume_store["values"][_prec]["volume"] = new_volume
            self.k_reserv_volume_store["values"][_prec]["counter"] = ex_counter + 1
            return

        return

    # Конвертор для даты и времени в ДжСОН
    def MyDateJsonConverter(self, o):
        if isinstance(o, datetime.datetime):
            return o.__str__()

    # Получить результаты расчёта
    def GetResult(self, _prec, _test_datetime=None):
        """
        _prec это JSON вида:
            {"time": "2020-03-20T10:00:00Z",
            "period": 600,
            "sum": 0.0,
            "intensity": 0.0,
            "type": 0}
        """

        result = None
        if _prec["sum"] == " ":
            _prec = None

        #self.k_point_correction = 1                                 # Коэффициент корректировки точечный (интенсивность на осадкомере к интенсивносьти по радару в точке)
        #self.k_reserv_volume_prec = 1                               # Резервный коэффициент (объем воды / текущие осадки на осадкомере)
        temp_datetime = datetime.datetime.now()
        temp_cur_min = (temp_datetime.minute // 10) * 10
        cur_datetime = datetime.datetime(temp_datetime.year, temp_datetime.month, temp_datetime.day, temp_datetime.hour, temp_cur_min, 0, 0)

        if _prec is not None:
            cur_datetime = dateutil.parser.parse(_prec["time"])

        if _test_datetime is not None:
            cur_datetime = _test_datetime

        matrix = self.GetMatrix(cur_datetime)

        #####################################
        # TODO Delete!!!!
        #temp_val = int(cur_datetime.timestamp())
        #temp_f_p = os.path.abspath(os.curdir) + '\\result\\{}.png'.format(int(cur_datetime.timestamp()))
        #cv2.imwrite(temp_f_p, matrix)
        #####################################

        # 1. Если ДМРЛ нет и нет осадков
        if matrix is None and (_prec is None or _prec["sum"] == " "):
            result = dict(time = cur_datetime.__str__(),
                water_volume = -1.0,
                prec_square = -1.0,
                all_square = -1.0,
                dmrl_prec = -1.0)
            return json.dumps(result)

        # 2. Если ДМРЛ нет, но есть осадки
        if matrix is None and _prec is not None:
            temp_volume = self.GetReservDataByPrec(float(_prec["sum"]))
            result = dict(time = cur_datetime.__str__(),
                water_volume = temp_volume,
                prec_square = self.squere,
                all_square = -1.0,
                dmrl_prec = -1.0)
            return json.dumps(result)

        # 3-4. Если есть ДМРЛ и есть (или нет) осадков с АГК - ОБЫЧНЫЙ АЛГОРИТМ
        # Определяем коэффициент корреляции, если оба значения есть и отличны от нуля
        cur_prec_value = 0
        dmrl_prec = -1.0
        if _prec is not None:
            cur_prec_value = float(_prec["sum"])

            test = matrix[0]
            test = test[0]
            test = test[0]

            value = matrix[int(self.corr_y)][int(self.corr_x)][0]
            dmrl_prec = self.GetPrecByDBZ(value)
            dmrl_prec = dmrl_prec / 6

            if dmrl_prec > 0 and cur_prec_value > 0:
                self.k_point_correction = cur_prec_value / dmrl_prec

        sum_squere = 0.0
        vol_water = 0.0
        pixel_counter = 0.0
        for yy in matrix:
            for xx in yy:
                lm_value = xx[0]
                m_prec = self.GetPrecByDBZ(lm_value) / 6.0

                vol_local = self.pixel_size * self.pixel_size * (1.0/1000.0) * m_prec * self.k_point_correction
                vol_water = vol_water + vol_local

                if vol_local > 0.0:
                    sum_squere = sum_squere + 1.0
                    pixel_counter += 1.0

        sum_squere = sum_squere * self.pixel_size * self.pixel_size

        result = dict(time = cur_datetime.__str__(),
            water_volume = vol_water,
            prec_square = sum_squere,
            all_square = self.squere,
            dmrl_prec = dmrl_prec)

        self.SetNewReservKoefficient(cur_prec_value, vol_water)

        return json.dumps(result)
########################################################################