/**
 * SensorParts.ts — Simulation logic for sensors, stepper motor, and NeoPixel devices.
 *
 * Implements:
 *  - tilt-switch
 *  - ntc-temperature-sensor
 *  - gas-sensor (MQ-series)
 *  - flame-sensor
 *  - heart-beat-sensor
 *  - big-sound-sensor
 *  - small-sound-sensor
 *  - stepper-motor (NEMA full-step decode)
 *  - led-ring (WS2812B NeoPixel ring)
 *  - neopixel-matrix (WS2812B NeoPixel matrix)
 *  - pir-motion-sensor
 *  - hc-sr04
 */

import { PartSimulationRegistry } from './PartSimulationRegistry';
import { setAdcVoltage } from './partUtils';
import { registerSensorUpdate, unregisterSensorUpdate } from '../SensorUpdateRegistry';

// ─── Tilt Switch ─────────────────────────────────────────────────────────────

/**
 * Tilt switch — click the element to toggle between tilted (OUT HIGH) and
 * upright (OUT LOW). Also controllable via SensorControlPanel "Toggle tilt" button.
 */
PartSimulationRegistry.register('tilt-switch', {
    attachEvents: (element, simulator, getArduinoPinHelper, componentId) => {
        const pin = getArduinoPinHelper('OUT');
        if (pin === null) return () => {};

        let tilted = false;

        const triggerToggle = () => {
            tilted = !tilted;
            simulator.setPinState(pin, tilted);
            console.log(`[TiltSwitch] pin ${pin} → ${tilted ? 'HIGH (tilted)' : 'LOW (upright)'}`);
        };

        // Start LOW (upright)
        simulator.setPinState(pin, false);
        element.addEventListener('click', triggerToggle);

        // SensorControlPanel callback
        registerSensorUpdate(componentId, (values) => {
            if (values.toggle === true) triggerToggle();
        });

        return () => {
            element.removeEventListener('click', triggerToggle);
            unregisterSensorUpdate(componentId);
        };
    },
});

// ─── NTC Temperature Sensor ──────────────────────────────────────────────────

/**
 * NTC thermistor sensor — injects analog voltage representing temperature.
 * Default 25°C → 2.5V. SensorControlPanel slider adjusts temperature.
 *
 * Linear approximation: volts = clamp(2.5 - (temp - 25) * 0.02, 0, 5)
 * (25°C = 2.5V; lower temp = higher voltage, higher temp = lower voltage)
 */
PartSimulationRegistry.register('ntc-temperature-sensor', {
    attachEvents: (element, simulator, getArduinoPinHelper, componentId) => {
        const pin = getArduinoPinHelper('OUT');
        if (pin === null) return () => {};

        const tempToVolts = (temp: number) =>
            Math.max(0, Math.min(5, 2.5 - (temp - 25) * 0.02));

        // Room temperature default
        setAdcVoltage(simulator, pin, tempToVolts(25));

        const onInput = () => {
            const val = (element as any).value;
            if (val !== undefined) {
                setAdcVoltage(simulator, pin, (val / 1023.0) * 5.0);
            }
        };
        element.addEventListener('input', onInput);

        registerSensorUpdate(componentId, (values) => {
            if ('temperature' in values) {
                setAdcVoltage(simulator, pin, tempToVolts(values.temperature as number));
            }
        });

        return () => {
            element.removeEventListener('input', onInput);
            unregisterSensorUpdate(componentId);
        };
    },
});

// ─── Gas Sensor (MQ-series) ──────────────────────────────────────────────────

/**
 * Gas sensor — injects analog voltage on AOUT.
 * Default 1.5V (clean air / low gas). SensorControlPanel slider adjusts level (0–1023).
 * Higher value → higher voltage (more gas detected).
 */
PartSimulationRegistry.register('gas-sensor', {
    attachEvents: (element, simulator, getArduinoPinHelper, componentId) => {
        const pinAOUT = getArduinoPinHelper('AOUT');
        const pinDOUT = getArduinoPinHelper('DOUT');
        const pinManager = (simulator as any).pinManager;

        const el = element as any;
        el.ledPower = true;

        const unsubscribers: (() => void)[] = [];

        // Inject baseline analog voltage (1.5V ≈ clean air / low gas)
        if (pinAOUT !== null) {
            setAdcVoltage(simulator, pinAOUT, 1.5);
        }

        // DOUT from Arduino → threshold LED indicator
        if (pinDOUT !== null && pinManager) {
            unsubscribers.push(
                pinManager.onPinChange(pinDOUT, (_: number, state: boolean) => {
                    el.ledD0 = state;
                })
            );
        }

        // Allow element to update analog value if it fires input events
        const onInput = () => {
            const val = (el as any).value;
            if (val !== undefined && pinAOUT !== null) {
                setAdcVoltage(simulator, pinAOUT, (val / 1023.0) * 5.0);
            }
        };
        element.addEventListener('input', onInput);
        unsubscribers.push(() => element.removeEventListener('input', onInput));

        registerSensorUpdate(componentId, (values) => {
            if ('gasLevel' in values && pinAOUT !== null) {
                setAdcVoltage(simulator, pinAOUT, ((values.gasLevel as number) / 1023) * 5.0);
            }
        });

        return () => {
            unsubscribers.forEach(u => u());
            unregisterSensorUpdate(componentId);
        };
    },
});

