# -*- coding: utf-8 -*-
# coding: utf-8
"""
Estructura de modelo de conexion a una BBDD
"""

# -----------------------------------------------------------------------
# Imports
# -----------------------------------------------------------------------
from abc import ABC, abstractmethod


class AbstractBBDD(ABC):

    def __init__(self, config: dict, as_dict: bool = False):
        """
            Constructor de la clase de conexion a SQLServer.

            Args:
                config (dict): Diccionario de configuracion. Debe contener el "host" y la "database" al que conectar.
                as_dict (:obj:`bool`, optional): Indicar si los resultados del cursor deben devolverse en list o dict.
                    Su valor por defecto es False.

            Returns:
                AbstractBBDD: nuevo objeto clase SqlServerTCK.

        """
        self.__config = config
        self.__as_dict = as_dict
        super().__init__()

    @classmethod
    @abstractmethod
    def load_from_file(cls, path_config: str):
        """
            Funcion para cargar la clase con los valores necesarios desde un fichero de config

            Args:
                path_config (str): Valor a parsear para convertirlo a formato SQLServer

            Returns:
                AbstractBBDD: Devuelve el constructor de la clase
        """
        raise NotImplementedError()

    @classmethod
    @abstractmethod
    def load_from_dict(cls, config: dict):
        """
            Funcion para cargar la clase con los valores necesarios desde un dict

            Args:
                config (dict): Valor a parsear para convertirlo a formato SQLServer

            Returns:
                AbstractBBDD: Devuelve el constructor de la clase
        """
        raise NotImplementedError()

    @abstractmethod
    def config(self):
        """
            Obtener la configuracion usada para conectar a la BBDD

            Returns:
                config (dict): Devuelve un diccionario de Python con toda la configuración
        """
        return self.__config

    @staticmethod
    def __parser(value) -> str:
        """
            Parsea una variable/valor de Python para introducirlo dentro de una query de SQLServer

            Args:
                value (Any): Valor a parsear para convertirlo a formato SQLServer

            Returns:
                str: Valor resultante parseado
        """
        if value is None:
            return u"NULL"
        elif type(value) is int:
            return u"'" + (u"{0}".format(value)).replace("'", "''") + u"'"
        elif type(value) is bool:
            return u"{0}".format("1" if value else "0")
        else:
            return u"'" + (u"{0}".format(value).replace("'", "''")) + u"'"

    @abstractmethod
    def run_query(self, sql_query: str):
        """
            Ejecutar una query en SQLServer devolviendo los resultados como lista de tuplas (o de diccionarios,
            dependiendo de si se ha indicado el parametro as_dict en el constructor)

            Args:
                sql_query (str): Query a ejecutar

            Returns:
                (:obj:`list`, :obj:`dict`): Valores devueltos por la query. Si no hay valores que devolver,
                    se devuelve una lista vacia
        """
        raise NotImplementedError()

    @abstractmethod
    def exec_procedure(self, procedure, params={}, db=None):
        """
            Ejecutar un procedimiento almacenado

            Args:
                procedure (str): Nombre del procedure (solo el nombre, sin incluir schema, db...)
                params (dict): Diccionario con los parametros a incluir en la ejecucion del procedure.
                    Las claves deben coincidir exactamente con el nombre de los parametros del procedure
                db (str): La Base de Datos donde se encuentra el procedure. Si no se indica,
                    se coge la pasada en el constructor

            Returns:
                (:obj:`list`, :obj:`dict`): Valores devueltos por la query. Si no hay valores que devolver,
                    se devuelve una lista vacia
        """
        raise NotImplementedError()

    @abstractmethod
    def insert_tuples(self, headers, elements, table, db=None):
        """
            Insertar una lista de tuplas en una tabla

            Args:
                headers (list): Lista de nombres de las columnas de la tabla.
                    Es importante que se respete el orden respecto a elements
                elements (list[Tuple]): La lista de tuplas (o lista de listas) a insertar.
                    Es importante que se respete el orden respecto a headers
                table (str): Nombre de la tabla donde insertar (solo el nombre, sin incluir schema, db...)
                db (str): La Base de Datos donde se encuentra el procedure.
                    Si no se indica, se coge la pasada en el constructor

            Returns:
                int: Numero de filas insertadas satisfactoriamente
        """
        raise NotImplementedError()

    @abstractmethod
    def insert_dicts(self, dicts, table, db=None):
        """
            Insertar una lista de tuplas en una tabla

            Args:
                dicts (list[dict]): La lista de tuplas (o lista de listas) a insertar.
                    Es importante que se respete el orden respecto a headers
                table (str): Nombre de la tabla donde insertar (solo el nombre, sin incluir schema, db...)
                db (str): La Base de Datos donde se encuentra el procedure.
                    Si no se indica, se coge la pasada en el constructor

            Returns:
                int: Numero de filas insertadas satisfactoriamente
        """
        raise NotImplementedError()