/**
 * Ladder Logic Engine
 * Evaluates rungs in a scan cycle:
 * 1. Read all inputs
 * 2. Evaluate rungs top-to-bottom, left-to-right
 * 3. Update all outputs
 */

import type {
  Contact,
  Coil,
  Timer,
  Counter,
  LogicGate,
  Rung,
  RungElement,
  ComparisonCondition,
  Program,
  EngineState,
  Input,
  Output,
  MemoryBit,
  ContactType,
  CoilType,
  TimerType,
  CounterType,
  GateType,
  ComparisonOp,
  Branch,
  MathElement,
  MathOperator,
  OneShot,
  MoveElement,
  ScaleElement,
  NoOp,
  CompareElement,
  EdgeType,
} from './types';
import {
  LadderError,
  InvalidMemoryAccessError,
  MathOperationError,
} from './errors';

export class LadderEngine {
  state: EngineState;
  private program: Program | null = null;
  private listeners: Set<() => void> = new Set();
  private lastRungStates: Map<string, boolean> = new Map();
  private stopFn: (() => void) | null = null;

  constructor() {
    this.state = {
      cycle: 0,
      inputs: new Map(),
      outputs: new Map(),
      memory: new Map(),
      timers: new Map(),
      counters: new Map(),
      previousInputs: new Map(),
      running: false,
    };
  }

  /** Subscribe to state changes. */
  subscribe(listener: () => void): () => void {
    this.listeners.add(listener);
    return () => this.listeners.delete(listener);
  }

  private notify() {
    this.listeners.forEach((l) => l());
  }

  /** Initialize or replace the program. */
  loadProgram(program: Program): void {
    this.stop();
    this.program = program;
    this.state.outputs.clear();
    this.state.inputs.clear();
    this.state.memory.clear();
    this.state.timers.clear();
    this.state.counters.clear();
    this.lastRungStates.clear();
    this.notify();
  }

  /** Get current engine state. */
  getState(): Readonly<EngineState> {
    return this.state;
  }

  /** Get the loaded program. */
  getProgram(): Program | null {
    return this.program;
  }

  // ─── Mutations ──────────────────────────────────────────────────

  /** Update a component's parameters within a rung. */
  updateComponent(rungId: string, componentId: string, updates: Partial<any>): void {
    if (!this.program) return;
    const rung = this.program.rungs.find((r) => r.id === rungId);
    if (!rung) return;

    const found = this.findComponentRecursive(rung.series, componentId);
    if (found) {
      Object.assign(found.element, updates);
      this.notify();
    }
  }

  /** Move a component from one rung to another or within the same rung. */
  moveComponent(
    sourceRungId: string,
    componentId: string,
    targetRungId: string,
    targetPosition: number,
  ): void {
    if (!this.program) return;
    const sourceRung = this.program.rungs.find((r) => r.id === sourceRungId);
    const targetRung = this.program.rungs.find((r) => r.id === targetRungId);
    if (!sourceRung || !targetRung) return;

    const found = this.findComponentRecursive(sourceRung.series, componentId);
    if (!found) return;

    const { parent, index, element } = found;
    parent.splice(index, 1);

    // Insert into target rung's series
    (element as any).position = targetPosition;
    targetRung.series.splice(targetPosition, 0, element);

    // Re-index positions
    this.reindexSeries(sourceRung.series);
    this.reindexSeries(targetRung.series);

    this.notify();
  }

  /** Toggle an input state. */
  toggleInput(address: string): void {
    const current = this.state.inputs.get(address)?.value ?? false;
    this.setInput(address, !current);
  }

  // ─── I/O Operations ────────────────────────────────────────────

  /** Set an input value. */
  setInput(address: string, value: boolean | number, rawValue?: number): void {
    const existing = this.state.inputs.get(address);
    this.state.inputs.set(address, {
      address,
      value,
      rawValue: rawValue ?? existing?.rawValue,
    });
    this.notify();
  }