// ─── Flame Sensor ────────────────────────────────────────────────────────────

/**
 * Flame sensor — injects analog voltage on AOUT.
 * Default 4.5V (no flame). SensorControlPanel slider: 0 = no flame (high V),
 * 1023 = intense flame (low V).
 */
PartSimulationRegistry.register('flame-sensor', {
    attachEvents: (element, simulator, getArduinoPinHelper, componentId) => {
        const pinAOUT = getArduinoPinHelper('AOUT');
        const pinDOUT = getArduinoPinHelper('DOUT');
        const pinManager = (simulator as any).pinManager;

        const el = element as any;
        el.ledPower = true;

        const unsubscribers: (() => void)[] = [];

        if (pinAOUT !== null) {
            setAdcVoltage(simulator, pinAOUT, 4.5); // no flame = high voltage
        }

        if (pinDOUT !== null && pinManager) {
            unsubscribers.push(
                pinManager.onPinChange(pinDOUT, (_: number, state: boolean) => {
                    el.ledSignal = state;
                })
            );
        }

        const onInput = () => {
            const val = (el as any).value;
            if (val !== undefined && pinAOUT !== null) {
                setAdcVoltage(simulator, pinAOUT, (val / 1023.0) * 5.0);
            }
        };
        element.addEventListener('input', onInput);
        unsubscribers.push(() => element.removeEventListener('input', onInput));

        registerSensorUpdate(componentId, (values) => {
            if ('intensity' in values && pinAOUT !== null) {
                // 0 = no flame → high voltage (4.5V); 1023 = flame → low voltage (0.2V)
                const volts = 5.0 - ((values.intensity as number) / 1023) * 5.0;
                setAdcVoltage(simulator, pinAOUT, volts);
            }
        });

        return () => {
            unsubscribers.forEach(u => u());
            unregisterSensorUpdate(componentId);
        };
    },
});

// ─── Heart Beat Sensor ───────────────────────────────────────────────────────

/**
 * Heart beat sensor — simulates a 60 BPM signal on OUT pin.
 * Every 1000ms: briefly pulls OUT HIGH for 100ms, then LOW again.
 */
PartSimulationRegistry.register('heart-beat-sensor', {
    attachEvents: (element, simulator, getArduinoPinHelper) => {
        const pin = getArduinoPinHelper('OUT');
        if (pin === null) return () => {};

        simulator.setPinState(pin, false);

        const intervalId = setInterval(() => {
            simulator.setPinState(pin, true); // pulse HIGH
            setTimeout(() => simulator.setPinState(pin, false), 100);
        }, 1000);

        return () => clearInterval(intervalId);
    },
});

// ─── Big Sound Sensor ────────────────────────────────────────────────────────

/**
 * Big sound sensor (FC-04) — injects mid-range analog on AOUT.
 * SensorControlPanel slider adjusts sound level (0–1023).
 */
PartSimulationRegistry.register('big-sound-sensor', {
    attachEvents: (element, simulator, getArduinoPinHelper, componentId) => {
        const pinAOUT = getArduinoPinHelper('AOUT');
        const pinDOUT = getArduinoPinHelper('DOUT');
        const pinManager = (simulator as any).pinManager;

        const el = element as any;
        el.led2 = true; // Power LED

        const unsubscribers: (() => void)[] = [];

        if (pinAOUT !== null) {
            setAdcVoltage(simulator, pinAOUT, 2.5);
        }

        if (pinDOUT !== null && pinManager) {
            unsubscribers.push(
                pinManager.onPinChange(pinDOUT, (_: number, state: boolean) => {
                    el.led1 = state;
                })
            );
        }

        const onInput = () => {
            const val = (el as any).value;
            if (val !== undefined && pinAOUT !== null) {
                setAdcVoltage(simulator, pinAOUT, (val / 1023.0) * 5.0);
            }
        };
        element.addEventListener('input', onInput);
        unsubscribers.push(() => element.removeEventListener('input', onInput));

        registerSensorUpdate(componentId, (values) => {
            if ('soundLevel' in values && pinAOUT !== null) {
                setAdcVoltage(simulator, pinAOUT, ((values.soundLevel as number) / 1023) * 5.0);
            }
        });

        return () => {
            unsubscribers.forEach(u => u());
            unregisterSensorUpdate(componentId);
        };
    },
});

