# models.py - Modelos completos para SQL Server
from flask_sqlalchemy import SQLAlchemy
from datetime import datetime
from werkzeug.security import generate_password_hash, check_password_hash
from flask_login import UserMixin

db = SQLAlchemy()

class Cliente(db.Model):
    __tablename__ = 'Clientes'
    
    ClienteID = db.Column(db.Integer, primary_key=True, autoincrement=True)
    NIT = db.Column(db.String(20), nullable=False)  # ← Quitar unique=True
    RazonSocial = db.Column(db.String(200), nullable=False)
    NombreComercial = db.Column(db.String(200), nullable=False)
    EstadoActivo = db.Column(db.Boolean, nullable=False, default=True)
    FechaVencimientoCertificado = db.Column(db.Date, nullable=True)
    FechaCreacion = db.Column(db.DateTime, default=datetime.utcnow)
    FechaModificacion = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    UsuarioModificacion = db.Column(db.String(100))
    Observaciones = db.Column(db.String(500))
    TokenUser = db.Column(db.String(200), nullable=True)
    TokenPassword = db.Column(db.String(200), nullable=True)
    
    def to_dict(self):
        return {
            'ClienteID': self.ClienteID,
            'NIT': self.NIT,
            'RazonSocial': self.RazonSocial,
            'NombreComercial': self.NombreComercial,
            'EstadoActivo': self.EstadoActivo,
            'Estado': 'ACTIVO' if self.EstadoActivo else 'BLOQUEADO',
            'FechaVencimientoCertificado': self.FechaVencimientoCertificado.strftime('%Y-%m-%d') if self.FechaVencimientoCertificado else None,
            'FechaCreacion': self.FechaCreacion.strftime('%Y-%m-%d %H:%M:%S') if self.FechaCreacion else None,
            'FechaModificacion': self.FechaModificacion.strftime('%Y-%m-%d %H:%M:%S') if self.FechaModificacion else None,
            'UsuarioModificacion': self.UsuarioModificacion,
            'Observaciones': self.Observaciones,
            'TokenUser': self.TokenUser,
            'TokenPassword': self.TokenPassword,
            # Campos calculados para mejor visualización
            'DiasParaVencimiento': self._calcular_dias_vencimiento(),
            'EstadoCertificado': self._estado_certificado()
        }
    
    def _calcular_dias_vencimiento(self):
        """Calcular días hasta el vencimiento del certificado"""
        if not self.FechaVencimientoCertificado:
            return None
        
        from datetime import date
        hoy = date.today()
        diferencia = (self.FechaVencimientoCertificado - hoy).days
        return diferencia
    
    def _estado_certificado(self):
        """Determinar el estado del certificado basado en la fecha de vencimiento"""
        dias = self._calcular_dias_vencimiento()
        
        if dias is None:
            return 'SIN_FECHA'
        elif dias < 0:
            return 'VENCIDO'
        elif dias <= 30:
            return 'POR_VENCER'
        else:
            return 'VIGENTE'
    
    @classmethod
    def buscar_por_datos(cls, nit=None, razon_social=None, nombre_comercial=None):
        """Buscar cliente por NIT, Razón Social o Nombre Comercial"""
        query = cls.query
        
        if nit:
            query = query.filter(cls.NIT == nit)
        if razon_social:
            query = query.filter(cls.RazonSocial.like(f'%{razon_social}%'))
        if nombre_comercial:
            query = query.filter(cls.NombreComercial.like(f'%{nombre_comercial}%'))
            
        return query.all()
    
    def __repr__(self):
        return f'<Cliente {self.NIT}: {self.RazonSocial}>'
    
    __table_args__ = (
        db.UniqueConstraint('NIT', 'NombreComercial', name='uq_nit_nombre_comercial'),
    )

class Usuario(UserMixin, db.Model):
    __tablename__ = 'Usuarios'
    
    UsuarioID = db.Column(db.Integer, primary_key=True, autoincrement=True)
    Username = db.Column(db.String(50), nullable=False, unique=True)
    Password = db.Column(db.String(255), nullable=False)
    NombreCompleto = db.Column(db.String(200), nullable=False)
    Email = db.Column(db.String(100))
    Activo = db.Column(db.Boolean, nullable=False, default=True)
    FechaCreacion = db.Column(db.DateTime, default=datetime.utcnow)
    UltimoAcceso = db.Column(db.DateTime)
    Rol = db.Column(db.String(50), default='Usuario')
    
    def set_password(self, password):
        """Establecer contraseña con hash"""
        self.Password = generate_password_hash(password)
    
    def check_password(self, password):
        """Verificar contraseña"""
        return check_password_hash(self.Password, password)
    
    def get_id(self):
        """Requerido por Flask-Login"""
        return str(self.UsuarioID)
    
    def to_dict(self):
        return {
            'UsuarioID': self.UsuarioID,
            'Username': self.Username,
            'NombreCompleto': self.NombreCompleto,
            'Email': self.Email,
            'Activo': self.Activo,
            'FechaCreacion': self.FechaCreacion.strftime('%Y-%m-%d %H:%M:%S') if self.FechaCreacion else None,
            'UltimoAcceso': self.UltimoAcceso.strftime('%Y-%m-%d %H:%M:%S') if self.UltimoAcceso else None,
            'Rol': self.Rol
        }
    
    def __repr__(self):
        return f'<Usuario {self.Username}: {self.NombreCompleto}>'