from common.proxy.ssh import SSHConfig
from ja.user.config.base import UserConfig, Verbosity
from ja.common.job import JobPriority, JobStatus
from datetime import datetime
from typing import List, Tuple, Dict, Iterable, cast


class QueryCommandConfig(UserConfig):
    """
    Config for the query command of the user client. If one of the properties of this class is None it is not
    considered for filtering query results. Only return jobs that satisfy the individual conditions of each property.
    If more than one value is provided for a single property, the condition of the property is satisfied if the job
    matches any of the provided values.
    """

    def __init__(self, uid: List[str] = None, label: List[str] = None, owner: List[str] = None,
                 priority: List[JobPriority] = None, status: List[JobStatus] = None, is_preemtible: bool = None,
                 special_resources: List[List[str]] = None, cpu_threads: Tuple[int, int] = None,
                 memory: Tuple[int, int] = None, before: datetime = None, after: datetime = None,
                 ssh_config: SSHConfig = None, verbosity: Verbosity = Verbosity.NONE):
        if cpu_threads[0] > cpu_threads[1] or cpu_threads[0] < 1:
            raise ValueError("Invalid range for cpu_threads.")
        if memory[0] > memory[1] or memory[0] < 1:
            raise ValueError("Invalid range for memory.")
        if after < before:
            raise ValueError("incorrect datetime")
        self._uid = uid
        self._label = label
        self._owner = owner
        self._priority = priority
        self._status = status
        self._is_preemtible = is_preemtible
        self._special_resources = special_resources
        self._cpu_threads = cpu_threads
        self._memory = memory
        self._before = before
        self._after = after
        super().__init__(ssh_config, verbosity)

    @property
    def uid(self) -> List[str]:
        """!
        @return: Job uid(s) to filter query results by.
        """
        return self._uid

    @property
    def label(self) -> List[str]:
        """!
        @return: Job label(s) to filter query results by.
        """
        return self._label

    @property
    def owner(self) -> List[str]:
        """!
        @return: Job owner name(s) to filter query results by.
        """
        return self._owner

    @property
    def priority(self) -> List[JobPriority]:
        """!
        @return: Job priority/priorities to filter query results by.
        """
        return self._priority

    @property
    def status(self) -> List[JobStatus]:
        """!
        @return: Job status(es) to filter query results by.
        """
        return self._status

    @property
    def is_preemptible(self) -> bool:
        """!
        @return: Job.is_preemptible value to filter query results by.
        """
        return self._is_preemtible

    @property
    def special_resources(self) -> List[List[str]]:
        """!
        @return: Special resources to filter query results by.
        """
        return self._special_resources

    @property
    def cpu_threads(self) -> Tuple[int, int]:
        """!
        @return: Lower and upper bound of job CPU thread count to filter query results by.
        """
        return self._cpu_threads

    @property
    def memory(self) -> Tuple[int, int]:
        """!
        @return: Lower and upper bound of job memory allocation in MB to filter query results by.
        """
        return self._memory

    @property
    def before(self) -> datetime:
        """!
        Only return jobs scheduled before this point in time.
        @return: The latest point in time a job of interest was scheduled.
        """
        return self._before

    @property
    def after(self) -> datetime:
        """!
        Only return jobs scheduled after this point in time.
        @return: The earliest point in time a job of interest was scheduled.
        """
        return self._after

    @property
    def verbosity(self) -> Verbosity:
        return self._verbosity

    @property
    def ssh_config(self) -> SSHConfig:
        return self._ssh_config

    def __eq__(self, o: object) -> bool:
        if isinstance(o, QueryCommandConfig):
            return self._uid == o._uid \
                   and self._label == o._label \
                   and self._owner == o._owner \
                   and self._priority == o._priority \
                   and self._status == o._status \
                   and self._is_preemtible == o._is_preemtible \
                   and self._special_resources == o._special_resources \
                   and self._cpu_threads == o._cpu_threads \
                   and self._memory == o._memory \
                   and self._before == o._before \
                   and self._after == o._after \
                   and self._ssh_config == o._ssh_config \
                   and self._verbosity == o._verbosity
        else:
            return False

    def __dir__(self) -> Iterable[str]:
        return ["_uid", "_label", "_owner", "_priority", "_status", "_is_preemtible",
                "_special_resources", "_cpu_treads", "_memory", "_before", "_after",
                "_ssh_config", "_verbosity"]

    def source_from_user_config(self, other_config: "QueryCommandConfig", unset_only: bool = True) -> None:
        if unset_only is False:
            self.__init__(other_config._uid, other_config._label, other_config._owner,
                          other_config._priority, other_config._status, other_config._is_preemtible,
                          other_config._special_resources, other_config._cpu_threads, other_config._memory,
                          other_config._before, other_config._after)
            super().__init__(other_config._ssh_config, other_config._verbosity)
        else:
            for attr in dir(self):
                if getattr(self, attr) is None:
                    setattr(self, attr, getattr(other_config, attr))

    def to_dict(self) -> Dict[str, object]:
        _dict: Dict[str, object] = dict()
        _dict["uid"] = self._uid
        _dict["label"] = self._label
        _dict["owner"] = self._owner
        _dict["priority"] = self._priority
        _dict["status"] = self._status
        _dict["is_preemtible"] = self._is_preemtible
        _dict["special_resources"] = self._special_resources
        _dict["cpu_threads"] = self._cpu_threads
        _dict["memory"] = self._memory
        _dict["before"] = self._before.strftime("%d/%m/%Y %H:%M:%S")
        _dict["after"] = self._after.strftime("%d/%m/%Y %H:%M:%S")
        _dict["ssh_config"] = self._ssh_config.to_dict()
        _dict["verbosity"] = self._verbosity
        return _dict

    @classmethod
    def from_dict(cls, property_dict: Dict[str, object]) -> "QueryCommandConfig":
        _uid = cls._get_str_list_from_dict(property_dict=property_dict, key="uid", mandatory=False)
        _label = cls._get_str_list_from_dict(property_dict=property_dict, key="label", mandatory=False)
        _owner = cls._get_str_list_from_dict(property_dict=property_dict, key="owner", mandatory=False)

        _property: object = cls._get_from_dict(property_dict=property_dict, key="priority")
        if not isinstance(_property, list):
            cls._raise_error_wrong_type(
                key="priority", expected_type="List[JobPriority]",
                actual_type=_property.__class__.__name__
            )
        _object_list = cast(List[object], _property)
        _job_priority_list: List[JobPriority] = []
        for _object in _object_list:
            if not isinstance(_object, int):
                cls._raise_error_wrong_type(
                    key="priority", expected_type="List[JobPriority]",
                    actual_type="List[object]"
                )
            _job_priority_list.append(JobPriority(_object))

        _property: object = cls._get_from_dict(property_dict=property_dict, key="status")
        if not isinstance(_property, list):
            cls._raise_error_wrong_type(
                key="status", expected_type="List[JobStatus]",
                actual_type=_property.__class__.__name__
            )
        _object_list = cast(List[object], _property)
        _job_status_list: List[JobStatus] = []
        for _object in _object_list:
            if not isinstance(_object, int):
                cls._raise_error_wrong_type(
                    key="status", expected_type="List[JobStatus]",
                    actual_type="List[object]"
                )
            _job_status_list.append(JobStatus(_object))

        _is_preemtible = cls._get_bool_from_dict(property_dict=property_dict, key="is_preemtible", mandatory=False)

        _property: object = cls._get_from_dict(property_dict=property_dict, key="special_resources")
        if not isinstance(_property, list):
            cls._raise_error_wrong_type(
                key="special_resources", expected_type="List[List[str]",
                actual_type=_property.__class__.__name__
            )
        _object_list = cast(List[object], _property)
        __special_resources_list: List[List[str]] = []
        for _object in _object_list:
            if not isinstance(_object, list):
                cls._raise_error_wrong_type(
                    key="special_resources", expected_type="List[List[str]]",
                    actual_type="List[object]"
                )
            __special_resources_list.append(_object)

        _property: object = cls._get_from_dict(property_dict=property_dict, key="cpu_threads")
        if not isinstance(_property, tuple):
            cls._raise_error_wrong_type(
                key="cpu_threads", expected_type="Tuple[int, int]",
                actual_type=_property.__class__.__name__
            )
        _object_tuple = cast(Tuple[int], _property)
        _cpu_threads_list: List[int] = []
        for _object in _object_tuple:
            if not isinstance(_object, int):
                cls._raise_error_wrong_type(
                    key="cpu_threads", expected_type="Tuple[int]",
                    actual_type="Tuple[object]"
                )
            _cpu_threads_list.append(cast(int, _object))
        _cpu_threads: Tuple[int, int] = tuple(_cpu_threads_list)

        _property: object = cls._get_from_dict(property_dict=property_dict, key="memory")
        if not isinstance(_property, tuple):
            cls._raise_error_wrong_type(
                key="memory", expected_type="Tuple[int, int]",
                actual_type=_property.__class__.__name__
            )
        _object_tuple = cast(Tuple[int], _property)
        _memory_list: List[int] = []
        for _object in _object_tuple:
            if not isinstance(_object, int):
                cls._raise_error_wrong_type(
                    key="memory", expected_type="Tuple[int]",
                    actual_type="Tuple[object]"
                )
            _memory_list.append(cast(int, _object))
        _memory: Tuple[int, int] = tuple(_memory_list)

        _before_string = cls._get_str_from_dict(property_dict=property_dict, key="before", mandatory=False)
        _before = datetime.strptime(_before_string, "%d/%m/%Y %H:%M:%S")

        _after_string = cls._get_str_from_dict(property_dict=property_dict, key="after", mandatory=False)
        _after = datetime.strptime(_after_string, "%d/%m/%Y %H:%M:%S")

        if "ssh_config" in property_dict:
            _ssh_config = SSHConfig.from_dict(
                cls._get_dict_from_dict(property_dict=property_dict, key="ssh_config", mandatory=False))
        else:
            _ssh_config = None

        if "verbosity" in property_dict:
            _verbosity = Verbosity(cls._get_from_dict(property_dict=property_dict, key="verbosity", mandatory=False))
        else:
            _verbosity = None

        cls._assert_all_properties_used(property_dict)
        a = QueryCommandConfig(_uid, _label, _owner, _job_priority_list, _job_status_list, _is_preemtible,
                               __special_resources_list, _cpu_threads, _memory, _before, _after, _ssh_config)
        print(a.to_dict())
        return a