// ─── Small Sound Sensor ──────────────────────────────────────────────────────

/**
 * Small sound sensor (KY-038) — injects mid-range analog on AOUT.
 * SensorControlPanel slider adjusts sound level (0–1023).
 */
PartSimulationRegistry.register('small-sound-sensor', {
    attachEvents: (element, simulator, getArduinoPinHelper, componentId) => {
        const pinAOUT = getArduinoPinHelper('AOUT');
        const pinDOUT = getArduinoPinHelper('DOUT');
        const pinManager = (simulator as any).pinManager;

        const el = element as any;
        el.ledPower = true;

        const unsubscribers: (() => void)[] = [];

        if (pinAOUT !== null) {
            setAdcVoltage(simulator, pinAOUT, 2.5);
        }

        if (pinDOUT !== null && pinManager) {
            unsubscribers.push(
                pinManager.onPinChange(pinDOUT, (_: number, state: boolean) => {
                    el.ledSignal = state;
                })
            );
        }

        const onInput = () => {
            const val = (el as any).value;
            if (val !== undefined && pinAOUT !== null) {
                setAdcVoltage(simulator, pinAOUT, (val / 1023.0) * 5.0);
            }
        };
        element.addEventListener('input', onInput);
        unsubscribers.push(() => element.removeEventListener('input', onInput));

        registerSensorUpdate(componentId, (values) => {
            if ('soundLevel' in values && pinAOUT !== null) {
                setAdcVoltage(simulator, pinAOUT, ((values.soundLevel as number) / 1023) * 5.0);
            }
        });

        return () => {
            unsubscribers.forEach(u => u());
            unregisterSensorUpdate(componentId);
        };
    },
});

// ─── Stepper Motor (NEMA full-step decode) ───────────────────────────────────

/**
 * Stepper motor — monitors the 4 coil pins (A-, A+, B+, B-).
 * Uses a full-step lookup table to detect direction of rotation and
 * accumulates the shaft angle (1.8° per step = 200 steps per revolution).
 */
PartSimulationRegistry.register('stepper-motor', {
    attachEvents: (element, simulator, getArduinoPinHelper) => {
        const pinManager = (simulator as any).pinManager;
        if (!pinManager) return () => {};

        const el = element as any;
        const STEP_ANGLE = 1.8; // degrees per step

        const pinAMinus = getArduinoPinHelper('A-');
        const pinAPlus  = getArduinoPinHelper('A+');
        const pinBPlus  = getArduinoPinHelper('B+');
        const pinBMinus = getArduinoPinHelper('B-');

        const coils = { aMinus: false, aPlus: false, bPlus: false, bMinus: false };
        let cumAngle = el.angle ?? 0;
        let prevStepIndex = -1;

        // Full-step table: index → [A+, B+, A-, B-]
        const stepTable: [boolean, boolean, boolean, boolean][] = [
            [true,  false, false, false], // step 0
            [false, true,  false, false], // step 1
            [false, false, true,  false], // step 2
            [false, false, false, true],  // step 3
        ];

        function coilToStepIndex(): number {
            for (let i = 0; i < stepTable.length; i++) {
                const [ap, bp, am, bm] = stepTable[i];
                if (coils.aPlus === ap && coils.bPlus === bp &&
                    coils.aMinus === am && coils.bMinus === bm) {
                    return i;
                }
            }
            return -1;
        }

        function onCoilChange() {
            const idx = coilToStepIndex();
            if (idx < 0) return;
            if (prevStepIndex < 0) { prevStepIndex = idx; return; }

            const diff = (idx - prevStepIndex + 4) % 4;
            if (diff === 1) {
                cumAngle += STEP_ANGLE;
            } else if (diff === 3) {
                cumAngle -= STEP_ANGLE;
            }
            prevStepIndex = idx;
            el.angle = ((cumAngle % 360) + 360) % 360;
        }

        const unsubscribers: (() => void)[] = [];

        if (pinAMinus !== null) {
            unsubscribers.push(pinManager.onPinChange(pinAMinus, (_: number, s: boolean) => {
                coils.aMinus = s; onCoilChange();
            }));
        }
        if (pinAPlus !== null) {
            unsubscribers.push(pinManager.onPinChange(pinAPlus, (_: number, s: boolean) => {
                coils.aPlus = s; onCoilChange();
            }));
        }
        if (pinBPlus !== null) {
            unsubscribers.push(pinManager.onPinChange(pinBPlus, (_: number, s: boolean) => {
                coils.bPlus = s; onCoilChange();
            }));
        }
        if (pinBMinus !== null) {
            unsubscribers.push(pinManager.onPinChange(pinBMinus, (_: number, s: boolean) => {
                coils.bMinus = s; onCoilChange();
            }));
        }

        return () => unsubscribers.forEach(u => u());
    },
});

