#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import queueing_tool as qt
import numpy as np
import datetime as dt

# CONSTANTS
MAX_AGENTS = 1000000
ONE_YEAR = 525600 # 365 días
SEED = 13

def get_queue_args(p, servers):
    q_args = {
        # Camara Térmica Queue
        1: {
            'num_servers': servers['camaras'],
            'arrival_f': lambda t: t + np.random.uniform(p[0], p[1]),
            'service_f': lambda t: t + np.random.uniform(0.0667, 0.1),
            'collect_data': True
        },
        # Examen Detallado Queue
        2: {
            'num_servers': servers['personal'], # Personal Medico
            'service_f': lambda t: t + np.random.uniform(14, 22),
            'collect_data': True
        },
        # Periodo de Observación Queue
        3: {
            'num_servers': servers['cap_obsr'], # Capacidad de Sala de Observación
            'service_f': lambda t: t + np.random.uniform(1200, 1440),
            'collect_data': True
        },
        # Tratamiento Preventivo Queue
        4: {
            'num_servers': servers['cap_prev'], # Capacidad de Sala de Tratamientos Preventivos
            'service_f': lambda t: t + np.random.uniform(7200, 10080),
            'collect_data': True
        },
        # Tratamiento Definitivo Queue
        5: {
            'num_servers': servers['cap_def'], # Capacidad de Sala de Tratamientos Definitivos
            'service_f': lambda t: t + np.random.uniform(5760, 8640),
            'collect_data': True
        },
        6: {
            'service_f': lambda t: t,
            'collect_data': True
        }
    }
    return q_args

def build_queue_graph(lmb, transition_matrix, svr):
    adja_list = {
        0: [1],
        1: [2, 6],
        2: [3, 4, 7],
        3: [4, 7],
        4: [5, 8],
        5: [9]
    }
    edge_list = {
        0: {1: 1},
        1: {2: 2, 6: 6},
        2: {3: 3, 4: 4, 7: 6},
        3: {4: 4, 7: 6},
        4: {5: 5, 8: 6},
        5: {9: 6}
    }
    g = qt.adjacency2graph(adjacency=adja_list, edge_type=edge_list)
    q_classes = {k: qt.QueueServer for k in range(1, 7)}
    q_args = get_queue_args(lmb, svr)
    qn = qt.QueueNetwork(g=g, q_classes=q_classes, q_args=q_args, max_agents=MAX_AGENTS, seed=SEED)
    qn.set_transitions(transition_matrix)
    return qn

def draw(qn):
    qn.g.new_vertex_property('pos')
    pos = [[k-5, 0.8] for k in range(0, 3)]
    pos += [[-2, 0.6],  [-1, 0.8],  [0, 0.8], [-3, 0.4], [0, 0.4]]
    pos += [[k-5, 0.4] for k in range(7, 10)]
    dt = {k: pos[k] for k in range(10)}
    qn.g.set_pos(dt)
    qn.draw(fname="fiebre.png", figsize=(12, 3), bbox_inches='tight')


def sim(λ, transition_matrix, servers, SIM_TIME, SCENARIO):
    print("Starting simulation...")
    net = build_queue_graph(λ, transition_matrix, servers)
    net.initialize(edges=[(0,1)])
    net.start_collecting_data()
    net.simulate(t=SIM_TIME)
    net.stop_collecting_data()
    q_res = np.array([[
        'ID Queue', 'Agents (%)', 'Agents (Qty)',
        'Waiting Time (Avg)',
        'Waiting Time (Min)',
        'Waiting Time (Max)',
        'Number Waiting (Avg)',
        'Number Waiting (Min)',
        'Number Waiting (Max)',
        'Utilization (%)',
        'Utilization (Avg)',
        'Server Number (Qty)'
    ]])
    total_arr = net.edge2queue[0].num_arrivals[0]
    for j in range(11):
        waiting_time = [ i[1]-i[0] for i in net.edge2queue[j].fetch_data() if i[1] > 0]
        total_time = [ i[2]-i[0] for i in net.edge2queue[j].fetch_data() if i[1] > 0]
        nbr_waiting = [ i[3] for i in net.edge2queue[j].fetch_data() if i[1] > 0]
        utilization = [ i[4]-i[3] for i in net.edge2queue[j].fetch_data() if i[1] > 0]
        l = [
            net.edge2queue[j].edge[2],
            np.around(net.edge2queue[j].num_arrivals[0]/total_arr, decimals=4),
            net.edge2queue[j].num_arrivals[0],
            np.around(np.mean(waiting_time), decimals=4),
            np.around(np.amin(waiting_time), decimals=4),
            np.around(np.amax(waiting_time), decimals=4),
            np.around(np.mean(nbr_waiting), decimals=4),
            np.around(np.amin(nbr_waiting), decimals=4),
            np.around(np.amax(nbr_waiting), decimals=4),
            np.around(np.mean(utilization) / net.edge2queue[j].num_servers, decimals=4),
            np.around(np.mean(utilization), decimals=4),
            net.edge2queue[j].num_servers
        ]
        q_res = np.append(q_res, [l], axis=0)

    today = dt.datetime.now()
    filename = today.strftime("%Y-%m-%d_%H:%M:%S")+"-queue-analysis-"+SCENARIO+"-"+str(SIM_TIME/1440)+"days.csv"
    np.savetxt(filename, q_res, delimiter=',', fmt='%s')
    print("Done.")



# Datos - Scenario 1
SCENARIO = "scenario1"
λ = (0.0602, 0.1818) # Min y Max de tiempos entre llegadas.
transition_matrix = {
    0: {1: 1.0},
    1: {2: 0.04, 6: 0.96},
    2: {3: 0.05, 4: 0.06, 7: 0.89},
    3: {4: 0.06, 7: 0.94},
    4: {5: 0.08, 8: 0.92},
    5: {9: 1.0}
}
servers = {
    'camaras' : 2,
    'personal': 10,
    'cap_obsr': 100,
    'cap_prev': 200,
    'cap_def' : 20
}
sim(λ, transition_matrix, servers, ONE_YEAR, SCENARIO)

# Datos - Scenario 2
SCENARIO = "scenario2"
e = (0.0667, 0.2) # Min y Max de tiempos entre llegadas.
transition_matrix = {
    0: {1: 1.0},
    1: {2: 0.16, 6: 0.84},
    2: {3: 0.05, 4: 0.06, 7: 0.89},
    3: {4: 0.06, 7: 0.94},
    4: {5: 0.08, 8: 0.92},
    5: {9: 1.0}
}
servers = {
    'camaras' : 2,
    'personal': 50,
    'cap_obsr': 100,
    'cap_prev': 1000,
    'cap_def' : 50
}
sim(e, transition_matrix,servers, ONE_YEAR, SCENARIO )

# Datos - Scenario 3
SCENARIO = "scenario3"
e = (0.075, 0.2273)  # Min y Max de tiempos entre llegadas.
transition_matrix = {
    0: {1: 1.0},
    1: {2: 0.4, 6: 0.6},
    2: {3: 0.05, 4: 0.06, 7: 0.89},
    3: {4: 0.06, 7: 0.94},
    4: {5: 0.08, 8: 0.92},
    5: {9: 1.0}
}
servers = {
    'camaras' : 2,
    'personal': 100,
    'cap_obsr': 200,
    'cap_prev': 1500,
    'cap_def' : 200
}
sim(e, transition_matrix, servers, ONE_YEAR, SCENARIO)