from collections import OrderedDict

from django import conf
from django.shortcuts import render

from .obsconfig_class import OBSConfig

from django.conf import settings
from src.core.pyros_django.dashboard.decorator import level_required
from django.contrib.auth.decorators import login_required

from django.http import HttpResponse
from datetime import datetime

from django.views.decorators.csrf import csrf_exempt

import re
import yaml
import tempfile
import json
import os

def get_nested_dictionaries_as_list(dic, result=[]):
    for key, value in dic.items():
        print(value, type(value))

        print(result)
        if isinstance(value, dict):
            print("recursive call")

            get_nested_dictionaries_as_list(value, result)
        elif isinstance(value, list) and key == "CAPABILITIES":
            print("VALUE OF LIST =======          ", value)

            for element in value:

                # print(element)
                if isinstance(element, dict):
                    get_nested_dictionaries_as_list(element, result)

        else:

            result.append((key, value))

    return result

@login_required

@level_required("Admin", "Observer", "Management", "Operator", "Unit-PI")

def obs_global_config(request):

    config = OBSConfig(
        os.environ["PATH_TO_OBSCONF_FILE"], os.environ["unit_name"])

    units_names = list(config.get_units().keys())

    pickle_file_mtime = os.path.getmtime(config.CONFIG_PATH+config.pickle_file)

    pickle_datetime = datetime.utcfromtimestamp(
        pickle_file_mtime).strftime("%Y/%m/%d %H:%M:%S")
    CAN_EDIT_CONFIG = request.session.get("role") in (
        "Admin", "Operator", "Unit-PI", "Unit-board")
    CAN_VIEW_HARDWARE_CONFIG = request.session.get("role") in (
        "Admin", "Operator", "Unit-PI", "Unit-board")
    CAN_VIEW_ASTRONOMER_CONFIG = request.session.get("role") in (
        "Admin", "Operator", "Unit-PI", "Observer", "Management board manager", "Unit-board")
    CAN_VIEW_AGENTS_CONFIG = request.session.get("role") == "Admin"

    return render(request, "obs_config/global_obs_configuration.html", {

        "units_names": units_names,

        "obs_name": config.get_obs_name(),

        "last_modification_time": pickle_datetime,
        "CAN_EDIT_CONFIG": CAN_EDIT_CONFIG,

        "CAN_VIEW_HARDWARE_CONFIG": CAN_VIEW_HARDWARE_CONFIG,

        "CAN_VIEW_ASTRONOMER_CONFIG": CAN_VIEW_ASTRONOMER_CONFIG,
        "CAN_VIEW_AGENTS_CONFIG": CAN_VIEW_AGENTS_CONFIG

    })

@login_required

@level_required("Admin", "Unit-PI", "Operator")

def obs_hardware_config(request):

    config = OBSConfig(
        os.environ["PATH_TO_OBSCONF_FILE"], os.environ["unit_name"])

    devices = config.get_devices()
    active_devices = config.get_active_devices()
    computers = config.get_computers()
    active_computers = config.get_active_computers()
    # give for a device name (key) the unit name where it is used (value)
    device_to_unit = {}
    # give for a computer name (key) the unit name where it is used (value)
    computer_to_unit = {}
    for device in active_devices:
        device_to_unit[device] = config.get_unit_of_device(device)
    for computer in active_computers:
        computer_to_unit[computer] = config.get_unit_of_computer(computer)

    devices_links = config.devices_links

    return render(request, 'obs_config/obs_hardware_configuration.html', {'devices': devices, "active_devices": active_devices, "computers": computers, "active_computers": active_computers, "device_to_unit": device_to_unit, "computer_to_unit": computer_to_unit, "devices_links": devices_links})

@login_required

@level_required("Admin", "Unit-PI", "Operator")
def unit_hardware_configuration(request, unit_name):
    config = OBSConfig(
        os.environ["PATH_TO_OBSCONF_FILE"], os.environ["unit_name"])

    devices = config.get_devices()

    return render(request, 'obs_config/unit_hardware_configuration.html', {'config': config})

@login_required