// ─── WS2812B NeoPixel decode helper ──────────────────────────────────────────

/**
 * Decode WS2812B bit-stream from DIN pin changes for NeoPixel devices.
 */
function createNeopixelDecoder(
    simulator: any,
    pinDIN: number,
    onPixel: (index: number, r: number, g: number, b: number) => void,
): () => void {
    const pinManager = simulator.pinManager;
    if (!pinManager) return () => {};

    const RESET_CYCLES = 800;
    const BIT1_THRESHOLD = 8;

    let lastRisingCycle = 0;
    let lastFallingCycle = 0;
    let lastHigh = false;

    let bitBuf = 0;
    let bitsCollected = 0;
    let byteBuf: number[] = [];
    let pixelIndex = 0;

    const unsub = pinManager.onPinChange(pinDIN, (_: number, high: boolean) => {
        const cpu = simulator.cpu ?? (simulator as any).cpu;
        const now: number = cpu?.cycles ?? 0;

        if (high) {
            const lowDur = now - lastFallingCycle;
            if (lowDur > RESET_CYCLES) {
                pixelIndex = 0;
                byteBuf = [];
                bitBuf = 0;
                bitsCollected = 0;
            }
            lastRisingCycle = now;
            lastHigh = true;
        } else {
            if (lastHigh) {
                const highDur = now - lastRisingCycle;
                const bit = highDur > BIT1_THRESHOLD ? 1 : 0;

                bitBuf = (bitBuf << 1) | bit;
                bitsCollected++;

                if (bitsCollected === 8) {
                    byteBuf.push(bitBuf & 0xFF);
                    bitBuf = 0;
                    bitsCollected = 0;

                    if (byteBuf.length === 3) {
                        const g = byteBuf[0];
                        const r = byteBuf[1];
                        const b = byteBuf[2];
                        onPixel(pixelIndex++, r, g, b);
                        byteBuf = [];
                    }
                }
            }
            lastFallingCycle = now;
            lastHigh = false;
        }
    });

    return unsub;
}

// ─── LED Ring (WS2812B NeoPixel ring) ────────────────────────────────────────

PartSimulationRegistry.register('led-ring', {
    attachEvents: (element, simulator, getArduinoPinHelper) => {
        const pinDIN = getArduinoPinHelper('DIN');
        if (pinDIN === null) return () => {};

        const el = element as any;

        const unsub = createNeopixelDecoder(
            (simulator as any),
            pinDIN,
            (index, r, g, b) => {
                try {
                    el.setPixel(index, { r, g, b });
                } catch (_) {
                    // setPixel not yet available (element not upgraded) — ignore
                }
            },
        );

        return unsub;
    },
});

// ─── NeoPixel Matrix (WS2812B matrix grid) ────────────────────────────────────

PartSimulationRegistry.register('neopixel-matrix', {
    attachEvents: (element, simulator, getArduinoPinHelper) => {
        const pinDIN = getArduinoPinHelper('DIN');
        if (pinDIN === null) return () => {};

        const el = element as any;

        const unsub = createNeopixelDecoder(
            (simulator as any),
            pinDIN,
            (index, r, g, b) => {
                const cols: number = el.cols ?? 8;
                const row = Math.floor(index / cols);
                const col = index % cols;
                try {
                    el.setPixel(row, col, { r, g, b });
                } catch (_) {
                    // ignore
                }
            },
        );

        return unsub;
    },
});

// ─── Single NeoPixel (WS2812B) ───────────────────────────────────────────────

/**
 * Single addressable RGB LED — decodes the WS2812B data stream on DIN.
 */
PartSimulationRegistry.register('neopixel', {
    attachEvents: (element, simulator, getArduinoPinHelper) => {
        const pinDIN = getArduinoPinHelper('DIN');
        if (pinDIN === null) return () => {};

        const el = element as any;

        const unsub = createNeopixelDecoder(
            (simulator as any),
            pinDIN,
            (_index, r, g, b) => {
                el.r = r / 255;
                el.g = g / 255;
                el.b = b / 255;
            },
        );

        return unsub;
    },
});

