import sys
import math
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 matplotlib.pyplot as plt

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

#forecast_corr = Forecast(dmrl_prec_file.DMRLPrecFile(_FILE_MODE=True, _polygon=loca_data.GetGeoCoordPolygon()),
#    duamel_model.CatchmentArea(), duamel_model.DumlRiverModel(), duamel_model.RiverCrossSection())
#forecast_noco = Forecast(dmrl_prec_file_without_correction.DMRLPrecFile_WOC(_FILE_MODE=True, _polygon=loca_data.GetGeoCoordPolygon()),
#    duamel_model.CatchmentArea(), duamel_model.DumlRiverModel(), duamel_model.RiverCrossSection())

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(),
    sher_duam_class_2.TestSherDuamel(_k_up=1.0, _k_down=20.0, _k_multy=25.0, _k_addit=20.0),
    duamel_model.RiverCrossSection(),
    _multy_k = 1.0)

test_k_up = 1.0
test_k_down = 20.0

ld = duamel_model.DumlRiverModel(_k_n = 1.0, _k_korr = 1.0, _res_add_val = 0.0, _dmi_up_per = test_k_up, _dmi_down_per = test_k_down)
se = sher_duam_class_2.TestSherDuamel(_k_up=test_k_up, _k_down=test_k_down, _k_multy=1.0, _k_addit=0.0)

class test_duam:
    def __init__(self, _k_n = 1.0, _k_korr = 1.0, _res_add_val = 0.0, _dmi_up_per = test_k_up, _dmi_down_per = test_k_down):
        self._k_n = _k_n
        self._k_korr = _k_korr
        self._res_add_val = _res_add_val
        self._dmi_up_per = _dmi_up_per
        self._dmi_down_per = _dmi_down_per

        self.old_value = 0.0
        self.cur_counter = 0

    def model_step(self, _counter, _value):
        delta = _value - self.old_value
        return 0

counter = 0
data = ""
step_range_plus = 5100
step_range_zero = 20
def_plus = 1.0

countet_data = []
ld_data = []
se_data = []
tv_data = []
value = 0.0

def get_test_e_val(counter, amp, k):
    result = amp * (1 - math.exp(-counter/k))
    return result

for i in range(step_range_zero):
    rld = ld.model_step(counter, 0.0)
    rse = se.model_step(counter, 0.0)


    countet_data.append(counter)
    ld_data.append(rld)
    se_data.append(rse)

    tva = get_test_e_val(counter, 0.0, test_k_up)
    tv_data.append(tva)

    #data = data + "\t".join([str(counter), str(rld), str(rse), str(tva)]) + "\n"
    counter = counter + 1

n_counter = 0

for i in range(step_range_plus):
    rld = ld.model_step(counter, def_plus)
    rse = se.model_step(counter, def_plus)

    countet_data.append(counter)
    ld_data.append(rld)
    se_data.append(rse)

    tva = get_test_e_val(n_counter, def_plus, test_k_up)
    tv_data.append(tva)

    data = data + "\t".join([str(counter), str(rld), str(rse), str(tva)]) + "\n"
    counter = counter + 1
    n_counter = n_counter + 1

for i in range(step_range_zero):
    rld = ld.model_step(counter, 0.0)
    rse = se.model_step(counter, 0.0)

    countet_data.append(counter)
    ld_data.append(rld)
    se_data.append(rse)

    tva = get_test_e_val(counter, 0.0, test_k_up)
    tv_data.append(tva)

    data = data + "\t".join([str(counter), str(rld), str(rse), str(tva)]) + "\n"
    counter = counter + 1


print(data)

fig, ax = plt.subplots()

ax.plot(countet_data, ld_data, label = 'ASL_DUAM')
ax.plot(countet_data, se_data, label = 'ELS_DUAM')
ax.plot(countet_data, tv_data, label = 'TD_DUAM')

ax.legend()

plt.show()



'''
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': " ", 'sum': " ", 'time': cur_date.__str__(), 'type': " "}
    rl_dic_prec_data[cur_date] = {'raw_ndistance': " ", '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]
    result = None
    counter += 1

    result = forecast_corr.GetResult(dic_prec_data[k], k, counter)
    json_all += json.dumps(result)

    result_sher = forecast_sher.GetResult(dic_prec_data[k], k, counter)

    ks, vs = GetAllDictKeysAndValues(dict(
        real_prec = real_prec,
        real_level = real_level,
        forecast = result,
        forecast_sher = result_sher))

    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()
'''