@level_required("Admin", "Unit-PI", "Operator")
def computer_details(request, computer_name):
    config = OBSConfig(
        os.environ["PATH_TO_OBSCONF_FILE"], os.environ["unit_name"])

    computer_detail = yaml.dump(config.get_computers()[computer_name])
    """

    computer_detail = { re.sub("^_","",key):value for key,
                               value in config.get_computers()[computer_name].items() }

     # We're removing "_" at the beginning of each key :

    power = { re.sub("^_","",key):value for key,
                     value in config.get_computer_power(computer_name).items() }

    computer_config = computer_detail["computer_config"]
    # We're removing "_" at the beginning of each key :

    computer_detail["computer_config"] = {
        re.sub("^_","",key):value for key,value in computer_config.items() }
    # Remove power key as we have this information in the same

    if power is not None:
        computer_detail["computer_config"].pop("power")

    return render(request,"obs_config/computer_details.html", {"computer_detail" : computer_detail, "power" : power})

    """

    return render(request, "obs_config/computer_details.html", {"computer_detail": computer_detail})

@login_required

@level_required("Admin", "Unit-PI",  "Operator", "Observer")

def device_details(request, device_name):
    config = OBSConfig(
        os.environ["PATH_TO_OBSCONF_FILE"], os.environ["unit_name"])

    # We're removing "_" at the beginning of each key :
    device = config.get_devices()[device_name]

    # device_detail  = yaml.dump(device)
    # config_device = open(config.CONFIG_PATH+device["file"],"r").read()

    devices_links = config.devices_links

    file_name_to_device_name = {
        v: k for k, v in config.get_devices_names_and_file().items()}

    active_devices = config.get_active_devices()

    """
    Alternative solutions:

        - test_device -> we're using a recursive function to get all nested dicitonaries but we loose a level of

        "precision" (no separations of capabilities for example)
        - device_detail -> we use multiple function to get specific value (not global enougth, if we had another key we have to change the code)

    """

    device_detail = {re.sub("^_", "", key): value for key,
                     value in config.get_devices()[device_name].items()}
    # test_device=  get_nested_dictionaries_as_list(device_detail,[])

    if config.get_device_power(device_name) is not None:
        # We're removing "_" at the beginning of each key :

        power = {re.sub("^_", "", key): value for key,
                 value in config.get_device_power(device_name).items()}
    else:

        power = None
    if config.get_device_connector(device_name) is not None:
        # We're removing "_" at the beginning of each key :

        connector = {re.sub("^_", "", key): value for key,
                     value in config.get_device_connector(device_name).items()}

    else:
        connector = None

    capabilities = []
    if config.get_device_capabilities(device_name) is not None:
        copy_capabilities = config.get_device_capabilities(device_name)
        for capability in copy_capabilities:
            # We're removing "_" at the beginning of each key :

            capabilities.append(
                {re.sub("^_", "", key): value for key, value in capability.items()})

    device_config = device_detail["device_config"]
    # We're removing "_" at the beginning of each key :

    device_detail["device_config"] = {
        re.sub("^_", "", key): value for key, value in device_config.items()}
    # Remove power key as we have this information in the same

    if power is not None:
        device_detail["device_config"].pop("power")
    if connector is not None:
        device_detail["device_config"].pop("connector")

    if len(capabilities) != 0:

        device_detail["device_config"].pop("CAPABILITIES")

    return render(request, "obs_config/device_details.html", {"device_detail": device_detail, "power": power, "connector": connector, "capabilities": capabilities, "devices_links": devices_links, "file_name_to_device_name": file_name_to_device_name, "active_devices": active_devices})

    # return render(request,"obs_config/device_details.html", { "device_detail" : device_detail, "config" : config_device })

@login_required

@level_required("Admin", "Observer", "Management", "Operator", "Unit-PI", "TAC")

