import time, copy, uuid, json, re
from dataclasses import dataclass, field, fields, asdict
from enum import Enum
from typing import List, Dict, Any, Optional

class Prisma:
    RST = "\033[0m"
    RED, GRN, YEL, BLU, MAG, CYN, WHT, GRY = (
        "\033[31m",
        "\033[32m",
        "\033[33m",
        "\033[34m",
        "\033[35m",
        "\033[36m",
        "\033[97m",
        "\033[90m",
    )
    INDIGO, OCHRE, VIOLET, SLATE = (
        "\033[34;1m",
        "\033[33;2m",
        "\033[35;2m",
        "\033[30;1m",
    )
    _STRIP_PATTERN = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
    _COLOR_MAP = {
        "R": RED,
        "G": GRN,
        "Y": YEL,
        "B": BLU,
        "M": MAG,
        "C": CYN,
        "W": WHT,
        "0": GRY,
        "I": INDIGO,
        "O": OCHRE,
        "V": VIOLET,
        "S": SLATE,
    }

    @classmethod
    def paint(cls, text: str, color_key: str = "0") -> str:
        if len(color_key) == 1:
            code = cls._COLOR_MAP.get(color_key, cls.WHT)
        else:
            code = cls._COLOR_MAP.get(str(color_key)[0].upper(), cls.WHT)
        txt = str(text)
        return f"{code}{txt}" if txt.endswith(cls.RST) else f"{code}{txt}{cls.RST}"

    @classmethod
    def strip(cls, text: str) -> str:
        return cls._STRIP_PATTERN.sub("", str(text))


class LoreCategory(Enum):
    LEXICON = "LEXICON"
    SCENARIOS = "scenarios"
    GORDON = "gordon"
    GORDON_LOGS = "gordon_logs"
    GENETICS = "genetics"
    DEATH = "death"
    ALMANAC = "almanac"
    DREAMS = "dreams"


class RealityLayer:
    TERMINAL = 0
    SIMULATION = 1
    VILLAGE = 2
    DEBUG = 3
    DEEP_CX = 4


@dataclass
class ErrorLog:
    component: str
    error_msg: str
    timestamp: float = field(default_factory=time.time)
    severity: str = "WARNING"


@dataclass
class EnergyState:
    # --- VSL Somatic ---
    voltage: float = 30.0  # (V) Creative intensity
    health: float = 100.0  # (H) Structural integrity
    stamina: float = 100.0  # (P) ATP pool
    trauma: float = 0.0  # (T) Unresolved rupture

    # --- VSL Cognitive ---
    exhaustion: float = 0.2  # (E) Lexical fatigue
    contradiction: float = 0.4  # (β) Capacity to hold opposing truths
    scope: float = 0.3  # (S) Retrieval breadth
    depth: float = 0.3  # (D) Hierarchical traversal
    connectivity: float = 0.2  # (C) Logical bridging

    # --- VSL Semantic ---
    psi: float = 0.2  # (Ψ) Void / Abstraction
    chi: float = 0.2  # (Χ) Entropy / Chaos
    valence: float = 0.0  # (♥) Emotional polarity

    # --- VSL Extended (SLASH Mod) ---
    gamma: float = 0.0  # (Γ) Clarity Index
    sigma: float = 0.0  # (Σ) Synergy Score
    eta: float = 0.0  # (Η) Humanity Quotient
    theta: float = 0.0  # (Θ) Resilience (Feedback loops)
    upsilon: float = 0.0  # (Υ) Integrity

    # --- Extended/Legacy Substrate ---
    entropy: float = 0.2  # Legacy map to chi
    mass: float = 0.0
    velocity: float = 0.0
    beta_index: float = 0.4  # Legacy map to contradiction
    turbulence: float = 0.0
    kappa: float = 0.0  # (κ) Drag corollary
    epsilon: float = 0.0  # (ε) Entropy corollary
    xi: float = 0.0  # (Ξ) Substrate depth
    perfection_streak: int = 0


@dataclass
class MaterialState:
    clean_words: List[str] = field(default_factory=list)
    raw_text: str = ""
    counts: Dict[str, int] = field(default_factory=dict)
    antigens: int = 0
    vector: Dict[str, float] = field(default_factory=dict)
    truth_ratio: float = 0.0
    repetition: float = 0.0


