import logging, requests, threading
from typing import Any, Iterator, List, Tuple, Union
from common.type_checkers.Checkers import chk_string, chk_type
from device.service.driver_api._Driver import _Driver
from . import ALL_RESOURCE_KEYS
from .Tools import create_connectivity_service, find_key, config_getter, delete_connectivity_service

LOGGER = logging.getLogger(__name__)

class TransportApiDriver(_Driver):
    def __init__(self, address: str, port: int, **settings) -> None:    # pylint: disable=super-init-not-called
        self.__lock = threading.Lock()
        self.__started = threading.Event()
        self.__terminate = threading.Event()
        self.__tapi_root = 'http://' + address + ':' + str(port)
        self.__timeout = int(settings.get('timeout', 120))

    def Connect(self) -> bool:
        url = self.__tapi_root + '/restconf/data/tapi-common:context'
        with self.__lock:
            if self.__started.is_set(): return True
            try:
                requests.get(url, timeout=self.__timeout)
            except requests.exceptions.Timeout:
                LOGGER.exception('Timeout connecting {:s}'.format(str(self.__tapi_root)))
                return False
            except Exception:  # pylint: disable=broad-except
                LOGGER.exception('Exception connecting {:s}'.format(str(self.__tapi_root)))
                return False
            else:
                self.__started.set()
                return True

    def Disconnect(self) -> bool:
        with self.__lock:
            self.__terminate.set()
            return True

    def GetInitialConfig(self) -> List[Tuple[str, Any]]:
        with self.__lock:
            return []

    def GetConfig(self, resource_keys : List[str] = []) -> List[Tuple[str, Union[Any, None, Exception]]]:
        chk_type('resources', resource_keys, list)
        results = []
        with self.__lock:
            if len(resource_keys) == 0: resource_keys = ALL_RESOURCE_KEYS
            for i, resource_key in enumerate(resource_keys):
                str_resource_name = 'resource_key[#{:d}]'.format(i)
                chk_string(str_resource_name, resource_key, allow_empty=False)
                results.extend(config_getter(self.__tapi_root, resource_key, self.__timeout))
        return results

    def SetConfig(self, resources: List[Tuple[str, Any]]) -> List[Union[bool, Exception]]:
        results = []
        if len(resources) == 0:
            return results
        with self.__lock:
            for resource in resources:
                LOGGER.info('resource = {:s}'.format(str(resource)))

                input_sip = find_key(resource, 'input_sip')
                output_sip = find_key(resource, 'output_sip')
                uuid = find_key(resource, 'uuid')
                capacity_value = find_key(resource, 'capacity_value')
                capacity_unit = find_key(resource, 'capacity_unit')
                layer_protocol_name = find_key(resource, 'layer_protocol_name')
                layer_protocol_qualifier = find_key(resource, 'layer_protocol_qualifier')
                direction = find_key(resource, 'direction')

                data = create_connectivity_service(
                    self.__tapi_root, self.__timeout, uuid, input_sip, output_sip, direction, capacity_value,
                    capacity_unit, layer_protocol_name, layer_protocol_qualifier)
                results.extend(data)
        return results

    def DeleteConfig(self, resources: List[Tuple[str, Any]]) -> List[Union[bool, Exception]]:
        results = []
        if len(resources) == 0: return results
        with self.__lock:
            for resource in resources:
                LOGGER.info('resource = {:s}'.format(str(resource)))
                uuid = find_key(resource, 'uuid')
                results.extend(delete_connectivity_service(self.__tapi_root, self.__timeout, uuid))
        return results

    def SubscribeState(self, subscriptions : List[Tuple[str, float, float]]) -> List[Union[bool, Exception]]:
        # TODO: TAPI does not support monitoring by now
        return [False for _ in subscriptions]

    def UnsubscribeState(self, subscriptions : List[Tuple[str, float, float]]) -> List[Union[bool, Exception]]:
        # TODO: TAPI does not support monitoring by now
        return [False for _ in subscriptions]

    def GetState(self, blocking=False) -> Iterator[Tuple[float, str, Any]]:
        # TODO: TAPI does not support monitoring by now
        return []