  /** Read an input value. */
  getInput(address: string): boolean | number {
    return this.state.inputs.get(address)?.value ?? false;
  }

  /** Read an output value. */
  getOutput(address: string): boolean | number {
    return this.state.outputs.get(address)?.value ?? false;
  }

  /** Get all outputs. */
  getOutputs(): Map<string, Output> {
    return this.state.outputs;
  }

  /** Set a memory bit directly. */
  setMemory(address: string, value: boolean | number): void {
    const existing = this.state.memory.get(address);
    if (existing) {
      existing.value = value;
    } else {
      this.state.memory.set(address, { address, value });
    }
    this.notify();
  }

  /** Read a memory bit. */
  getMemory(address: string): boolean | number {
    return this.state.memory.get(address)?.value ?? false;
  }

  // ─── Scan Cycle ────────────────────────────────────────────────

  /** Run one scan cycle of the ladder program. */
  scan(): void {
    if (!this.program) return;

    this.state.cycle++;

    // Save current inputs as previous for edge detection (all address spaces)
    const currentInputs = new Map<string, boolean | number>();
    this.state.inputs.forEach((input, addr) => {
      currentInputs.set(addr, input.value);
    });
    this.state.memory.forEach((mem, addr) => {
      currentInputs.set(addr, mem.value);
    });
    this.state.outputs.forEach((out, addr) => {
      currentInputs.set(addr, out.value);
    });

    // Handle resets
    this.handleCounterResets();
    this.handleTimerResets(this.program);

    // Evaluate each rung
    for (const rung of this.program.rungs) {
      try {
        const lastRungState = this.lastRungStates.get(rung.id) ?? false;
        if (!rung.enabled) {
          this.lastRungStates.set(rung.id, false);
          continue;
        }
        const currentRungState = this.evaluateRung(rung, lastRungState);
        this.lastRungStates.set(rung.id, currentRungState);
      } catch (err) {
        console.error(`Error in scan cycle for rung ${rung.id}:`, err);
        // We continue to the next rung even if one fails
      }
    }

    // Update previousInputs for next scan cycle
    this.state.previousInputs = currentInputs;

    this.notify();
  }

  /** Start the engine running. */
  start(): () => void {
    if (!this.program) return () => {};
    if (this.stopFn) this.stop();

    this.state.running = true;
    this.notify();
    const interval = this.program.cycleTime;
    const timer = setInterval(() => this.scan(), interval);

    this.stopFn = () => {
      this.state.running = false;
      this.notify();
      clearInterval(timer);
    };

    return this.stopFn;
  }

  /** Stop the engine running. */
  stop(): void {
    if (this.stopFn) {
      this.stopFn();
      this.stopFn = null;
    }
  }

  private handleCounterResets(): void {
    if (!this.program) return;
    for (const rung of this.program.rungs) {
      this.traverseRung(rung, (element) => {
        if (element.type === 'counter') {
          const counter = element as Counter;
          if (counter.resetAddress) {
            const resetValue = this.getInput(counter.resetAddress) || this.getMemory(counter.resetAddress) || this.getOutput(counter.resetAddress);
            if (resetValue) {
              this.state.counters.set(counter.instanceId, { ...counter, current: 0 });
            }
          }
        }
      });
    }
  }

  private handleTimerResets(program: Program): void {
    for (const rung of program.rungs) {
      if (!rung.enabled) continue;
      for (const element of rung.series) {
        if (element.type === 'timer') {
          const timer = element as Timer;
          if (timer.timerType === 'RTO' && timer.resetAddress) {
            const resetState =
              this.getInput(timer.resetAddress) ||
              this.getMemory(timer.resetAddress) ||
              this.getOutput(timer.resetAddress) ||
              false;
            if (resetState) {
              const existing = this.state.timers.get(timer.instanceId);
              if (existing) {
                existing.accumulated = 0;
              } else {
                this.state.timers.set(timer.instanceId, {
                  ...timer,
                  accumulated: 0,
                });
              }
            }
          }
        }
      }
    }
  }

