from __future__ import annotations

from dataclasses import dataclass, field
from datetime import datetime
from enum import Enum
from typing import List, Optional
from Copilot.dataAcquisition.Core.CollectedData import ParameterRef, MachineRef
from Copilot.numericLayer.Core.ruleHits import TrendRuleHits

class SignalStatus(str, Enum):
    NORMAL = "normal"
    WARNING = "warning"
    CRITICAL = "critical"
    STALE = "stale"


@dataclass
class SignalInsight:
    parameter: ParameterRef
    machine: MachineRef
    value: float
    timestamp: datetime

    status: SignalStatus
    trend: TrendRuleHits   # stable | rising | falling | oscillating | insufficient_data
    rule_hits: List[str] = field(default_factory=list)

    message: Optional[str] = None

    def to_dict(self) -> dict:
        return {
            "parameter": self.parameter.to_dict(),
            "machine": self.machine.to_dict(),
            "value": self.value,
            "timestamp": self.timestamp.isoformat(),
            "status": self.status.value,
            "trend": self.trend,
            "rule_hits": self.rule_hits,
            "message": self.message,
        }

    @classmethod
    def from_dict(cls, data: dict) -> "SignalInsight":
        return cls(

            parameter=ParameterRef.from_dict(
                data["parameter"]
            ),

            machine=MachineRef.from_dict(
                data["machine"]
            ),

            value=data["value"],

            timestamp=datetime.fromisoformat(
                data["timestamp"]
            ),

            status=SignalStatus(
                data["status"]
            ),

            trend=data["trend"],

            rule_hits=data.get("rule_hits", []),

            message=data.get("message"),
        )