def obs_astronomer_config(request):

    config = OBSConfig(
        os.environ["PATH_TO_OBSCONF_FILE"], os.environ["unit_name"])

    units = config.get_units()
    units_topologies = {}
    # for each unit
    for unit_name in units:

        units_topologies[unit_name] = config.get_topology(unit_name)

        layouts = units_topologies[unit_name].pop("LAYOUTS")["layouts"]
        albums = units_topologies[unit_name].pop("ALBUMS")["albums"]

        # for each category (security, mount, channels)
        for category in units_topologies[unit_name]:
            if category != "CHANNELS":
                # Security and Mount are directly a dictionary containing the attributes of those categories
                # However, component_agents is a list so we need to iterate through this list

                for index, component_agent in enumerate(units_topologies[unit_name][category]["COMPONENT_AGENTS"]):

                    component_name = list(component_agent.keys())[0]
                    agent = component_agent[component_name]

                    device_of_agent = config.get_device_for_agent(
                        unit_name, agent)

                    units_topologies[unit_name][category]["COMPONENT_AGENTS"][index][component_name] = device_of_agent
            else:
                # Channels is composed of a list of channel, we're looping through it

                # We want to list every component for each channels

                for channel_name in units_topologies[unit_name]["CHANNELS"]:

                    units_topologies[unit_name]["CHANNELS"][channel_name]["DEVICES"] = []
                    for index, agent in enumerate(units_topologies[unit_name]["CHANNELS"][channel_name]["AGENTS"]):
                        device = config.get_device_for_agent(

                            unit_name, agent)

                        if device is None:
                            # Agent is not an AgentDevice
                            continue
                        else:
                            units_topologies[unit_name]["CHANNELS"][channel_name]["DEVICES"].append(device)
                    for index, device in enumerate(units_topologies[unit_name]["CHANNELS"][channel_name]["COMPONENTS"]):
                        device = config.get_device_information(device)
                        units_topologies[unit_name]["CHANNELS"][channel_name]["DEVICES"].append(device)

        # Re add layouts and albums

        units_topologies[unit_name]["LAYOUTS"] = layouts

        units_topologies[unit_name]["ALBUMS"] = albums
        order_of_keys = ["SECURITY", "MOUNT", "LAYOUTS", "ALBUMS", "CHANNELS"]
        list_of_tuples = [(key, units_topologies[unit_name][key])
                          for key in order_of_keys]
        units_topologies[unit_name] = OrderedDict(list_of_tuples)

    return render(request, "obs_config/obs_astronomer_config.html", {

        "units_topologies": units_topologies,

    })

@ login_required
@ level_required("Admin")

def obs_agents_config(request):

    config = OBSConfig(
        os.environ["PATH_TO_OBSCONF_FILE"], os.environ["unit_name"])

    units = config.get_units()
    units_topologies = {}
    active_agents_by_unit = {}
    # for each unit
    for unit_name in units:

        agents = config.get_agents(unit_name)

        # list of active agents of the current unit

        active_agents_by_unit[unit_name] = config.get_active_agents(unit_name)

        # topology of the current unit

        units_topologies[unit_name] = config.get_topology(unit_name)

        # removing albums and layouts, not useful in this view
        units_topologies[unit_name].pop("LAYOUTS")
        units_topologies[unit_name].pop("ALBUMS")

        for category in units_topologies[unit_name]:
            if category != "CHANNELS":
                # Security and Mount are directly a dictionary containing the attributes of those categories
                # However, component_agents is a list so we need to iterate through this list
                for component_agent in units_topologies[unit_name][category]["COMPONENT_AGENTS"]:
                    component_name = list(component_agent.keys())[0]

                    agent = agents[component_agent[component_name]]

                    # get the index of the current component, agent couple
                    index = units_topologies[unit_name][category]["COMPONENT_AGENTS"].index(
                        component_agent)

                    units_topologies[unit_name][category]["COMPONENT_AGENTS"][index][component_name] = agent
            else:

                for channel_name in units_topologies[unit_name]["CHANNELS"]:

                    units_topologies[unit_name]["CHANNELS"][channel_name]["CAPABILITIES"] = {}
                    for index, agent in enumerate(units_topologies[unit_name]["CHANNELS"][channel_name]["AGENTS"]):
                        # get agent informations
                        if type(agent) == str:
                            agent = config.get_agent_information(unit_name, agent)
                            if agent is None: 
                                # agent missing link, not defined in agents list in obs config
                                pass
                            device = agent.get("device")
                            if device:

                                capabilities = config.get_device_capabilities(device)

                                units_topologies[unit_name]["CHANNELS"][channel_name]["CAPABILITIES"][device] = capabilities
                            units_topologies[unit_name]["CHANNELS"][channel_name]["AGENTS"][index] = agent

        agents = config.get_agents_per_computer(config.unit_name)
        computers = {}
        for computer in config.get_computers():
            computers[config.get_computers().get(computer).get("computer_config").get("hostname")] = computer
        units_topologies[unit_name]["COMPUTERS"] = agents

    return render(request, "obs_config/obs_agents_config.html", {"units_topologies": units_topologies, "active_agents_by_unit": active_agents_by_unit,"computers":computers})

