"""
Analizador en tiempo real - MVP v1.0

Procesa mediciones en tiempo real para detección de desvíos
"""

import logging
import time
from datetime import datetime
from ..base import BaseProcessor
from ...config.constants import (
    REALTIME_BATCH_SIZE,
    REALTIME_SLEEP,
    CONFIG_UPDATE_INTERVAL
)
from .deviation import DeviationAnalyzer

logger = logging.getLogger(__name__)

class RealtimeAnalyzer(BaseProcessor):
    def __init__(self, db_name):
        super().__init__(db_name)
        self.deviation_analyzer = DeviationAnalyzer()
        self.batch_size = REALTIME_BATCH_SIZE
        self.last_config_update = None
        self.config_update_interval = CONFIG_UPDATE_INTERVAL
        self.metrics = {
            'processed_measurements': 0,
            'detected_deviations': 0,
            'generated_alarms': 0
        }
        logger.info("RealtimeAnalyzer inicializado")

    def run(self):
        """Ejecuta el procesamiento en tiempo real"""
        while self.running:
            try:
                if not self.check_connection():
                    time.sleep(5)
                    continue

                # Actualizar configuraciones si es necesario
                self._update_configurations()

                # Obtener mediciones no analizadas con FOR UPDATE SKIP LOCKED
                success, measurements = self.execute_query("""
                    SELECT 
                        bb.id,
                        bb.dmac,
                        bb.temp,
                        bb.fecha,
                        m.idSistema,
                        e.idEntrada 
                    FROM bandeja_blue bb
                    JOIN modbus m ON bb.dmac = m.dmac
                    JOIN entradas e ON m.idModbus = e.idModbus
                    WHERE bb.analizado_el IS NULL
                    ORDER BY bb.fecha
                    LIMIT %s
                    FOR UPDATE SKIP LOCKED
                """, (self.batch_size,))

                if not success:
                    logger.error(f"Error obteniendo mediciones: {measurements}")
                    time.sleep(5)
                    continue

                if not measurements:
                    time.sleep(REALTIME_SLEEP)
                    continue

                # Procesar mediciones
                processed_ids = []
                for measurement in measurements:
                    try:
                        if self._process_measurement(measurement):
                            processed_ids.append(measurement['id'])
                    except Exception as e:
                        logger.error(f"Error procesando medición {measurement['id']}: {str(e)}")
                        continue

                # Marcar como analizadas
                if processed_ids:
                    self._mark_as_analyzed(processed_ids)

            except Exception as e:
                logger.error(f"Error en procesamiento tiempo real: {str(e)}")
                time.sleep(5)

    def _process_measurement(self, measurement):
        """Procesa una medición individual"""
        if self.debug:
            logger.debug(
                f"Procesando medición: DMAC={measurement['dmac']}, "
                f"Valor={measurement['temp']}°C"
            )

        # Analizar desvíos
        result = self.deviation_analyzer.analyze(
            measurement['idSistema'],
            measurement['idEntrada'],
            measurement['temp'],
            measurement['fecha']
        )

        if result.get('deviation_detected'):
            self.metrics['detected_deviations'] += 1
            if result.get('alarm_generated'):
                self.metrics['generated_alarms'] += 1

        self.metrics['processed_measurements'] += 1
        return True

    def _mark_as_analyzed(self, ids):
        """Marca un conjunto de mediciones como analizadas"""
        if not ids:
            return

        placeholders = ', '.join(['%s'] * len(ids))
        success, result = self.execute_query(
            f"""
            UPDATE bandeja_blue 
            SET analizado_el = %s 
            WHERE id IN ({placeholders})
            """,
            [datetime.now()] + ids,
            commit=True
        )

        if success and self.debug:
            logger.debug(f"Marcadas {len(ids)} mediciones como analizadas")

    def _update_configurations(self):
        """Actualiza las configuraciones si es necesario"""
        now = datetime.now()
        if (self.last_config_update is None or 
            (now - self.last_config_update).total_seconds() > self.config_update_interval):
            
            self.deviation_analyzer.update_configurations(self.conn)
            self.last_config_update = now
            if self.debug:
                logger.debug("Configuraciones actualizadas")

    def get_metrics(self):
        """Obtiene métricas del procesador"""
        metrics = self.metrics.copy()
        metrics.update(self.deviation_analyzer.get_metrics())
        return metrics

    def toggle_debug(self):
        """Cambia el modo debug"""
        super().toggle_debug()
        self.deviation_analyzer.debug = self.debug