import os
import redis
import psycopg2
import datetime
import config
import logging
import base_entity
import base_entity.fws
import json
import pkgutil
import inspect
import measurers
import urllib
import urllib.request
import urllib.parse
import requests
import time
import sys
import logging
from ocm_fwk.ocm_mq import OcmMqBase, OcmMqBlockingPublisher

currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
parentdir = os.path.dirname(currentdir)
sys.path.insert(0,parentdir)

import datatypes.dt_precipitation
import config as cfg
import base_entity.utils as utils

logging.basicConfig(filename="service.log", level=logging.ERROR)

################################
## ОБЩИЕ РЕСУРСЫ
confUseBus = False
################################


################################
## ОБЩИЕ РЕСУРСЫ
DBConnection = None
RadisConnection = None
BusSenderConnection = None

meas_store = dict()											# Общая песочница измерителей
rel_station_meas = dict()							        # Связи измерителей и постов
commutator = dict()	                                        # Коммутатор
hard_db_source = []                                         # Источники из железячной базы данных
external_source = []										# Внешние источники (рейн-вьевер и прочее)
internal_source = []										# Внутренние источники (виртуальные измерители)
filter_hard_db_source = []									# Фильтр для шины (тут только ГУИДы тех измерителей, которые нужны в работе)
routing_store = []											# Список уникальных маршрутов для получения данных
data_types = dict()											# Зарегистрированные типы данных
tmp_bus_values_for_ts = []                                  # Временное хранилище данных с шины на один тайм-слот (для проверки на момент "УЖЕ БЫЛО")
tmp_bus_ts = None                                           # Ометка времени для шины (для проверки на момент "УЖЕ БЫЛО")

###############################################

# 1. Подготовка соединений
def ConnectionPrepare():
    host = config.db_postgres_connection["host"]
    login = config.db_postgres_connection["user"]
    pwd = config.db_postgres_connection["password"]
    udb = config.user_db_name

    global DBConnection
    DBConnection = psycopg2.connect(
        host=host,
        database=udb,
        user=login,
        password=pwd)
    DBConnection.autocommit = True

    global RadisConnection
    global BusSenderConnection
    BusSenderConnection = utils.BusPublisher(cfg)