@ login_required
@ level_required("Admin", "Operator", "Unit-PI", "Unit-board")

def edit_config(request):

    config = OBSConfig(
        os.environ["PATH_TO_OBSCONF_FILE"], os.environ["unit_name"])

    return render(request, "obs_config/edit_config.html", {"config_file": config.raw_config})

@ login_required
@ level_required("Admin", "Operator", "Unit-PI", "Unit-board")

def verify_config(request):
    if request.POST.get("config"):

        temp_config_file = tempfile.NamedTemporaryFile(
            mode='w+', suffix=".yml")

        temp_config_file.write(request.POST.get("config"))
        temp_config_file.seek(0)
        response_data = {}

        try:
            config_file = yaml.safe_load(temp_config_file.read())
        except yaml.YAMLError as exc:
            if hasattr(exc, 'problem_mark'):
                yaml_error_message = ""
                if exc.context != None:

                    yaml_error_message += str(exc.problem_mark) + \
                        '\n  ' + str(exc.problem) + ' ' + str(exc.context)

                else:

                    yaml_error_message = str(
                        exc.problem_mark.name) + '\n  ' + str(exc.problem)

                response_data["is_valid"] = False
                response_data["yaml_error_message"] = yaml_error_message
            return HttpResponse(json.dumps(response_data), content_type="application/json")

        temp_config_file.seek(0)
        schema = config_file["schema"]
        errors = []
        if schema == None:

            response_data["is_valid"] = False

            response_data["message"] = "Missing schema"

        schema_path = os.path.join(

            os.environ["DJANGO_PATH"], "../../../config/observatory/general/schemas/")

        config = OBSConfig.check_config(
            temp_config_file.name, schema_path+schema)

        if type(config) == bool and config:
            response_data["is_valid"] = True

        else:

            response_data["is_valid"] = False
            for error in config:

                errors.append(
                    (f"Error : {str(error).split('. Path')[0]}", f"Path to error : '{error.path}'"))

            response_data["message"] = errors
        temp_config_file.close()
        return HttpResponse(json.dumps(response_data), content_type="application/json")

@ login_required
@ level_required("Admin", "Operator", "Unit-PI", "Unit-board")

def save_config(request):
    if request.POST:
        if request.POST["config"]:

            with open(os.environ["PATH_TO_OBSCONF_FILE"], "w") as obs_config_file:

                obs_config_file.write(request.POST.get("config"))

            return HttpResponse("Ok !")

@ login_required

@ level_required("Admin", "Unit-PI",  "Operator", "Observer")

@ csrf_exempt

def view_raw_component_config_file(request):

    COMPONENT_PATH = os.path.join(
        os.environ["DJANGO_PATH"], "../../../config/components/")

    if request.POST:
        try:
            yaml_file = open(COMPONENT_PATH+request.POST["yaml_file"])
            content = yaml_file.readlines()
        except:
            content = "Component defined within the device configuration file"
        return HttpResponse(content)

@ login_required

@ level_required("Admin", "Unit-PI",  "Operator", "Observer")

@ csrf_exempt

def view_raw_generic_device_config_file(request):

    GENERIC_DEVICES_PATH = os.path.join(

        os.environ["DJANGO_PATH"], "../../../config/observatory/general/devices/")

    if request.POST:
        yaml_file = open(GENERIC_DEVICES_PATH+request.POST["yaml_file"])
        content = yaml_file.readlines()
        return HttpResponse(content)

@ login_required

@ level_required("Admin", "Unit-PI",  "Operator", "Observer")

@ csrf_exempt

def view_raw_device_config_file(request):
    obs_folder = os.environ["PATH_TO_OBSCONF_FOLDER"]
    if request.POST:
        yaml_file = open(obs_folder+request.POST["yaml_file"])
        content = yaml_file.readlines()

        return HttpResponse(content)

@ login_required

@ level_required("Admin", "Unit-PI",  "Operator", "Observer")

def obs_config_help(request):

    return render(request, "obs_config/obs_config_help.html")