  // ─── Rung Evaluation ───────────────────────────────────────────

  private evaluateRung(rung: Rung, lastRungState: boolean): boolean {
    const rungResult = this.evaluateSeries(rung.series, lastRungState);

    // The last element in series is typically the output coil
    const lastElement = rung.series[rung.series.length - 1];
    if (lastElement && lastElement.type === 'coil') {
      this.activateCoil(lastElement as Coil, rungResult, lastRungState);
    }

    return rungResult;
  }

  private evaluateSeries(elements: RungElement[], lastRungState: boolean): boolean {
    let result = true;
    for (const element of elements) {
      try {
        switch (element.type) {
          case 'contact':
            result = result && this.evaluateContact(element as Contact);
            break;
          case 'gate':
            result = result && this.evaluateGate(element as LogicGate);
            break;
          case 'timer': {
            const timerResult = this.evaluateTimer(element as Timer, result, lastRungState);
            const t = element as Timer;
            if (t.timerType === 'TOF') {
              // TOF controls its own output independently of rung state:
              // while timing (off-delay), it overrides the series result
              result = timerResult;
            } else {
              result = result && timerResult;
            }
            break;
          }
          case 'counter': {
            const counterResult = this.evaluateCounter(element as Counter, result, lastRungState);
            result = result && counterResult;
            break;
          }
          case 'branch':
            result = result && this.evaluateBranch(element as Branch, lastRungState);
            break;
          case 'math': {
            const mathResult = this.evaluateMath(element as MathElement, result);
            result = result && mathResult;
            break;
          }
          case 'oneshot': {
            const oneshotResult = this.evaluateOneShot(element as OneShot, result, lastRungState);
            result = result && oneshotResult;
            break;
          }
          case 'move': {
            const moveResult = this.evaluateMove(element as MoveElement, result);
            result = result && moveResult;
            break;
          }
          case 'scale': {
            const scaleResult = this.evaluateScale(element as ScaleElement, result);
            result = result && scaleResult;
            break;
          }
          case 'noop':
            // NOP is a no-op, passes through as true
            break;
          case 'compare': {
            const compareResult = this.evaluateCompare(element as CompareElement, result);
            result = result && compareResult;
            break;
          }
          case 'coil':
            break;
          default:
            break;
        }
      } catch (err) {
        console.error(`Error evaluating element ${element.type}:`, err);
        // In a real PLC, this might halt the scan or set a fault bit.
        // Here, we'll treat it as a failure of this part of the rung.
        result = false;
      }
    }
    return result;
  }

  private evaluateBranch(branch: Branch, lastRungState: boolean): boolean {
    if (branch.logic === 'AND') {
      return branch.paths.every((path) => this.evaluateSeries(path, lastRungState));
    } else {
      return branch.paths.some((path) => this.evaluateSeries(path, lastRungState));
    }
  }

  private evaluateContact(contact: Contact): boolean {
    let inputValue: boolean | number;

    if (this.state.inputs.has(contact.address)) {
      inputValue = this.getInput(contact.address);
    } else if (this.state.memory.has(contact.address)) {
      inputValue = this.getMemory(contact.address);
    } else if (this.state.outputs.has(contact.address)) {
      inputValue = this.getOutput(contact.address);
    } else {
      // No address found — treat as false input
      inputValue = false;
    }

    // Evaluate the base contact logic (NO/NC with optional condition)
    let baseResult: boolean;
    if (contact.condition) {
      const rawValue =
        this.state.inputs.get(contact.address)?.rawValue ?? inputValue;
      if (typeof rawValue !== 'number') return false;
      baseResult = this.compare(rawValue, contact.condition.op, contact.condition.value);
    } else {
      baseResult = !!inputValue;
    }

    const contactResult = contact.contactType === 'NO' ? baseResult : !baseResult;

    // Edge detection: if edgeType is set, only pass on the specified edge
    if (contact.edgeType) {
      const prevValue = this.state.previousInputs.get(contact.address);
      const currentBool = !!inputValue;
      const prevBool = prevValue !== undefined ? !!prevValue : false;

      if (contact.edgeType === 'RISING') {
        return contactResult && currentBool && !prevBool;
      } else if (contact.edgeType === 'FALLING') {
        return contactResult && !currentBool && prevBool;
      } else if (contact.edgeType === 'BOTH') {
        return contactResult && (currentBool !== prevBool);
      }
    }

    return contactResult;
  }

