from abc import ABC
from abc import abstractmethod


class Connection(ABC):
    """The connection class is used as a base for specific connections.

    Attributes:
        conn_obj (dict)
        connection (any, optional)

    """

    def __init__(self, conn_obj):
        self._conn_obj = conn_obj
        self._connection = None

    @property
    def connection(self):
        return self._connection

    @connection.setter
    def connection(self, value):
        self._connection = value

    @property
    def conn_obj(self):
        return self._conn_obj

    @conn_obj.setter
    def conn_obj(self, value):
        self._conn_obj = value

    @abstractmethod
    def login(self):
        pass

    @abstractmethod
    def transfer_files(self, file_list, transfer_mode='upload',
                       batch_file_id=None, pid=None, overwrite=None,
                       check_delivered_files=True, d_job=None):
        pass

    @abstractmethod
    def mkdir(self, dest_dir):
        pass

    @abstractmethod
    def is_dir(self, dirname):
        pass

    @abstractmethod
    def file_exists(self, file_name):
        pass

    @abstractmethod
    def file_size(self, file_name):
        pass

    @abstractmethod
    def delete(self, filename, remove_dir=False):
        pass

    @abstractmethod
    def rmdir(self, dir_name):
        pass

    @abstractmethod
    def scan_dir(self, directory, exceptions=[]):
        pass

    @abstractmethod
    def reconnect(self):
        pass

    @abstractmethod
    def check_connection(self, remote_initial_dir):
        pass

    @abstractmethod
    def close_connection(self):
        pass

    def replace_backslashes(self, value):
        value = value.replace('\\', '/')
        return value

    def get_bucket(self):
        bucket = self.conn_obj['domain_name']

        self.replace_backslashes(bucket)

        bucket = bucket.strip('/')

        parts = bucket.split('/')

        return parts[0]

    @staticmethod
    def handle_exceptions(handler):
        """Make sure exceptions dont keep the connection open.

        Args:
            handler: function to safely wrap exceptions.
        Returns:
            function: wrapped function.
        """
        def exception_handler(self, *args, **kwargs):
            """Function to wrap exceptions around.

            Args:
                *args: passed to wrapped function
                **kwargs: passed to wrapped function

            Returns:
                any: wrapped handler return value.
            """
            try:
                return handler(self, *args, **kwargs)
            except Exception as e:
                self.close_connection()
                raise e

        return exception_handler