# app/runtime/subscribers/ui_subscriber.py

from Copilot.dataAcquisition.Core.BaseSubscriber import BaseSubscriber
from Copilot.dataAcquisition.Core.CollectedData import CollectedData
from models.factory_structure_model import Parameter
from Copilot.numericLayer.Analyzers.primeryNumericalAnalyzer import primeryNumericalAnalyzer
from Copilot.SituationLayer.Analyzers.machineSituationManager import SituationManager
from Copilot.numericLayer.Core.SignalInsight import SignalStatus
from Copilot.SituationLayer.Core.situationWorker import SituationWorker
from Copilot.SituationLayer.Core.Incident import IncidentRef, IncidentSeverity
from Copilot.dataAcquisition.Core.eventBus import EventBus
from Copilot.numericLayer.Filters.Rule.ruleFilters import ConsecutiveRuleFilter, CooldownFilter
from Copilot.numericLayer.Filters.Rule.rulePipelineFilters import RuleFilterPipeline
from Copilot.numericLayer.Analyzers.signalStatusResolver import SignalStatusResolver


class AnalyzeParmValueHandler(BaseSubscriber):

    def __init__(self, incident_bus:EventBus):

        super().__init__()
        self.incident_bus = incident_bus
        self.numerical_analyzer = primeryNumericalAnalyzer()
        self.signal_status_resolver = SignalStatusResolver()
        self.situation_manager = SituationManager()
        self.situation_worker = SituationWorker(
                                    situation_manager=self.situation_manager,
                                    interval_seconds=1.0,
                                    on_incidents=self.handle_incidents
                                )

        self.situation_worker.start()
        
        self.rule_filter_pipeline = RuleFilterPipeline([
                                                    ConsecutiveRuleFilter(min_occurrences=3),
                                                    CooldownFilter(cooldown_seconds=5),
                                                ])

    def stop(self):
        res = super().stop()
        self.situation_worker.stop()
        return res

    def handle(self, event:CollectedData):

        signal_insight = self.numerical_analyzer.process(event)
        signal_insight = self.signal_status_resolver.apply(signal_insight)
        
        self.situation_manager.add_to_history(signal_insight)

        # filter rules
        signal_insight = self.rule_filter_pipeline.apply(signal_insight)
        signal_insight = self.signal_status_resolver.apply(signal_insight)


        should_emit = True

        if should_emit and signal_insight.status != SignalStatus.NORMAL:
            print(signal_insight.parameter.tag)
            print(signal_insight.value)
            print(signal_insight.status)
            print(signal_insight.rule_hits)
            print('----------------------')


        if should_emit:
            self.situation_manager.process(signal_insight)
        
        

    
    def handle_incidents(self, incidents:list[IncidentRef]):
        for incident in incidents:

            if incident.severity == IncidentSeverity.LOW:
                continue
            
            print("INCIDENT:", incident.incident_type)
            print(incident.severity)
            print(incident.summary)
            print("acitve signals:")
            for signal in incident.active_signals:
                print(signal.parameter.tag, ": ", signal.status, "-", signal.rule_hits)

            print('TRigger:')
            print(incident.trigger_rules)
            print('parm:',incident.trigger_parameter.tag)
            print("--------------------")
            print("--------------------")
            print("--------------------")

            
            self.incident_bus.emit(incident)