  private activateCoil(coil: Coil, energized: boolean, lastRungState: boolean = false): void {
    let newValue: boolean | number;
    switch (coil.coilType) {
      case 'OUTPUT':
      case 'OTE':
        // OTE = Output Energize — standard coil that follows rung state
        newValue = energized ? (coil.value ?? true) : (coil.value ?? false);
        break;
      case 'SET':
      case 'OTL':
      case 'LATCH':
        // OTL/LATCH/SET: once energized, stays on until OTU/UNLATCH/RESET clears it
        newValue = energized ? true : (this.state.outputs.get(coil.address)?.value ?? false);
        break;
      case 'RESET':
      case 'OTU':
      case 'UNLATCH':
        // OTU/UNLATCH/RESET: clears a latched output
        newValue = energized ? false : (this.state.outputs.get(coil.address)?.value ?? false);
        break;
      case 'TOGGLE':
        // Only toggle on rising edge (FALSE→TRUE transition), not every scan while held
        if (energized && !lastRungState) {
          const currentToggle = this.state.outputs.get(coil.address)?.value ?? false;
          newValue = !currentToggle;
        } else {
          // Rung held high or false — don't change the output
          return;
        }
        break;
      default:
        newValue = energized;
    }
    this.state.outputs.set(coil.address, {
      address: coil.address,
      value: newValue,
      lastUpdated: this.state.cycle,
    });
  }

  private evaluateTimer(
    timer: Timer,
    rungState: boolean,
    lastRungState: boolean,
  ): boolean {
    const existing = this.state.timers.get(timer.instanceId);
    const currentTimer = existing ?? { ...timer, accumulated: 0 };
    const cycleTime = this.program?.cycleTime ?? 100;

    switch (timer.timerType) {
      case 'TON':
        if (rungState) {
          currentTimer.accumulated = Math.min(
            currentTimer.accumulated + cycleTime,
            timer.preset,
          );
        } else {
          currentTimer.accumulated = 0;
        }
        break;
      case 'TOF':
        if (rungState) {
          // Input is TRUE — reset timer, output ON immediately
          currentTimer.accumulated = 0;
        } else {
          // Input went FALSE — start off-delay timing
          currentTimer.accumulated = Math.min(
            currentTimer.accumulated + cycleTime,
            timer.preset,
          );
        }
        break;
      case 'TP':
        if (rungState && !lastRungState) {
          currentTimer.accumulated = timer.preset;
        } else if (currentTimer.accumulated > 0) {
          currentTimer.accumulated = Math.max(
            currentTimer.accumulated - cycleTime,
            0,
          );
        }
        break;
      case 'RTO':
        // Retain On-Delay: like TON but accumulated time persists when input goes false
        // Needs explicit reset to clear accumulated time
        if (timer.resetAddress) {
          const resetState =
            this.getInput(timer.resetAddress) ||
            this.getMemory(timer.resetAddress) ||
            this.getOutput(timer.resetAddress) ||
            false;
          if (resetState) {
            currentTimer.accumulated = 0;
            break; // Don't accumulate this cycle when reset is asserted
          }
        }
        if (rungState) {
          currentTimer.accumulated = Math.min(
            currentTimer.accumulated + cycleTime,
            timer.preset,
          );
        }
        // When rungState is false, accumulated time is retained (not reset)
        break;
    }

    this.state.timers.set(timer.instanceId, currentTimer);

    if (timer.timerType === 'TON') return currentTimer.accumulated >= timer.preset;
    if (timer.timerType === 'TOF') {
      // TOF: power flows when input is true OR when timer is still timing (not yet done)
      // rungState=true → output ON (accumulated=0, not done)
      // rungState=false → output ON while accumulated < preset, OFF when done
      return rungState || currentTimer.accumulated < timer.preset;
    }
    if (timer.timerType === 'TP') return currentTimer.accumulated > 0;
    if (timer.timerType === 'RTO') return currentTimer.accumulated >= timer.preset;

    return false;
  }

