import sys
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 dmrl_prec_file
import dmrl_prec_file_prec_3_sigma
import loca_data
import duamel_model



class Forecast():

    def __init__(self, _dmrl, _flow_rate, _duamel, _level_calc):
        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 = 0.0
        sq_prec = 0.0
        all_sq = 0.0
        priv_prec = 0.0
        dmrl_prec = 0.0

        if result is not None:
            volume_ex = True
            result = json.loads(result)
            volume = float(result["water_volume"])
            sq_prec = float(result["prec_square"])
            all_sq = float(result["all_square"])
            dmrl_prec = float(result["dmrl_prec"])
        else:
            volume_ex = False

        if sq_prec != 0:
            priv_prec = (volume * 1000) / sq_prec

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

        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



test_dmrl = dmrl_prec_file.DMRLPrecFile(_FILE_MODE=True, _polygon=loca_data.GetGeoCoordPolygon())
test_dmrl1 = dmrl_prec_file_prec_3_sigma.DMRLPrecFile(_FILE_MODE=True, _polygon=loca_data.GetGeoCoordPolygon())
duamel = duamel_model.DumlRiverModel()
duamel1 = duamel_model.DumlRiverModel()
flow_rate = duamel_model.CatchmentArea()
flow_rate1 = duamel_model.CatchmentArea()
level_calc = duamel_model.RiverCrossSection()
level_calc1 = duamel_model.RiverCrossSection()


datetime_min = datetime.datetime(2020, 1, 29, 22, 50, 0)
datetime_max = datetime.datetime(2020, 2, 4, 15, 40, 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] = None
    rl_dic_prec_data[cur_date] = None
    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

for k in dic_prec_data.keys():
    counter += 1
    result = test_dmrl.GetResult(dic_prec_data[k], k)
    #result1 = test_dmrl1.GetResult(dic_prec_data[k], k)

    prec_ex = False
    volume_ex = False
    real_level_ex = False

    real_prec = 0.0
    if dic_prec_data[k] is None:
        prec_ex = False
    else:
        real_prec = dic_prec_data[k]["sum"]
        prec_ex = True

    real_level = None
    if rl_dic_prec_data[k] is None:
        real_level_ex = False
    else:
        real_level = rl_dic_prec_data[k]["water_level_bs"]
        real_level_ex = True

    volume = 0.0
    sq_prec = 0.0
    all_sq = 0.0
    priv_prec = 0.0
    dmrl_prec = -1.0

    if result is not None:
        volume_ex = True
        result = json.loads(result)
        volume = float(result["water_volume"])
        sq_prec = float(result["prec_square"])
        all_sq = float(result["all_square"])
        dmrl_prec = float(result["dmrl_prec"])
    else:
        volume_ex = False

    #result1_vol = 0.0
    #if result1 is not None:
    #    result1 = json.loads(result1)
    #    result1_vol = float(result1["water_volume"])

    if sq_prec != 0:
        priv_prec = (volume * 1000) / sq_prec

    flow = flow_rate.calc_surface_flow(priv_prec)
    duam = duamel.model_step(counter, flow)
    level = level_calc.bs_water_level(duam)

    flow1 = flow_rate1.calc_surface_flow(real_prec)
    duam1 = duamel1.model_step(counter, flow1)
    level1 = level_calc1.bs_water_level(duam1)


    local_data = "{date}\t{prec_ex}\t{prec}\t{volume_ex}\t{volume}\t{squere}\t{all_squere}\t{priv_prec}\t{flow}\t{duam}\t{level}\t{real_level_ex}\t{real_level}\t{level1}\t{result1}\n".format(
        date=k,
        prec_ex = prec_ex,
        prec = real_prec,
        volume_ex = volume_ex,
        volume = volume,
        squere = sq_prec,
        all_squere = all_sq,
        priv_prec = priv_prec,
        flow = flow,
        duam = duam,
        level = level,
        real_level_ex = real_level_ex,
        real_level = real_level,
        level1 = level1,
        result1 = dmrl_prec)

    data += local_data
    print(k)

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