"""Handler of commands sent by CloudSync app to the Device Registration Tool"""

import json
import requests
from time import time
import random
from typing import List
import urllib.parse

from cloudsync.handlers.error_handler import ErrorHandler
from cloudsync.handlers.error import Error
from cloudsync.utils.globals import *
from cloudsync.common.enums import *
from cloudsync.utils.helpers import *


@log_func
def cmd_outgoing_register(device_name: str,
                          hd_serial: str,
                          dg_serial: str,
                          sw_version: str,
                          manf_tool_base_url: str,
                          data_source_id: int,
                          headers: dict,
                          error_handler: ErrorHandler) -> requests.Response:
    """
    Initiates device registration with the device registration tool
    Device -> Manufacturing Tool

    :param device_name: the device name
    :param hd_serial: the hd serial number
    :param dg_serial: the dg serial number
    :param sw_version: the device software version
    :param manf_tool_base_url: the manufacturing tool base url
    :param data_source_id: the data source identification number
    :param headers: the header dictionary
    :param error_handler: global error handler
    :return: requests.Response
    """
    try:
        url = urllib.parse.urljoin(manf_tool_base_url, "register/")
        data = {
            "datasourceId": data_source_id,
            "name": device_name,
            "hdSerialNumber": hd_serial,
            "dgSerialNumber": dg_serial,
            "softwareVersion": sw_version,
        }
        resp = requests.post(url=url,
                             data=data,
                             headers=headers,
                             timeout=(30, 60))
        return resp
    except requests.exceptions.Timeout:
        error = Error.timeout(OutboundMessageIDs.CS2UI_ERROR.value,
                              ErrorIDs.CS_REQ_REGISTRATION_ERROR.value)
        error_handler.enqueue_error(error=error)
        return None
    except requests.exceptions.TooManyRedirects:
        error = Error.redirect(OutboundMessageIDs.CS2UI_ERROR.value,
                               ErrorIDs.CS_REQ_REGISTRATION_ERROR.value)
        error_handler.enqueue_error(error=error)
        return None
    except Exception as e:
        error = Error.general(OutboundMessageIDs.CS2UI_ERROR.value,
                              ErrorIDs.CS_REQ_REGISTRATION_ERROR.value,
                              str(e))
        error_handler.enqueue_error(error=error)
        return None


@log_func
def cmd_outgoing_validation_result(invalid_attributes: List[str],
                                   hd_serial: str,
                                   g_config: dict,
                                   error_handler: ErrorHandler):
    """
    Sends the validation POST to the manf tool
    :param invalid_attributes: The list of invalid attributes
    :param hd_serial: The hd serial number
    :param g_config: The device config
    :param error_handler: global error handler
    :return: The json response
    """

    if (CONFIG_KEBORMED not in g_config.keys() or
            CONFIG_KEBORMED_MFT_URL not in g_config[CONFIG_KEBORMED]):
        error = Error.general(OutboundMessageIDs.CS2UI_ERROR.value,
                              ErrorIDs.CS_DEVICE_VALIDATION_RESULT_ERROR.value,
                              "Manufacturing tool url not found")
        error_handler.enqueue_error(error=error)
        return None

    try:
        url = urllib.parse.urljoin(g_config[CONFIG_KEBORMED][CONFIG_KEBORMED_MFT_URL],
                                   "validation/")

        headers = {
            "device_ip": g_config[CONFIG_DEVICE][CONFIG_DEVICE_IP],
            "device_sn": hd_serial
        }
        if len(invalid_attributes) == 0:
            data = json.dumps({})
        else:
            data = {
                "invalidAttributes": invalid_attributes,
            }
        g_utils.logger.debug("headers: {0}".format(headers))
        g_utils.logger.debug("data: {0}".format(data))
        resp = requests.post(url=url,
                             data=data,
                             headers=headers,
                             timeout=(30, 60))
        return resp.json()
    except requests.exceptions.Timeout:
        error = Error.timeout(OutboundMessageIDs.CS2UI_ERROR.value,
                              ErrorIDs.CS_DEVICE_VALIDATION_RESULT_ERROR.value)
        error_handler.enqueue_error(error=error)
        return None
    except requests.exceptions.TooManyRedirects:
        error = Error.redirect(OutboundMessageIDs.CS2UI_ERROR.value,
                               ErrorIDs.CS_DEVICE_VALIDATION_RESULT_ERROR.value)
        error_handler.enqueue_error(error=error)
        return None
    except Exception as e:
        error = Error.general(OutboundMessageIDs.CS2UI_ERROR.value,
                              ErrorIDs.CS_DEVICE_VALIDATION_RESULT_ERROR.value,
                              str(e))
        error_handler.enqueue_error(error=error)
        return None