  private evaluateCounter(
    counter: Counter,
    rungState: boolean,
    lastRungState: boolean,
  ): boolean {
    const existing = this.state.counters.get(counter.instanceId);
    const currentCounter = existing ?? { ...counter, current: 0 };

    // Check for reset first. If resetting, we set current to 0 and do not increment.
    if (counter.resetAddress) {
      const resetValue = this.getInput(counter.resetAddress) || this.getMemory(counter.resetAddress) || this.getOutput(counter.resetAddress);
      if (resetValue) {
        currentCounter.current = 0;
        currentCounter.ov = false;
        currentCounter.und = false;
        this.state.counters.set(counter.instanceId, currentCounter);
        return false;
      }
    }

    if (rungState && !lastRungState) {
      if (counter.counterType === 'CTU' || counter.counterType === 'CTUD') {
        currentCounter.current++;
        if (currentCounter.current > 9999) {
          currentCounter.ov = true;
          currentCounter.current = 9999;
        }
      } else if (counter.counterType === 'CTD') {
        currentCounter.current--;
        if (currentCounter.current < 0) {
          currentCounter.und = true;
          currentCounter.current = 0;
        }
      }
    }

    this.state.counters.set(counter.instanceId, currentCounter);

    if (counter.counterType === 'CTU' || counter.counterType === 'CTUD') {
      return currentCounter.current >= counter.preset;
    } else if (counter.counterType === 'CTD') {
      return currentCounter.current <= 0;
    }

    return false;
  }

  private evaluateGate(gate: LogicGate): boolean {
    const inputValues = gate.inputs.map(
      (addr) => {
        if (this.state.inputs.has(addr)) return !!this.getInput(addr);
        if (this.state.memory.has(addr)) return !!this.getMemory(addr);
        if (this.state.outputs.has(addr)) return !!this.getOutput(addr);
        return false;
      },
    );
    switch (gate.gateType) {
      case 'AND': return inputValues.every(Boolean);
      case 'OR': return inputValues.some(Boolean);
      case 'XOR': return inputValues.filter(Boolean).length % 2 === 1;
      case 'NOT': return !inputValues[0];
      case 'NAND': return !inputValues.every(Boolean);
      case 'NOR': return !inputValues.some(Boolean);
      default: return false;
    }
  }

  private evaluateMath(math: MathElement, rungState: boolean): boolean {
    if (!rungState) return false;

    const valA = this.getValueFromAddress(math.inputA);
    const valB = this.getValueFromAddress(math.inputB);

    if (typeof valA !== 'number' || typeof valB !== 'number') {
      throw new MathOperationError(math.operator, 'Inputs must be numbers');
    }

    let result: number;
    switch (math.operator) {
      case 'ADD': result = valA + valB; break;
      case 'SUB': result = valA - valB; break;
      case 'MUL': result = valA * valB; break;
      case 'DIV':
        if (valB === 0) throw new MathOperationError(math.operator, 'Division by zero');
        result = valA / valB;
        break;
      default: throw new MathOperationError(math.operator, 'Unknown operator');
    }

    // Integer mode: truncate to whole number (32-bit DINT style)
    if (this.program?.integerMode) {
      result = Math.trunc(result);
    }
    // 32-bit overflow protection
    result = Math.max(-2147483648, Math.min(2147483647, result));

    // Update the output address. Since it's math, we might want to update an output or memory.
    // For simplicity, we'll assume it's an output or memory.
    // If it's an output, we use the existing logic. 
    // Note: the current activateCoil only handles boolean/number for COILS.
    // We might need a more generic setAddressValue method.

    if (this.state.outputs.has(math.outputAddress)) {
        const out = this.state.outputs.get(math.outputAddress)!;
        this.state.outputs.set(math.outputAddress, { ...out, value: result, lastUpdated: this.state.cycle });
    } else if (this.state.memory.has(math.outputAddress)) {
        const mem = this.state.memory.get(math.outputAddress)!;
        this.state.memory.set(math.outputAddress, { ...mem, value: result });
    } else {
        this.state.memory.set(math.outputAddress, { address: math.outputAddress, value: result });
    }

    return true; // Math element itself is "true" if it doesn't error and is evaluated in a series
  }

