config.py

"""
Configuración del servicio Veureu Compliance

Centraliza todas las variables de entorno y configuración
para facilitar el despliegue y mantenimiento.
"""

import os
from typing import Optional
import logging

logger = logging.getLogger(__name__)

class ComplianceConfig:
    """Clase de configuración para el servicio de compliance"""
    
    def __init__(self):
        self.load_environment()
    
    def load_environment(self):
        """Carga todas las variables de entorno"""
        
        # === CONFIGURACIÓN GENERAL ===
        self.ENVIRONMENT = os.getenv("ENVIRONMENT", "simulation")  # simulation, staging, production
        self.LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO")
        self.API_TIMEOUT = int(os.getenv("API_TIMEOUT", "30"))
        
        # === POLYGON BLOCKCHAIN ===
        self.POLYGON_RPC_URL = os.getenv("POLYGON_RPC_URL", "https://polygon-rpc.com")
        self.POLYGON_CHAIN_ID = int(os.getenv("POLYGON_CHAIN_ID", "137"))
        self.POLYGON_PRIVATE_KEY = os.getenv("POLYGON_WALLET_PRIVATE_KEY")
        self.DIGEST_CONTRACT_ADDR = os.getenv("DIGEST_CONTRACT_ADDR")
        self.DIGEST_CONTRACT_ABI = os.getenv("DIGEST_CONTRACT_ABI", "[]")
        
        # === AWS QLDB ===
        self.AWS_ACCESS_KEY_ID = os.getenv("AWS_ACCESS_KEY_ID")
        self.AWS_SECRET_ACCESS_KEY = os.getenv("AWS_SECRET_ACCESS_KEY")
        self.AWS_REGION = os.getenv("AWS_REGION", "eu-west-1")
        self.QLDB_LEDGER_NAME = os.getenv("QLDB_LEDGER_NAME", "veureu-compliance")
        
        # === GOOGLE OAUTH ===
        self.GOOGLE_CLIENT_ID = os.getenv("GOOGLE_CLIENT_ID")
        self.GOOGLE_CLIENT_SECRET = os.getenv("GOOGLE_CLIENT_SECRET")
        self.OAUTH_REDIRECT_URI = os.getenv("OAUTH_REDIRECT_URI")
        
        # === EMAIL SMTP ===
        self.SMTP_SERVER = os.getenv("SMTP_SERVER")
        self.SMTP_PORT = int(os.getenv("SMTP_PORT", "587"))
        self.SMTP_USERNAME = os.getenv("SMTP_USERNAME")
        self.SMTP_PASSWORD = os.getenv("SMTP_PASSWORD")
        self.SMTP_USE_TLS = os.getenv("SMTP_USE_TLS", "true").lower() == "true"
        
        # === VALIDADORES ===
        self.VALIDATOR_EMAILS = os.getenv("VALIDATOR_EMAILS", "validators@veureu.cat").split(",")
        
        # === SEGURIDAD ===
        self.JWT_SECRET_KEY = os.getenv("JWT_SECRET_KEY", "your-secret-key-change-in-production")
        self.SESSION_TIMEOUT = int(os.getenv("SESSION_TIMEOUT", "3600"))  # 1 hora
        
        # === MONITOREO ===
        self.ENABLE_METRICS = os.getenv("ENABLE_METRICS", "false").lower() == "true"
        self.METRICS_PORT = int(os.getenv("METRICS_PORT", "8000"))
        
        # Log de configuración cargada
        self.log_configuration()
    
    def log_configuration(self):
        """Registra la configuración cargada (sin datos sensibles)"""
        logger.info("=== CONFIGURACIÓN CARGADA ===")
        logger.info(f"Environment: {self.ENVIRONMENT}")
        logger.info(f"Log Level: {self.LOG_LEVEL}")
        
        # Blockchain
        logger.info(f"Polygon RPC: {self.POLYGON_RPC_URL}")
        logger.info(f"Polygon Chain: {self.POLYGON_CHAIN_ID}")
        logger.info(f"Contract Address: {'Configurado' if self.DIGEST_CONTRACT_ADDR else 'No configurado'}")
        logger.info(f"Private Key: {'Configurada' if self.POLYGON_PRIVATE_KEY else 'No configurada'}")
        
        # AWS QLDB
        logger.info(f"AWS Region: {self.AWS_REGION}")
        logger.info(f"QLDB Ledger: {self.QLDB_LEDGER_NAME}")
        logger.info(f"AWS Credentials: {'Configuradas' if self.AWS_ACCESS_KEY_ID else 'No configuradas'}")
        
        # OAuth
        logger.info(f"Google OAuth: {'Configurado' if self.GOOGLE_CLIENT_ID else 'No configurado'}")
        
        # Email
        logger.info(f"SMTP Server: {self.SMTP_SERVER or 'No configurado'}")
        logger.info(f"Validadores: {len(self.VALIDATOR_EMAILS)} configurados")
        
        logger.info("=== FIN CONFIGURACIÓN ===")
    
    def is_production(self) -> bool:
        """Verifica si estamos en modo producción"""
        return self.ENVIRONMENT.lower() == "production"
    
    def is_simulation(self) -> bool:
        """Verifica si estamos en modo simulación"""
        return self.ENVIRONMENT.lower() == "simulation"
    
    def has_blockchain_config(self) -> bool:
        """Verifica si hay configuración completa de blockchain"""
        return all([
            self.POLYGON_PRIVATE_KEY,
            self.DIGEST_CONTRACT_ADDR,
            self.DIGEST_CONTRACT_ABI != "[]"
        ])
    
    def has_qldb_config(self) -> bool:
        """Verifica si hay configuración completa de QLDB"""
        return all([
            self.AWS_ACCESS_KEY_ID,
            self.AWS_SECRET_ACCESS_KEY
        ])
    
    def has_oauth_config(self) -> bool:
        """Verifica si hay configuración completa de OAuth"""
        return all([
            self.GOOGLE_CLIENT_ID,
            self.GOOGLE_CLIENT_SECRET
        ])
    
    def has_email_config(self) -> bool:
        """Verifica si hay configuración completa de email"""
        return all([
            self.SMTP_SERVER,
            self.SMTP_USERNAME,
            self.SMTP_PASSWORD
        ])
    
    def get_service_status(self) -> dict:
        """Obtiene estado de todos los servicios"""
        return {
            "environment": self.ENVIRONMENT,
            "blockchain": {
                "configured": self.has_blockchain_config(),
                "rpc_url": self.POLYGON_RPC_URL,
                "chain_id": self.POLYGON_CHAIN_ID,
                "contract": self.DIGEST_CONTRACT_ADDR is not None
            },
            "qldb": {
                "configured": self.has_qldb_config(),
                "region": self.AWS_REGION,
                "ledger": self.QLDB_LEDGER_NAME
            },
            "oauth": {
                "configured": self.has_oauth_config(),
                "client_id": self.GOOGLE_CLIENT_ID is not None
            },
            "email": {
                "configured": self.has_email_config(),
                "server": self.SMTP_SERVER,
                "validators": len(self.VALIDATOR_EMAILS)
            }
        }

# Instancia global de configuración
config = ComplianceConfig()

# Funciones helper para acceso fácil
def is_production() -> bool:
    return config.is_production()

def is_simulation() -> bool:
    return config.is_simulation()

def get_service_status() -> dict:
    return config.get_service_status()