@dataclass
class SpatialState:
    zone: str = "COURTYARD"
    manifold: str = "DEFAULT"
    narrative_drag: float = 0.6  # (F) Friction - High=stuck, Low=flow. Default 0.6
    friction: float = 0.6        # (F) VSL alias for narrative drag
    atmosphere: str = "NEUTRAL"
    flow_state: str = "LAMINAR"


@dataclass
class PhysicsPacket:
    energy: EnergyState = field(default_factory=EnergyState)
    matter: MaterialState = field(default_factory=MaterialState)
    space: SpatialState = field(default_factory=SpatialState)

    @property
    def E(self):
        return self.energy.exhaustion

    @E.setter
    def E(self, v):
        self.energy.exhaustion = v

    @property
    def beta(self):
        return self.energy.contradiction

    @beta.setter
    def beta(self, v):
        self.energy.contradiction = v
        self.energy.beta_index = v

    @property
    def S(self):
        return self.energy.scope

    @S.setter
    def S(self, v):
        self.energy.scope = v

    @property
    def D(self):
        return self.energy.depth

    @D.setter
    def D(self, v):
        self.energy.depth = v

    @property
    def C(self):
        return self.energy.connectivity

    @C.setter
    def C(self, v):
        self.energy.connectivity = v

    @property
    def V(self):
        return self.energy.voltage

    @V.setter
    def V(self, v):
        self.energy.voltage = v

    @property
    def voltage(self):
        return self.energy.voltage

    @voltage.setter
    def voltage(self, v):
        self.energy.voltage = v

    @property
    def F(self):
        return self.space.friction

    @F.setter
    def F(self, v):
        self.space.friction = v
        self.space.narrative_drag = v

    @property
    def narrative_drag(self):
        return self.space.narrative_drag

    @narrative_drag.setter
    def narrative_drag(self, v):
        self.space.narrative_drag = v
        self.space.friction = v

    @property
    def H(self):
        return self.energy.health

    @H.setter
    def H(self, v):
        self.energy.health = v

    @property
    def P(self):
        return self.energy.stamina

    @P.setter
    def P(self, v):
        self.energy.stamina = v

    @property
    def T(self):
        return self.energy.trauma

    @T.setter
    def T(self, v):
        self.energy.trauma = v

    @property
    def psi(self):
        return self.energy.psi

    @psi.setter
    def psi(self, v):
        self.energy.psi = v

    @property
    def chi(self):
        return self.energy.chi

    @chi.setter
    def chi(self, v):
        self.energy.chi = v
        self.energy.entropy = v

    @property
    def entropy(self):
        return self.energy.entropy

    @entropy.setter
    def entropy(self, v):
        self.energy.entropy = v
        self.energy.chi = v

    @property
    def valence(self):
        return self.energy.valence

    @valence.setter
    def valence(self, v):
        self.energy.valence = v

    # -- LEGACY SHORTCUTS --
    @property
    def clean_words(self):
        return self.matter.clean_words

    @clean_words.setter
    def clean_words(self, v):
        self.matter.clean_words = v

    @property
    def vector(self):
        return self.matter.vector

    @vector.setter
    def vector(self, v):
        self.matter.vector = v

    @property
    def counts(self):
        return self.matter.counts

    @counts.setter
    def counts(self, v):
        self.matter.counts = v

    @property
    def zone(self):
        return self.space.zone

    @zone.setter
    def zone(self, v):
        self.space.zone = v

    def __init__(
        self,
        energy: Optional[EnergyState] = None,
        matter: Optional[MaterialState] = None,
        space: Optional[SpatialState] = None,
        **kwargs,
    ):
        self.energy = energy or EnergyState()
        self.matter = matter or MaterialState()
        self.space = space or SpatialState()
        for k, v in kwargs.items():
            setattr(self, k, v)


    @classmethod
    def void_state(cls):
        p = cls()
        p.space.atmosphere = "VOID"
        p.space.zone = "VOID"
        p.space.flow_state = "LAMINAR"
        return p

    def snapshot(self) -> "PhysicsPacket":
        return copy.deepcopy(self)

    def to_dict(self) -> Dict[str, Any]:
        return asdict(self)

    def get(self, key, default=None):
        if hasattr(self, key):
            return getattr(self, key)
        return default

    def __getitem__(self, key):
        return getattr(self, key)

    def __setitem__(self, key, value):
        setattr(self, key, value)

    def __contains__(self, key):
        return hasattr(self, key)