  private getValueFromAddress(address: string): boolean | number {
    if (this.state.inputs.has(address)) return this.getInput(address);
    if (this.state.memory.has(address)) return this.getMemory(address);
    if (this.state.outputs.has(address)) return this.getOutput(address);
    throw new InvalidMemoryAccessError(address);
  }

  // ─── New Instruction Evaluators ─────────────────────────────────

  /** One-Shot: fires true for exactly one scan on the specified edge. */
  private evaluateOneShot(oneshot: OneShot, rungState: boolean, lastRungState: boolean): boolean {
    if (!rungState) return false;

    const currentValue = this.getInput(oneshot.address) || this.getMemory(oneshot.address) || this.getOutput(oneshot.address);
    const prevValue = this.state.previousInputs.get(oneshot.address);
    const currentBool = !!currentValue;
    const prevBool = prevValue !== undefined ? !!prevValue : false;

    if (oneshot.edgeType === 'RISING') {
      return currentBool && !prevBool;
    } else {
      // FALLING
      return !currentBool && prevBool;
    }
  }

  /** MOV: copies value from source to destination. */
  private evaluateMove(move: MoveElement, rungState: boolean): boolean {
    if (!rungState) return false;

    const sourceValue = this.getValueFromAddress(move.source);

    if (this.state.outputs.has(move.destination)) {
      const out = this.state.outputs.get(move.destination)!;
      this.state.outputs.set(move.destination, { ...out, value: sourceValue, lastUpdated: this.state.cycle });
    } else if (this.state.memory.has(move.destination)) {
      this.state.memory.set(move.destination, {
        address: move.destination,
        value: sourceValue,
      });
    } else {
      this.state.memory.set(move.destination, { address: move.destination, value: sourceValue });
    }

    return true;
  }

  /** Scale: scales input from one range to another. */
  private evaluateScale(scale: ScaleElement, rungState: boolean): boolean {
    if (!rungState) return false;

    const inputVal = this.getValueFromAddress(scale.inputAddress);
    if (typeof inputVal !== 'number') {
      throw new MathOperationError('SLC', 'Input must be a number');
    }

    const range = scale.inMax - scale.inMin;
    let scaled: number;
    if (range === 0) {
      scaled = scale.outMin;
    } else {
      scaled = scale.outMin + ((inputVal - scale.inMin) / range) * (scale.outMax - scale.outMin);
    }
    // Clamp to output range
    scaled = Math.max(scale.outMin, Math.min(scale.outMax, scaled));

    if (this.state.outputs.has(scale.destination)) {
      const out = this.state.outputs.get(scale.destination)!;
      this.state.outputs.set(scale.destination, { ...out, value: scaled, lastUpdated: this.state.cycle });
    } else if (this.state.memory.has(scale.destination)) {
      this.state.memory.set(scale.destination, { address: scale.destination, value: scaled });
    } else {
      this.state.memory.set(scale.destination, { address: scale.destination, value: scaled });
    }

    return true;
  }