###############################################
## UTILS
def GetCurrentTS():
    ts = None
    ts = datetime.datetime.utcnow()
    minutes = (ts.minute // 10) * 10
    result = datetime.datetime(ts.year, ts.month, ts.day, ts.hour, minutes, 0, 0).replace(tzinfo=datetime.timezone.utc)
    test = result.replace(tzinfo=datetime.timezone.utc).isoformat()
    test2 = result.replace(tzinfo=datetime.timezone.utc)
    return result

def GetDataFromBus(_ts):
    global filter_hard_db_source									# Фильтр для шины (тут только ГУИДы тех измерителей, которые нужны в работе)
    global routing_store											# Список уникальных маршрутов для получения данных
    global confUseBus
    global tmp_bus_ts
    global tmp_bus_values_for_ts

    local_store = []

    if confUseBus == True:
        ###############################################
        # Доступ к данным через Шину
        pass

    else:
        ###############################################
        # Доступ к данным через REST
        ts = _ts

        dt = datetime.timedelta(minutes=1)
        ts_min = ts - dt
        ts_max = ts + dt
        url = r"http://evolution.emercit.com:8888/monitoring/rest/precipitation-measurements/{uid}?time-from={tmin}&time-to={tmax}"
        #r = requests.get('http://evolution.emercit.com:8888/monitoring/rest/water-level-measurements/25c207bb-a26b-4bf6-b628-ccb176544fd7', 
        #    params={"time-from":"2020-01-14T02:00:00+00:00","time-to":"2020-01-14T08:00:00+00:00"})

        for var in filter_hard_db_source:
            values = []
            try:
                q = url.format(uid = var, tmin = urllib.parse.quote(ts_min.__str__()), tmax = urllib.parse.quote(ts_max.__str__()))
                data = requests.get(q, timeout=120, stream=True)
                values = data.json()
            except BaseException as error:
                print("Не удалось получить данные от hard_db:{}".format(error))

            for v in values:
                v["time"] = ts
                v["measurer_uuid"] = var
                v["station_uuid"] = ""
                dt_guid = meas_store[var].get_reg_type_info()["Return_Data_Type_GUID"]
                full_val = data_types[dt_guid].convert_from_bus(v)
                local_store.append(full_val)

    return local_store

#@utils.dec_TryExcept
def SetToBus(rout, value):
    #print("send to bus rout = {}, value = {}".format(rout, json.dumps(value, cls=utils.SpecialJSONEncoder)))
    global BusSenderConnection
    try:
        BusSenderConnection.publish(rout, value)
        return
    except expression as identifier:
        ConnectionPrepare()
        try:
            BusSenderConnection.publish(rout, value)
            return
        except BaseException as identifier:
            logging.ERROR("Не удалось отправить данные на шину:{}".format(identifier))
            return
    return
    #BusSenderConnection.publish(rout, value)

def SaveToRadis(key, value):
    RadisConnection.set(key, value)

def GetFromRadis(key):
    result = RadisConnection.get(key).decode("utf-8")
    return result

def ExecuteNonResultQuery(query):
    try:
        cur = DBConnection.cursor()
        cur.execute(query)
        return
    except BaseException as err:
        ConnectionPrepare()
        try:
            cur = DBConnection.cursor()
            cur.execute(query)
        except BaseException as identifier:
            logging.ERROR("Не удалось выполнить запрос {} к БД:{}:{}".format(query, err, identifier))
            return
    return

def ExecuteResultQuery(query):
    result = None

    try:
        cur = DBConnection.cursor()
        cur.execute(query)
        result = cur.fetchall()
        cur.close()
        return result
    except BaseException as err:
        ConnectionPrepare()
        try:
            cur = DBConnection.cursor()
            cur.execute(query)
            result = cur.fetchall()
            cur.close()
            return result
        except BaseException as identifier:
            logging.ERROR("Не удалось выполнить запрос {} к БД:{}:{}".format(query, err, identifier))
            return
        finally:
            cur.close()
    return result

# 2. Заполнение оперативных данных
def FillData():
    global meas_store											# Общая песочница измерителей
    global rel_station_meas							        # Связи измерителей и постов
    global commutator	                                        # Коммутатор
    global hard_db_source                                         # Источники из железячной базы данных
    global external_source										# Внешние источники (рейн-вьевер и прочее)
    global internal_source										# Внутренние источники (виртуальные измерители)
    global filter_hard_db_source									# Фильтр для шины (тут только ГУИДы тех измерителей, которые нужны в работе)
    global routing_store											# Список уникальных маршрутов для получения данных
    global data_types											# Зарегистрированные типы данных
    global meas_type_store

    meas_store = dict()											# Общая песочница измерителей
    rel_station_meas = dict()							        # Связи измерителей и постов
    commutator = dict()	                                        # Коммутатор
    hard_db_source = []                                         # Источники из железячной базы данных
    external_source = []										# Внешние источники (рейн-вьевер и прочее)
    internal_source = []										# Внутренние источники (виртуальные измерители)
    filter_hard_db_source = []									# Фильтр для шины (тут только ГУИДы тех измерителей, которые нужны в работе)
    routing_store = []											# Список уникальных маршрутов для получения данных
    data_types = dict()											# Зарегистрированные типы данных
    meas_type_store = dict()                                    #{Хранилище типов измерителей}


    dt_query = base_entity.fws.get_select_all_query(base_entity.fws.struct.DataType)
    qresult = ExecuteResultQuery(dt_query)

    for var in qresult:
        dt_guid = var[3]
        mod_name = var[9]
        m_name = "datatypes.{}".format(mod_name)
        loader = pkgutil.get_loader(m_name)
        module = loader.load_module(m_name)
        dt = module.DataType()
        data_types[dt_guid] = dt

    meas_query = base_entity.fws.get_select_all_query(base_entity.fws.struct.Measurer)
    meas_type_query = base_entity.fws.get_select_all_query(base_entity.fws.struct.MeasurerType)
    qresult = ExecuteResultQuery(meas_type_query)

    for var in qresult:
        meas_type_store[var[3]] = var[9]

    qresult = ExecuteResultQuery(meas_query)

    for var in qresult:
        mid = int(var[0])
        Name  = var[1]
        Description = var[2]
        GUID  = var[3]
        Measure_Type_GUID = var[4]
        Parameters = json.loads(var[5])
        Dynamic_Parameters = json.loads(var[6])
        Connections = json.loads(var[7])
        Station_Parameters = json.loads(var[8])
        Is_Inherited = bool(var[9])
        Is_Bus_Sender = bool(var[10])
        Is_Work = bool(var[11])
        Save_Addition_Info = bool(var[12])

        # Create measurer by type
        m_name = "measurers.{}".format(meas_type_store[Measure_Type_GUID])
        loader = pkgutil.get_loader(m_name)
        module = loader.load_module(m_name)
        NewMeas = module.Measurer()
        NewMeas.initialize(
            _id=mid,
            _Name=Name,
            _GUID=GUID,
            _Description=Description,
            _Parameters = Parameters,
            _Dynamic_Parameters = Dynamic_Parameters,
            _Connections = Connections,
            _Station_Parameters = Station_Parameters,
            _Is_Inherited = Is_Inherited,
            _Is_Bus_Sender = Is_Bus_Sender,
            _Is_Work = Is_Work,
            _Save_Addition_Info = Save_Addition_Info)

        meas_store[GUID] = NewMeas

        if Is_Inherited == True:
            hard_db_source.append(GUID)
        else:
            conn = NewMeas.get_connections_list()

            if conn is None or len(conn) == 0:
                external_source.append(GUID)
            else:
                internal_source.append(GUID)

        st_params = NewMeas.get_station_parameter_list()

        if st_params is not None and len(st_params) > 0:
            st_param_dict = dict()
            for stp in st_params:
                st_param_q = base_entity.fws.get_select_query_by_guid(base_entity.fws.struct.StationParameter, stp)
                var = ExecuteResultQuery(st_param_q)
                st_param_dict[stp] = json.loads(var[0][4])
            NewMeas.set_station_parameters(st_param_dict)

    for key in meas_store.keys():
        NewMeas = meas_store[key]
        conn = NewMeas.get_connections_list()
        GUID = NewMeas.GUID

        if conn is not None and len(conn) > 0:
            for var in conn:
                if var in hard_db_source:
                    filter_hard_db_source.append(var)
                    dt_guid = meas_store[var].get_reg_type_info()["Return_Data_Type_GUID"]
                    rout = data_types[dt_guid].Bus_Rout_Name

                    if rout not in routing_store:
                        routing_store.append(rout)

                if var not in commutator.keys():
                    commutator[var] = []

                commutator[var].append(GUID)

def Start():
    ConnectionPrepare()
    FillData()

def Iterator(local_data_store = []):
    global commutator	                                        # Коммутатор
    global meas_store											# Общая песочница измерителей

    l = len(list(local_data_store.keys()))
    i = 0
    while i < l:
        mmn = list(local_data_store.keys())[i]
        recipients = commutator.get(mmn, [])
        for rec in recipients:
            result = None
            meas  = meas_store[rec]
            input_value = local_data_store[mmn]
            if meas.Current_TS_Is_Ready == False:
                try:
                    result = meas.set_value(input_value)
                except BaseException as identifier:
                    print(identifier)
                    result = None
            if result is not None:
                local_data_store[result["reg_inf"]["measurer_uuid"]] = result
                dt = meas.Return_Data_Type
                q = dt.get_insert_mdata_query(result)
                ExecuteNonResultQuery(q)
                if meas.Is_Bus_Sender == True:
                    SetToBus(dt.Bus_Rout_Name, dt.get_bus_data(result))
        l = len(list(local_data_store.keys()))
        i = i+1

def Run():
    global meas_store											# Общая песочница измерителей
    global rel_station_meas							        # Связи измерителей и постов
    global hard_db_source                                         # Источники из железячной базы данных
    global external_source										# Внешние источники (рейн-вьевер и прочее)
    global internal_source										# Внутренние источники (виртуальные измерители)
    global filter_hard_db_source									# Фильтр для шины (тут только ГУИДы тех измерителей, которые нужны в работе)
    global routing_store											# Список уникальных маршрутов для получения данных
    global data_types											# Зарегистрированные типы данных
    global meas_type_store

    current_ts = GetCurrentTS()
    local_data_store = dict()

    for key in meas_store.keys():
        meas_store[key].Current_TS = current_ts

    while(1):
        print(current_ts)
        local_data_store = dict()
        new_ts = GetCurrentTS()

        if new_ts == current_ts:
            #Забираем всё с шины
            values = GetDataFromBus(current_ts)

            # Заполнили локальное хранилище данными с шины
            if values is not None and len(values) > 0:
                for var in values:
                    local_data_store[var["reg_inf"]["measurer_uuid"]] = var

            # 1. СЛОЙ ПРЯМОГО ОБМЕНА
            if len(list(local_data_store.keys())) > 0:
                Iterator(local_data_store)
            local_data_store = dict()

            # 2. СЛОЙ ПРОВЕРКИ НА ГОТОВ_К_РАСЧЕТУ
            for key in internal_source:
                result = None
                meas = meas_store[key]
                if meas.Current_TS_Is_Ready == False:
                    try:
                        if meas.is_ready_to_calculation() == True:
                            result = meas.get_result()
                    except BaseException as identifier:
                        print(identifier)
                        result = None
                    if result is not None:
                        dt = meas.Return_Data_Type
                        q = dt.get_insert_mdata_query(result)
                        ExecuteNonResultQuery(q)
                        if meas.Is_Bus_Sender == True:
                            SetToBus(dt.Bus_Rout_Name, dt.get_bus_data(result))
                        local_data_store[result["reg_inf"]["measurer_uuid"]] = result
                        if len(list(local_data_store.keys())) > 0:
                            Iterator(local_data_store)

            # 2.1 СЛОЙ ПРОВЕРКИ НА ГОТОВ_К_РАСЧЕТУ ДЛЯ ВНЕШНИХ
            for key in external_source:
                result = None
                meas = meas_store[key]
                if meas.Current_TS_Is_Ready == False:
                    try:
                        if meas.is_ready_to_calculation() == True:
                            result = meas.get_result()
                    except BaseException as identifier:
                        print(identifier)
                        result = None
                    if result is not None:
                        dt = meas.Return_Data_Type
                        q = dt.get_insert_mdata_query(result)
                        ExecuteNonResultQuery(q)
                        if meas.Is_Bus_Sender == True:
                            SetToBus(dt.Bus_Rout_Name, dt.get_bus_data(result))
                        local_data_store[result["reg_inf"]["measurer_uuid"]] = result
                        if len(list(local_data_store.keys())) > 0:
                            Iterator(local_data_store)

            local_data_store = dict()

        else:
            local_data_store = dict()
            for key in internal_source:
                result = None
                meas = meas_store[key]
                try:
                    result = meas.set_new_time_slot(new_ts)
                except BaseException as identifier:
                    print(identifier)
                    result = None
                if result is not None:
                    dt = meas.Return_Data_Type
                    q = dt.get_insert_mdata_query(result)
                    ExecuteNonResultQuery(q)
                    if meas.Is_Bus_Sender == True:
                        SetToBus(dt.Bus_Rout_Name, dt.get_bus_data(result))
                    local_data_store[result["reg_inf"]["measurer_uuid"]] = result
                    if len(list(local_data_store.keys())) > 0:
                        Iterator(local_data_store)

            for key in external_source:
                result = None
                meas = meas_store[key]
                try:
                    result = meas.set_new_time_slot(new_ts)
                except BaseException as identifier:
                    print(identifier)
                    result = None
                if result is not None:
                    dt = meas.Return_Data_Type
                    q = dt.get_insert_mdata_query(result)
                    ExecuteNonResultQuery(q)
                    if meas.Is_Bus_Sender == True:
                        SetToBus(dt.Bus_Rout_Name, dt.get_bus_data(result))
                    local_data_store[result["reg_inf"]["measurer_uuid"]] = result
                    if len(list(local_data_store.keys())) > 0:
                        Iterator(local_data_store)

            local_data_store = dict()
            current_ts = new_ts
        time.sleep(20)

def main():
    Start()
    Run()

if __name__ == '__main__':
    main()