"""Gestión de conexiones y operaciones SQL Server."""

import pyodbc
from typing import Optional, Tuple, List
import time
from dataclasses import dataclass

from ..utils.logger import app_logger

_ODBC_DRIVER_CANDIDATES = (
    "ODBC Driver 18 for SQL Server",
    "ODBC Driver 17 for SQL Server",
    "ODBC Driver 13 for SQL Server",
    "FreeTDS",
)


def resolve_odbc_driver() -> str:
    """Devuelve el primer driver ODBC de SQL Server disponible."""
    installed = set(pyodbc.drivers())
    for name in _ODBC_DRIVER_CANDIDATES:
        if name in installed:
            return name
    raise RuntimeError(
        "No se encontró driver ODBC para SQL Server. "
        f"Instalados: {', '.join(pyodbc.drivers()) or 'ninguno'}"
    )


@dataclass
class LogicalFile:
    """Representa un archivo lógico de una base de datos."""
    logical_name: str
    physical_name: str
    type: str  # 'D' (data) o 'L' (log)


class SQLServerManager:
    """Gestor de operaciones con SQL Server."""
    
    def __init__(
        self,
        server: str,
        use_windows_auth: bool = True,
        username: Optional[str] = None,
        password: Optional[str] = None
    ):
        """
        Inicializa el gestor de SQL Server.
        
        Args:
            server: Nombre o IP del servidor SQL Server
            use_windows_auth: Usar autenticación de Windows
            username: Usuario SQL (si no usa Windows Auth)
            password: Contraseña SQL (si no usa Windows Auth)
        """
        # ODBC usa coma para el puerto (ip,puerto), no dos puntos
        self.server = server.replace(":", ",") if ":" in server else server
        self.use_windows_auth = use_windows_auth
        self.username = username
        self.password = password
    
    def get_connection_string(self, database: Optional[str] = None) -> str:
        """
        Construye la cadena de conexión.
        
        Args:
            database: Base de datos específica (opcional)
        
        Returns:
            Cadena de conexión ODBC
        """
        driver = resolve_odbc_driver()
        parts = [
            f"DRIVER={{{driver}}}",
            f"SERVER={self.server}",
        ]
        if "18" in driver:
            parts.append("TrustServerCertificate=yes")
        
        if database:
            parts.append(f"DATABASE={database}")
        
        if self.use_windows_auth:
            parts.append("Trusted_Connection=yes")
        else:
            parts.append(f"UID={self.username}")
            parts.append(f"PWD={self.password}")
        
        return ";".join(parts)
    
    @staticmethod
    def _drain_cursor(cursor) -> None:
        """Consume todos los result sets de comandos largos (RESTORE, etc.)."""
        while True:
            try:
                if cursor.description:
                    cursor.fetchall()
            except Exception:
                pass
            if not cursor.nextset():
                break

    def wait_for_database_state(
        self,
        db_name: str,
        target_state: str = "ONLINE",
        timeout_seconds: int = 300,
        poll_seconds: float = 2.0,
    ) -> Optional[str]:
        """Espera hasta que la BD alcance target_state o agote el timeout."""
        deadline = time.time() + timeout_seconds
        last_state: Optional[str] = None
        while time.time() < deadline:
            last_state = self.get_database_state(db_name)
            if last_state == target_state:
                return last_state
            if last_state is None and target_state == "ONLINE":
                # Puede tardar en aparecer en sys.databases al inicio del RESTORE.
                pass
            time.sleep(poll_seconds)
        return last_state

    def get_database_state(self, db_name: str) -> Optional[str]:
        """Devuelve state_desc de sys.databases o None si no existe."""
        try:
            conn_str = self.get_connection_string()
            conn = pyodbc.connect(conn_str, timeout=10)
            cursor = conn.cursor()
            cursor.execute(
                "SELECT state_desc FROM sys.databases WHERE name = ?",
                (db_name,),
            )
            row = cursor.fetchone()
            conn.close()
            return str(row[0]) if row else None
        except Exception as e:
            app_logger.error(f"Error consultando estado de DB [{db_name}]: {e}")
            return None

    def _prepare_database_for_restore(self, cursor, db_name: str) -> None:
        """
        Limpia una BD atascada en RESTORING u offline antes de un RESTORE nuevo.
        """
        state = self.get_database_state(db_name)
        if not state:
            return

        if state == "RESTORING":
            app_logger.warning(
                f"BD [{db_name}] en RESTORING; intentando WITH RECOVERY..."
            )
            try:
                cursor.execute(f"RESTORE DATABASE [{db_name}] WITH RECOVERY")
                self._drain_cursor(cursor)
                state = self.get_database_state(db_name)
            except Exception as e:
                app_logger.warning(f"RECOVERY falló para [{db_name}]: {e}")

        if state == "RESTORING":
            app_logger.warning(
                f"BD [{db_name}] sigue en RESTORING; eliminando con DROP DATABASE..."
            )
            cursor.execute(f"DROP DATABASE [{db_name}]")
            self._drain_cursor(cursor)
            return

        if state == "ONLINE":
            try:
                cursor.execute(
                    f"ALTER DATABASE [{db_name}] SET SINGLE_USER WITH ROLLBACK IMMEDIATE"
                )
                app_logger.info(f"BD [{db_name}] configurada en SINGLE_USER")
            except Exception as e:
                app_logger.warning(
                    f"No se pudo configurar SINGLE_USER en [{db_name}]: {e}"
                )

    def test_connection(self) -> Tuple[bool, Optional[str]]:
        """
        Prueba la conexión a SQL Server.
        
        Returns:
            Tupla (éxito, mensaje_error)
        """
        try:
            conn_str = self.get_connection_string()
            conn = pyodbc.connect(conn_str, timeout=10)
            cursor = conn.cursor()
            cursor.execute("SELECT @@VERSION")
            version = cursor.fetchone()[0]
            conn.close()
            
            app_logger.info(f"Conexión SQL Server exitosa: {version[:50]}...")
            return True, None
        except Exception as e:
            error_msg = f"Error conectando a SQL Server: {str(e)}"
            app_logger.error(error_msg)
            return False, error_msg
    
    def get_filelist_from_backup(
        self,
        backup_path: str,
        timeout_minutes: int = 5
    ) -> Tuple[List[LogicalFile], Optional[str]]:
        """
        Obtiene la lista de archivos lógicos de un backup usando RESTORE FILELISTONLY.
        
        Args:
            backup_path: Ruta al archivo .bak
            timeout_minutes: Timeout en minutos
        
        Returns:
            Tupla (lista de LogicalFile, mensaje_error)
        """
        try:
            conn_str = self.get_connection_string()
            conn = pyodbc.connect(conn_str, timeout=timeout_minutes * 60)
            cursor = conn.cursor()
            
            start_time = time.time()
            app_logger.info(f"Ejecutando RESTORE FILELISTONLY FROM DISK = '{backup_path}'")
            
            query = f"RESTORE FILELISTONLY FROM DISK = N'{backup_path}'"
            cursor.execute(query)
            
            elapsed = time.time() - start_time
            app_logger.info(f"FILELISTONLY completado en {elapsed:.2f}s")
            
            logical_files = []
            for row in cursor.fetchall():
                # Las columnas típicas son: LogicalName, PhysicalName, Type, ...
                logical_name = row.LogicalName
                physical_name = row.PhysicalName
                file_type = row.Type
                
                logical_files.append(LogicalFile(
                    logical_name=logical_name,
                    physical_name=physical_name,
                    type=file_type
                ))
                
                app_logger.debug(
                    f"Archivo lógico: {logical_name} ({file_type}) -> {physical_name}"
                )
            
            conn.close()
            
            if not logical_files:
                return [], "No se encontraron archivos lógicos en el backup"
            
            return logical_files, None
            
        except Exception as e:
            error_msg = f"Error obteniendo FILELISTONLY: {str(e)}"
            app_logger.error(error_msg)
            return [], error_msg
    
    def restore_database(
        self,
        db_name: str,
        backup_path: str,
        data_folder: str,
        logical_files: List[LogicalFile],
        timeout_minutes: int = 60,
        dry_run: bool = False
    ) -> Tuple[bool, Optional[str], Optional[str]]:
        """
        Restaura una base de datos desde un backup.
        
        Args:
            db_name: Nombre de la base de datos
            backup_path: Ruta al archivo .bak
            data_folder: Carpeta donde se crearán los archivos de datos
            logical_files: Lista de archivos lógicos del backup
            timeout_minutes: Timeout en minutos
            dry_run: Si True, solo simula (no ejecuta RESTORE)
        
        Returns:
            Tupla (éxito, stdout, error)
        """
        conn = None
        try:
            # Construir las cláusulas MOVE con un destino único por archivo lógico.
            # Renombrar todos los data files a {db}.mdf colisiona si el backup tiene
            # varios archivos; aquí cada archivo recibe un nombre distinto (G4).
            move_clauses = self._build_move_clauses(db_name, data_folder, logical_files)
            if not move_clauses:
                return False, None, "No se pudieron determinar los archivos del backup"

            restore_query = (
                f"RESTORE DATABASE [{db_name}] FROM DISK = N'{backup_path}' "
                f"WITH {', '.join(move_clauses)}, REPLACE"
            )

            app_logger.info(f"Comando RESTORE generado:\n{restore_query}")

            if dry_run:
                app_logger.info("Modo DRY RUN: No se ejecutará el RESTORE")
                return True, restore_query, None

            # Ejecutar RESTORE
            conn_str = self.get_connection_string()
            conn = pyodbc.connect(conn_str, timeout=timeout_minutes * 60)
            conn.autocommit = True  # Necesario para ALTER DATABASE
            cursor = conn.cursor()

            start_time = time.time()
            app_logger.info(f"Ejecutando RESTORE DATABASE [{db_name}]...")

            output_lines = []
            restore_error: Optional[str] = None

            try:
                # 1. Limpiar BD atascada o poner SINGLE_USER si ya existe ONLINE
                self._prepare_database_for_restore(cursor, db_name)

                # 2. RESTORE (RECOVERY es el default; drenar result sets hasta completar)
                cursor.execute(restore_query)
                self._drain_cursor(cursor)
                output_lines.append("RESTORE DATABASE ejecutado")

                # Esperar a que SQL Server termine (evita borrar el .bak demasiado pronto)
                waited_state = self.wait_for_database_state(
                    db_name,
                    target_state="ONLINE",
                    timeout_seconds=timeout_minutes * 60,
                )
                if waited_state != "ONLINE":
                    restore_error = (
                        f"BD [{db_name}] no alcanzó ONLINE tras RESTORE "
                        f"(estado: {waited_state})"
                    )
                    app_logger.error(restore_error)
            except Exception as e:
                restore_error = str(e)
                app_logger.error(f"RESTORE DATABASE falló para [{db_name}]: {e}")
            finally:
                # 3. MULTI_USER solo si la BD quedó ONLINE (G7)
                final_state = self.get_database_state(db_name)
                if final_state == "ONLINE":
                    try:
                        cursor.execute(f"ALTER DATABASE [{db_name}] SET MULTI_USER")
                        output_lines.append("Base de datos configurada en modo MULTI_USER")
                    except Exception as e:
                        restore_error = restore_error or (
                            f"No se pudo volver a MULTI_USER en [{db_name}]: {e}"
                        )
                        app_logger.error(restore_error)
                elif final_state:
                    msg = (
                        f"BD [{db_name}] quedó en estado {final_state} tras RESTORE"
                    )
                    restore_error = restore_error or msg
                    app_logger.error(msg)

            elapsed = time.time() - start_time
            output_lines.append(f"Restauración finalizada en {elapsed:.2f}s")

            output = "\n".join(output_lines)
            app_logger.info(output)

            if restore_error or self.get_database_state(db_name) != "ONLINE":
                state = self.get_database_state(db_name)
                err = restore_error or f"BD [{db_name}] no quedó ONLINE (estado: {state})"
                return False, output, err

            return True, output, None

        except Exception as e:
            error_msg = f"Error restaurando base de datos: {str(e)}"
            app_logger.error(error_msg)
            return False, None, error_msg
        finally:
            if conn is not None:
                try:
                    conn.close()
                except Exception:
                    app_logger.warning("No se pudo cerrar la conexión SQL tras el RESTORE")

    @staticmethod
    def _build_move_clauses(db_name, data_folder, logical_files) -> list:
        """
        Genera una cláusula MOVE por archivo lógico con destino único, evitando
        colisiones cuando el backup tiene múltiples data files o logs (G4):
          - 1er data → {db}.mdf, siguientes → {db}_N.ndf
          - 1er log  → {db}_log.ldf, siguientes → {db}_log_N.ldf
          - otros tipos (FILESTREAM/full-text) → {db}_{nombre_lógico_saneado}
        """
        clauses = []
        data_idx = 0
        log_idx = 0
        for lf in logical_files:
            if lf.type == 'D':
                suffix = "" if data_idx == 0 else f"_{data_idx}"
                ext = "mdf" if data_idx == 0 else "ndf"
                new_path = f"{data_folder}\\{db_name}{suffix}.{ext}"
                data_idx += 1
            elif lf.type == 'L':
                suffix = "" if log_idx == 0 else f"_{log_idx}"
                new_path = f"{data_folder}\\{db_name}_log{suffix}.ldf"
                log_idx += 1
            else:
                # No descartar otros tipos: moverlos preservando el nombre lógico.
                safe = "".join(c if c.isalnum() else "_" for c in lf.logical_name)
                new_path = f"{data_folder}\\{db_name}_{safe}"

            clauses.append(f"MOVE N'{lf.logical_name}' TO N'{new_path}'")
        return clauses
    
    def database_exists(self, db_name: str) -> bool:
        """
        Verifica si una base de datos existe.
        
        Args:
            db_name: Nombre de la base de datos
        
        Returns:
            True si existe
        """
        try:
            conn_str = self.get_connection_string()
            conn = pyodbc.connect(conn_str, timeout=10)
            cursor = conn.cursor()
            
            cursor.execute(
                "SELECT COUNT(*) FROM sys.databases WHERE name = ?",
                (db_name,)
            )
            exists = cursor.fetchone()[0] > 0
            
            conn.close()
            return exists
            
        except Exception as e:
            app_logger.error(f"Error verificando existencia de DB: {e}")
            return False