  /** Compare: evaluate inputA op inputB, write boolean result to outputAddress. */
  private evaluateCompare(cmp: CompareElement, rungState: boolean): boolean {
    if (!rungState) return false;

    const valA = this.getValueFromAddress(cmp.inputA);
    const valB = this.getValueFromAddress(cmp.inputB);

    if (typeof valA !== 'number' || typeof valB !== 'number') {
      throw new MathOperationError('CMP', 'Both inputs must be numbers');
    }

    const result = this.compare(valA, cmp.op, valB);

    if (this.state.outputs.has(cmp.outputAddress)) {
      const out = this.state.outputs.get(cmp.outputAddress)!;
      this.state.outputs.set(cmp.outputAddress, { ...out, value: result, lastUpdated: this.state.cycle });
    } else if (this.state.memory.has(cmp.outputAddress)) {
      this.state.memory.set(cmp.outputAddress, { address: cmp.outputAddress, value: result });
    } else {
      this.state.memory.set(cmp.outputAddress, { address: cmp.outputAddress, value: result });
    }

    return result;
  }

  /** Takes a deep snapshot of the current engine state. */
  takeSnapshot(): EngineState {
    return {
      cycle: this.state.cycle,
      inputs: new Map(Array.from(this.state.inputs.entries()).map(([k, v]) => [k, { ...v }])),
      outputs: new Map(Array.from(this.state.outputs.entries()).map(([k, v]) => [k, { ...v }])),
      memory: new Map(Array.from(this.state.memory.entries()).map(([k, v]) => [k, { ...v }])),
      timers: new Map(Array.from(this.state.timers.entries()).map(([k, v]) => [k, { ...v }])),
      counters: new Map(Array.from(this.state.counters.entries()).map(([k, v]) => [k, { ...v }])),
      previousInputs: new Map(this.state.previousInputs),
      running: this.state.running,
    };
  }

  /** Restores the engine state from a snapshot. */
  restoreSnapshot(snapshot: EngineState): void {
    this.state = {
      cycle: snapshot.cycle,
      inputs: new Map(Array.from(snapshot.inputs.entries()).map(([k, v]) => [k, { ...v }])),
      outputs: new Map(Array.from(snapshot.outputs.entries()).map(([k, v]) => [k, { ...v }])),
      memory: new Map(Array.from(snapshot.memory.entries()).map(([k, v]) => [k, { ...v }])),
      timers: new Map(Array.from(snapshot.timers.entries()).map(([k, v]) => [k, { ...v }])),
      counters: new Map(Array.from(snapshot.counters.entries()).map(([k, v]) => [k, { ...v }])),
      previousInputs: new Map(snapshot.previousInputs),
      running: snapshot.running,
    };
    this.notify();
  }

  private compare(a: number, op: string, b: number): boolean {
    switch (op) {
      case '==': return a === b;
      case '!=': return a !== b;
      case '>': return a > b;
      case '<': return a < b;
      case '>=': return a >= b;
      case '<=': return a <= b;
      default: return false;
    }
  }

  // ─── Helpers ────────────────────────────────────────────────────

  private findComponentRecursive(
    elements: RungElement[],
    componentId: string,
  ): { parent: RungElement[]; index: number; element: RungElement } | null {
    for (let i = 0; i < elements.length; i++) {
      const element = elements[i];
      if ((element as any).id === componentId) {
        return { parent: elements, index: i, element };
      }
      if (element.type === 'branch') {
        const branch = element as Branch;
        for (const path of branch.paths) {
          const found = this.findComponentRecursive(path, componentId);
          if (found) return found;
        }
      }
    }
    return null;
  }

  private reindexSeries(elements: RungElement[]): void {
    elements.forEach((el, i) => {
      (el as any).position = i;
      if (el.type === 'branch') {
        (el as Branch).paths.forEach((path) => this.reindexSeries(path));
      }
    });
  }

  private traverseRung(rung: Rung, callback: (el: RungElement) => void): void {
    this.traverseElements(rung.series, callback);
  }

  private traverseElements(
    elements: RungElement[],
    callback: (el: RungElement) => void,
  ): void {
    for (const el of elements) {
      callback(el);
      if (el.type === 'branch') {
        (el as Branch).paths.forEach((path) =>
          this.traverseElements(path, callback),
        );
      }
    }
  }
}