# Archivo: RulesGlobalSQL.py
# Ruta: Consultas_SQL\Utilities\RulesGlobalSQL.py
# Descripción: Consultas SQL para el módulo de Reglas Globales (RulesGlobal)
# Autor: Equipo de Desarrollo IGSA
# Fecha: 2025

"""
Módulo de consultas SQL para Reglas Globales (RulesGlobal).

Este módulo maneja todas las consultas relacionadas con:
- Obtención de reglas por módulo
- Obtención de reglas específicas por código
- Validación de existencia de reglas
"""

from Consultas_SQL.conexion import get_connection
import pyodbc

class RulesGlobalSQL:
    """
    Clase que contiene todas las consultas SQL para el módulo de Reglas Globales.
    Todos los métodos son estáticos para facilitar su uso sin necesidad de instanciar la clase.
    """
    
    @staticmethod
    def obtener_reglas_por_modulo(module_id):
        """
        Obtiene todas las reglas activas de un módulo específico.
        
        Args:
            module_id (str): ID del módulo (ej: 'FR_FlightRequest')
            
        Returns:
            dict: {
                'success': bool,
                'reglas': list de dict con las reglas (si existe),
                'error': str con mensaje de error (si falla)
            }
        """
        try:
            conn = get_connection()
            cursor = conn.cursor()
            
            query = """
                SELECT 
                    RuleCode,
                    ModuleID,
                    RuleName,
                    RuleDescription,
                    ComparisonOperator,
                    ValueType,
                    RuleValue,
                    RuleValue2,
                    RuleUnit,
                    MessageIfViolated,
                    IsActive
                FROM RulesGlobal
                WHERE ModuleID = ?
                  AND IsActive = 1
                ORDER BY RuleCode
            """
            
            cursor.execute(query, (module_id,))
            resultados = cursor.fetchall()
            
            cursor.close()
            conn.close()
            
            # Convertir resultados a lista de diccionarios
            reglas = []
            for row in resultados:
                reglas.append({
                    'RuleCode': row[0],
                    'ModuleID': row[1],
                    'RuleName': row[2],
                    'RuleDescription': row[3],
                    'ComparisonOperator': row[4],
                    'ValueType': row[5],
                    'RuleValue': row[6],
                    'RuleValue2': row[7],
                    'RuleUnit': row[8],
                    'MessageIfViolated': row[9],
                    'IsActive': row[10]
                })
            
            return {
                'success': True,
                'reglas': reglas,
                'error': None
            }
            
        except pyodbc.Error as e:
            return {
                'success': False,
                'reglas': [],
                'error': f'Error al obtener reglas del módulo: {str(e)}'
            }
        except Exception as e:
            return {
                'success': False,
                'reglas': [],
                'error': f'Error inesperado: {str(e)}'
            }
    
    @staticmethod
    def obtener_regla_por_codigo(rule_code):
        """
        Obtiene una regla específica por su código.
        
        Args:
            rule_code (str): Código de la regla (ej: 'KM_MIN')
            
        Returns:
            dict: {
                'success': bool,
                'regla': dict con información de la regla (si existe),
                'error': str con mensaje de error (si falla)
            }
        """
        try:
            conn = get_connection()
            cursor = conn.cursor()
            
            query = """
                SELECT 
                    RuleCode,
                    ModuleID,
                    RuleName,
                    RuleDescription,
                    ComparisonOperator,
                    ValueType,
                    RuleValue,
                    RuleValue2,
                    RuleUnit,
                    MessageIfViolated,
                    IsActive
                FROM RulesGlobal
                WHERE RuleCode = ?
                  AND IsActive = 1
            """
            
            cursor.execute(query, (rule_code,))
            resultado = cursor.fetchone()
            
            cursor.close()
            conn.close()
            
            if resultado:
                return {
                    'success': True,
                    'regla': {
                        'RuleCode': resultado[0],
                        'ModuleID': resultado[1],
                        'RuleName': resultado[2],
                        'RuleDescription': resultado[3],
                        'ComparisonOperator': resultado[4],
                        'ValueType': resultado[5],
                        'RuleValue': resultado[6],
                        'RuleValue2': resultado[7],
                        'RuleUnit': resultado[8],
                        'MessageIfViolated': resultado[9],
                        'IsActive': resultado[10]
                    },
                    'error': None
                }
            else:
                return {
                    'success': False,
                    'regla': None,
                    'error': f'Regla "{rule_code}" no encontrada o inactiva'
                }
                
        except pyodbc.Error as e:
            return {
                'success': False,
                'regla': None,
                'error': f'Error al obtener regla: {str(e)}'
            }
        except Exception as e:
            return {
                'success': False,
                'regla': None,
                'error': f'Error inesperado: {str(e)}'
            }
    
    @staticmethod
    def verificar_existencia_regla(rule_code):
        """
        Verifica si una regla existe y está activa.
        
        Args:
            rule_code (str): Código de la regla
            
        Returns:
            dict: {
                'success': bool,
                'existe': bool,
                'error': str (si falla)
            }
        """
        try:
            conn = get_connection()
            cursor = conn.cursor()
            
            query = """
                SELECT COUNT(*) AS Total
                FROM RulesGlobal
                WHERE RuleCode = ?
                  AND IsActive = 1
            """
            
            cursor.execute(query, (rule_code,))
            resultado = cursor.fetchone()
            
            cursor.close()
            conn.close()
            
            existe = resultado[0] > 0
            
            return {
                'success': True,
                'existe': existe,
                'error': None
            }
            
        except pyodbc.Error as e:
            return {
                'success': False,
                'existe': False,
                'error': f'Error al verificar existencia de regla: {str(e)}'
            }
        except Exception as e:
            return {
                'success': False,
                'existe': False,
                'error': f'Error inesperado: {str(e)}'
            }
    
    @staticmethod
    def obtener_todas_reglas_activas():
        """
        Obtiene todas las reglas activas del sistema.
        Útil para debugging o administración.
        
        Returns:
            dict: {
                'success': bool,
                'reglas': list de dict con todas las reglas,
                'total': int cantidad de reglas,
                'error': str (si falla)
            }
        """
        try:
            conn = get_connection()
            cursor = conn.cursor()
            
            query = """
                SELECT 
                    RuleCode,
                    ModuleID,
                    RuleName,
                    RuleDescription,
                    ComparisonOperator,
                    ValueType,
                    RuleValue,
                    RuleValue2,
                    RuleUnit,
                    MessageIfViolated,
                    IsActive
                FROM RulesGlobal
                WHERE IsActive = 1
                ORDER BY ModuleID, RuleCode
            """
            
            cursor.execute(query)
            resultados = cursor.fetchall()
            
            cursor.close()
            conn.close()
            
            reglas = []
            for row in resultados:
                reglas.append({
                    'RuleCode': row[0],
                    'ModuleID': row[1],
                    'RuleName': row[2],
                    'RuleDescription': row[3],
                    'ComparisonOperator': row[4],
                    'ValueType': row[5],
                    'RuleValue': row[6],
                    'RuleValue2': row[7],
                    'RuleUnit': row[8],
                    'MessageIfViolated': row[9],
                    'IsActive': row[10]
                })
            
            return {
                'success': True,
                'reglas': reglas,
                'total': len(reglas),
                'error': None
            }
            
        except pyodbc.Error as e:
            return {
                'success': False,
                'reglas': [],
                'total': 0,
                'error': f'Error al obtener reglas: {str(e)}'
            }
        except Exception as e:
            return {
                'success': False,
                'reglas': [],
                'total': 0,
                'error': f'Error inesperado: {str(e)}'
            }