import sys
import copy
import os
import time
import datetime
import json
import jsonpickle
import importlib
import urllib.request
from imageio import imread
import redis
import requests
import dateutil.parser
import loca_data
import duamel_model
import sher_duam_class_2

import dmrl_prec_file
import dmrl_prec_file_prec_3_sigma
import dmrl_prec_file_without_correction


def GetAllDictKeysAndValues(_dict_with_pref):
    key_store = []
    value_store = []
    for dwp_k in _dict_with_pref.keys():
        dwp = _dict_with_pref[dwp_k]
        if dwp is None:
            continue
        if dwp is not None:
            for k in dwp.keys():
                key_store.append(str(dwp_k) + "_" + str(k))
                value_store.append(str(dwp[k]))

    return key_store, value_store

class Forecast():

    def __init__(self, _dmrl, _flow_rate, _duamel, _level_calc, _multy_k=1):
        self._multy_k = _multy_k
        self.dmrl = _dmrl
        self.flow_rate = _flow_rate
        self.duamel = _duamel
        self.level_calc = _level_calc

    def GetResult(self, _prec_json, _datetime, _counter):
        result = self.dmrl.GetResult(_prec_json, _datetime)
        volume_ex = False

        volume = " "
        sq_prec = " "
        all_sq = " "
        priv_prec = " "
        dmrl_prec = " "
        flow = " "
        duam = " "
        level = " "

        if result is not None:
            result = json.loads(result)
            if float(result["water_volume"]) >= 0.0:
                volume_ex = True
                volume = float(result["water_volume"])
                sq_prec = float(result["prec_square"])
                all_sq = float(result["all_square"])
                dmrl_prec = float(result["dmrl_prec"])
                if all_sq > 0.0:
                    priv_prec = (self._multy_k * volume * 1000) / all_sq
                else:
                    priv_prec = 0.0

            if priv_prec == " ":
                priv_prec = 0.0

            flow = self.flow_rate.calc_surface_flow(priv_prec)
            duam = self.duamel.model_step(_counter, flow)
            level = self.level_calc.bs_water_level(duam)
        else:
            volume_ex = False

        outer_data = dict(
            volume_exist = volume_ex,
            sq_prec = sq_prec,
            all_sq = all_sq,
            priv_prec = priv_prec,
            dmrl_prec = dmrl_prec,
            flow = flow,
            duam = duam,
            level = level
        )

        return outer_data

class ForecastByPolygons():

    def __init__(self, _dmrl, _flow_rate, _duamel, _level_calc, _multy_k=1):
        self._multy_k = _multy_k
        self.dmrl = _dmrl
        self.flow_rate = _flow_rate
        self.duamel = _duamel
        self.level_calc = _level_calc

    def GetResult(self, _prec_json, _datetime, _counter):

        flow_rate_store = []

        for dmrl_pol in self.dmrl:
            flow_rate_store.append(copy.deepcopy(self.flow_rate))


        result = self.dmrl.GetResult(_prec_json, _datetime)

        volume_ex = False

        volume = " "
        sq_prec = " "
        all_sq = " "
        priv_prec = " "
        dmrl_prec = " "
        flow = " "
        duam = " "
        level = " "

        if result is not None:
            result = json.loads(result)
            if float(result["water_volume"]) >= 0.0:
                volume_ex = True
                volume = float(result["water_volume"])
                sq_prec = float(result["prec_square"])
                all_sq = float(result["all_square"])
                dmrl_prec = float(result["dmrl_prec"])
                if all_sq > 0.0:
                    priv_prec = (self._multy_k * volume * 1000) / all_sq
                else:
                    priv_prec = 0.0

            if priv_prec == " ":
                priv_prec = 0.0

            flow = self.flow_rate.calc_surface_flow(priv_prec)
            duam = self.duamel.model_step(_counter, flow)
            level = self.level_calc.bs_water_level(duam)
        else:
            volume_ex = False

        outer_data = dict(
            volume_exist = volume_ex,
            sq_prec = sq_prec,
            all_sq = all_sq,
            priv_prec = priv_prec,
            dmrl_prec = dmrl_prec,
            flow = flow,
            duam = duam,
            level = level
        )

        return outer_data