// ─── PIR Motion Sensor ───────────────────────────────────────────────────────

/**
 * PIR motion sensor — click the element OR press "Simulate motion" in the
 * SensorControlPanel to trigger a 3-second HIGH pulse on OUT.
 */
PartSimulationRegistry.register('pir-motion-sensor', {
    attachEvents: (element, simulator, getArduinoPinHelper, componentId) => {
        const pin = getArduinoPinHelper('OUT');
        if (pin === null) return () => {};

        simulator.setPinState(pin, false); // idle LOW

        let timer: ReturnType<typeof setTimeout> | null = null;

        const triggerMotion = () => {
            if (timer !== null) clearTimeout(timer);
            simulator.setPinState(pin, true);
            console.log('[PIR] Motion detected → OUT HIGH');
            timer = setTimeout(() => {
                simulator.setPinState(pin, false);
                timer = null;
                console.log('[PIR] Motion ended → OUT LOW');
            }, 3000);
        };

        element.addEventListener('click', triggerMotion);

        registerSensorUpdate(componentId, (values) => {
            if (values.trigger === true) triggerMotion();
        });

        return () => {
            element.removeEventListener('click', triggerMotion);
            if (timer !== null) clearTimeout(timer);
            unregisterSensorUpdate(componentId);
        };
    },
});

// ─── KS2E-M-DC5 Relay ────────────────────────────────────────────────────────

/**
 * Dual-coil relay — listens for COIL1/COIL2 pin state changes.
 */
PartSimulationRegistry.register('ks2e-m-dc5', {
    onPinStateChange: (pinName, state, _element) => {
        if (pinName === 'COIL1' || pinName === 'COIL2') {
            console.log(`[Relay KS2E] ${pinName} → ${state ? 'ACTIVATED' : 'RELEASED'}`);
        }
    },
});

// ─── HC-SR04 Ultrasonic Distance Sensor ──────────────────────────────────────

/**
 * Ultrasonic sensor — monitors the TRIG pin.
 * When TRIG goes HIGH, responds with an ECHO HIGH pulse whose duration
 * encodes the configured distance (default 10 cm).
 *
 * Echo timing: echoMs = distanceCm / 17.15
 * (speed of sound ~343 m/s; round-trip halves: 17150 cm/s)
 */
PartSimulationRegistry.register('hc-sr04', {
    attachEvents: (element, simulator, getArduinoPinHelper, componentId) => {
        const trigPin = getArduinoPinHelper('TRIG');
        const echoPin = getArduinoPinHelper('ECHO');
        if (trigPin === null || echoPin === null) return () => {};

        simulator.setPinState(echoPin, false); // ECHO LOW initially

        let distanceCm = 10; // default distance in cm

        const cleanup = simulator.pinManager.onPinChange(trigPin, (_: number, state: boolean) => {
            if (!state) return; // only react on TRIG HIGH
            // HC-SR04 timing (at 16 MHz):
            //  - Sensor processing delay after TRIG: ~600 µs = 9600 cycles
            //  - Echo duration = distanceCm / 17150 s × 16 000 000 cycles/s
            //    (17150 cm/s = speed of sound, one-way = round-trip/2)
            if (typeof simulator.schedulePinChange === 'function') {
                const now = simulator.getCurrentCycles() as number;
                const processingCycles = 9600; // ~600 µs sensor overhead
                const echoCycles = Math.round((distanceCm / 17150) * 16_000_000);
                simulator.schedulePinChange(echoPin, true,  now + processingCycles);
                simulator.schedulePinChange(echoPin, false, now + processingCycles + echoCycles);
                console.log(`[HC-SR04] Scheduled ECHO (${distanceCm} cm, echo=${(echoCycles/16000).toFixed(1)} µs)`);
            } else {
                // Fallback: best-effort async (works with delay()-based sketches, not pulseIn)
                const echoMs = Math.max(1, distanceCm / 17.15);
                setTimeout(() => {
                    simulator.setPinState(echoPin, true);
                    setTimeout(() => { simulator.setPinState(echoPin, false); }, echoMs);
                }, 1);
            }
        });

        registerSensorUpdate(componentId, (values) => {
            if ('distance' in values) {
                distanceCm = Math.max(2, Math.min(400, values.distance as number));
            }
        });

        return () => {
            cleanup();
            unregisterSensorUpdate(componentId);
        };
    },
});