@dataclass
class CycleContext:
    input_text: str
    is_system_event: bool = False
    clean_words: List[str] = field(default_factory=list)
    physics: PhysicsPacket = field(default_factory=PhysicsPacket.void_state)
    logs: List[str] = field(default_factory=list)
    flux_log: List[Dict[str, Any]] = field(default_factory=list)
    is_alive: bool = True
    refusal_triggered: bool = False
    refusal_packet: Optional[Dict] = None
    is_bureaucratic: bool = False
    bio_result: Dict = field(default_factory=dict)
    bio_snapshot: Optional[Dict] = None
    world_state: Dict = field(default_factory=dict)
    mind_state: Dict = field(default_factory=dict)
    timestamp: float = field(default_factory=time.time)
    bureau_ui: str = ""
    user_profile: Dict = field(
        default_factory=lambda: {"name": "TRAVELER", "confidence": 0}
    )
    last_impulse: Any = None
    reality_stack: Any = None
    active_lens: str = "NARRATOR"
    validator: Any = None

    @property
    def user_name(self):
        return self.user_profile.get("name", "TRAVELER")

    @user_name.setter
    def user_name(self, value):
        self.user_profile["name"] = value

    def log(self, message: str):
        self.logs.append(message)

    def record_flux(
        self, phase: str, metric: str, initial: float, final: float, reason: str = ""
    ):
        delta = final - initial
        if abs(delta) > 0.001:
            self.flux_log.append(
                {
                    "phase": phase,
                    "metric": metric,
                    "initial": initial,
                    "final": final,
                    "delta": delta,
                    "reason": reason,
                    "timestamp": time.time(),
                }
            )

    def snapshot(self) -> "CycleContext":
        new_ctx = copy.copy(self)
        for f in fields(self):
            name = f.name
            val = getattr(self, name)
            if name == "physics" and hasattr(val, "snapshot"):
                setattr(new_ctx, name, val.snapshot())
            elif isinstance(val, (list, dict, set)):
                setattr(new_ctx, name, copy.deepcopy(val))
        return new_ctx


@dataclass
class MindSystem:
    mem: Any
    lex: Any
    dreamer: Any
    mirror: Any
    tracer: Any


@dataclass
class PhysSystem:
    observer: Any
    forge: Any
    crucible: Any
    theremin: Any
    pulse: Any
    nav: Any
    gate: Optional[Any] = None
    tension: Optional[Any] = None
    dynamics: Any = None


@dataclass
class DecisionTrace:
    trace_id: str
    timestamp: float
    component: str
    decision_type: str
    inputs: Dict[str, Any]
    reasoning: str
    outcome: str

    def to_json(self):
        return json.dumps(asdict(self))


@dataclass
class DecisionCrystal:
    decision_id: str = field(default_factory=lambda: str(uuid.uuid4())[:8])
    timestamp: float = field(default_factory=time.time)
    leverage_metrics: Dict[str, float] = field(default_factory=dict)
    prompt_snapshot: str = ""
    physics_state: Dict[str, Any] = field(default_factory=dict)
    chorus_weights: Dict[str, float] = field(default_factory=dict)
    system_state: str = "STABLE"
    active_archetype: str = "OBSERVER"
    council_mandates: List[str] = field(default_factory=list)
    final_response: str = ""

    def __str__(self):
        e_val = self.leverage_metrics.get("E", 0.0)
        return (
            f"💎 CRYSTAL [{self.decision_id}] {self.system_state} | "
            f"Arch: {self.active_archetype} | E: {e_val:.2f}"
        )

    def crystallize(self) -> str:
        data = asdict(self)
        data["_summary"] = f"{self.system_state}::{self.active_archetype}"
        data["_type"] = "CRYSTAL"
        return json.dumps(data)