from loguru import logger
from sqlalchemy import Column, Integer, String, Text, TIMESTAMP
from sqlalchemy.orm import sessionmaker
from sqlalchemy.exc import SQLAlchemyError

from src.ArquitectureLayer.Model import Model_base
from src.ConexionSql.Postgres_conexion import PostgresConexion
from src.Credenciales.postgres_credencial import PostgresCredencial

class LoggerDB:
    _sink_removido = False  # ← evita múltiples remove() si se crean varias instancias

    def __init__(self, credencial: PostgresCredencial, nombre_tabla: str, created_by: str = None):
        
        # 🔥 Elimina todos los sinks activos, incluso los automáticos
        logger.remove()

        self.conexion = PostgresConexion(credencial)
        self.engine = self.conexion.get_engine()
        self.Session = sessionmaker(bind=self.engine)
        self.nombre_tabla = nombre_tabla
        self.created_by = created_by

        self.modelo_logger = self._generar_modelo_logger()
        self._crear_tabla_si_no_existe()
        logger.add(self._sink, level="DEBUG")

    def _generar_modelo_logger(self):
        class LoggerTable(Model_base):
            __tablename__ = self.nombre_tabla
            __table_args__ = {'extend_existing': True}  # 👈 Esta línea evita el error

            id = Column(Integer, primary_key=True)
            nivel = Column(String, nullable=False)
            mensaje = Column(Text, nullable=False)
            fecha = Column(TIMESTAMP(timezone=True), nullable=False)
            modulo = Column(String, nullable=True)
            funcion = Column(String, nullable=True)
            linea = Column(Integer, nullable=True)
        return LoggerTable

    def _crear_tabla_si_no_existe(self):
        self.modelo_logger.__table__.create(self.engine, checkfirst=True)

    def _sink(self, message):
        record = message.record
        try:
            session = self.Session()
            log_entry = self.modelo_logger(
                nivel=record["level"].name,
                mensaje=record["message"],
                fecha=record["time"],
                modulo=record["module"],
                funcion=record["function"],
                linea=record["line"],
                sys_created_by=self.created_by
            )
            session.add(log_entry)
            session.commit()
            session.close()
        except SQLAlchemyError as e:
            print(f"[LoggerDB] Error guardando log en BD: {e}")