forecast_corr = Forecast(
    dmrl_prec_file.DMRLPrecFile(_FILE_MODE=True, _polygon=loca_data.GetGeoCoordPolygon(), _radar_a=200, _radar_n=1.6),
    duamel_model.CatchmentArea(),
    duamel_model.DumlRiverModel(_k_n = 1.0, _k_korr = 25.0, _res_add_val = 20.0, _dmi_up_per = 1.0, _dmi_down_per = 20.0),
    duamel_model.RiverCrossSection(),
    _multy_k = 1.0)

'''
forecast_sher = Forecast(
    dmrl_prec_file.DMRLPrecFile(_FILE_MODE=True, _polygon=loca_data.GetGeoCoordPolygon(), _radar_a=200, _radar_n=1.6),
    duamel_model.CatchmentArea(_capacity=222.0, _in_filter=1.0, _out_filter=0.009),
    sher_duam_class_2.TestSherDuamel(_k_up=1.0, _k_down=20.0, _k_multy=50.0, _k_addit=20.0),
    duamel_model.RiverCrossSection(),
    _multy_k = 1.0)
'''

datetime_min = datetime.datetime(2020, 1, 29, 22, 50, 0)
datetime_max = datetime.datetime(2020, 2, 4, 15, 40, 0)
#datetime_max = datetime.datetime(2020, 2, 29, 17, 0, 0)
dt_delta = datetime.timedelta(minutes=10)
tz_diff  = datetime.timedelta(hours=3)
web_start = datetime_min - tz_diff
web_end = datetime_max - tz_diff

# ОСАДКИ
url_ocm = 'http://10.110.0.37:8888/monitoring/rest/precipitation-measurements/33ce9a80-27df-41dd-8dbe-cf3ec918b4c2?time-from={}&time-to={}'.format(web_start, web_end)
ocm_data = requests.get(url_ocm)
data = ocm_data.json()
dic_prec_data = {}

#РЕАЛЬНЫЙ УРОВЕНЬ ВОДЫ
rl_url_ocm = 'http://10.110.0.37:8888/monitoring/rest/water-level-measurements/983353a2-1e37-4295-a06b-a2065bc7cb8b?time-from={}&time-to={}'.format(web_start, web_end)
rl_ocm_data = requests.get(rl_url_ocm)
rl_data = rl_ocm_data.json()
rl_dic_prec_data = {}

cur_date = datetime_min

while cur_date <= datetime_max:
    dic_prec_data[cur_date] = {'intensity': " ", 'period': "-1", 'sum': " ", 'time': cur_date.__str__(), 'type': " "}
    rl_dic_prec_data[cur_date] = {'raw_ndistance': "-1", 'time': cur_date.__str__(), 'water_level_bs': " ", 'water_level_zero': " "}
    cur_date = cur_date + dt_delta

for pi in data:
    dt = dateutil.parser.parse(pi["time"], ignoretz=False)
    dt = dt + tz_diff
    ndt = datetime.datetime(dt.year, dt.month, dt.day, dt.hour, dt.minute, 0)
    dic_prec_data[ndt] = pi
    pi["time"] = datetime.datetime(dt.year, dt.month, dt.day, dt.hour, dt.minute, 0).__str__()

for rl in rl_data:
    dt = dateutil.parser.parse(rl["time"], ignoretz=False)
    dt = dt + tz_diff
    ndt = datetime.datetime(dt.year, dt.month, dt.day, dt.hour, dt.minute, 0)
    rl_dic_prec_data[ndt] = rl
    rl["time"] = datetime.datetime(dt.year, dt.month, dt.day, dt.hour, dt.minute, 0).__str__()

data = ""
counter = 0
keys = ""
json_all = ""

for k in dic_prec_data.keys():

    real_prec = dic_prec_data[k]
    real_level = rl_dic_prec_data[k]
    c_real_prec = real_prec
    c_real_level = real_level

    if real_prec["period"] < 0:
        c_real_prec = None

    if real_level["raw_ndistance"] < 0:
        c_real_level = None

    result = None
    counter += 1

    result = forecast_corr.GetResult(c_real_prec, k, counter)

    ks, vs = GetAllDictKeysAndValues(dict(
        data = dict(time=k),
        real_prec = real_prec,
        real_level = real_level,
        forecast = result))

    data += "\t".join(vs) + "\n"
    keys = "\t".join(ks)

    print(k)

data = keys + "\n" +  data
data = data.replace(".", ",")
f = open('result.txt', 'w')
f.write(data)
f.close()

fj = open('result_json.txt', 'w')
fj.write(json_all)
fj.close()