"""QML-facing controller for the live/review wafer dashboard."""
from __future__ import annotations
import logging
from typing import Any, Optional

from PySide6.QtCore import QObject, Property, QTimer, Qt, Signal, Slot

from pygui.backend.csv_recorder import CsvRecorder
from pygui.backend.frame import Frame
from pygui.backend.frame_player import FramePlayer, frames_from_wafer_data
from pygui.backend.session_model import SessionModel
from pygui.backend.threshold_classifier import ThresholdConfig
from pygui.backend.zwafer_models import Sensor
from pygui.backend.zwafer_parser import ZWaferParser
from pygui.serialcomm.stream_reader import StreamReader
from pygui.backend.sensor_editor import SensorEditor

log = logging.getLogger(__name__)

MODE_LIVE = "live"
MODE_REVIEW = "review"


class SessionController(QObject):
    # public signals
    frameUpdated = Signal()        # any property below may have changed
    modeChanged = Signal()
    stateChanged = Signal()
    recordingChanged = Signal()
    sensorsChanged = Signal()
    loadedFileChanged = Signal()
    # private: marshal a worker-thread frame onto the main thread
    _liveFrame = Signal(object)    # Frame

    def __init__(self, parent: QObject | None = None) -> None:
        super().__init__(parent)
        self._mode = MODE_REVIEW
        self._model = SessionModel()
        self._player = FramePlayer()
        self._reader: Optional[StreamReader] = None
        self._recorder = CsvRecorder()
        self._sensors: list[Sensor] = []
        self._last = None              # last SessionUpdate
        self._elapsed = 0.0

        self._play_timer = QTimer(self)
        self._play_timer.timeout.connect(self._advance)
        self._speed = 1.0

        # Q1: coalesce live repaints to ~20 Hz; data is still processed every frame.
        self._repaint_timer = QTimer(self)
        self._repaint_timer.setInterval(50)            # ~20 Hz
        self._repaint_timer.timeout.connect(self._flush_repaint)
        self._dirty = False

        self._liveFrame.connect(self._on_live_frame, Qt.ConnectionType.QueuedConnection)
        
        self._sensor_editor = SensorEditor()
        self._last_raw_frame: Frame | None = None
        self._loaded_file: str = ""

    # ---- properties QML binds to ----
    @Property(str, notify=modeChanged)
    def mode(self) -> str: return self._mode

    @Property(int, notify=frameUpdated)
    def frameIndex(self) -> int: return self._player.index

    @Property(int, notify=frameUpdated)
    def frameTotal(self) -> int: return self._player.total

    @Property(str, notify=stateChanged)
    def state(self) -> str: return self._last.state if self._last else "idle"

    @Property(bool, notify=recordingChanged)
    def recording(self) -> bool: return self._recorder.is_recording

    @Property(list, notify=frameUpdated)
    def sensorDots(self) -> list[dict]:
        """Per-sensor render data for the radial map."""
        if not self._last:
            return []
        out = []
        for i, s in enumerate(self._sensors):
            v = self._last.values[i] if i < len(self._last.values) else 0.0
            band = self._last.bands[i] if i < len(self._last.bands) else "in_range"
            out.append({"label": s.label, "x": s.x, "y": s.y,
                        "value": round(v, 2), "band": band, "index": i})
        return out

    # ---- WaferMapItem bindings (split view of sensorDots) ----
    @Property("QVariantList", notify=sensorsChanged)
    def sensorLayout(self) -> list:
        """[{label, x, y}] for WaferMapItem.sensors."""
        return [{"label": s.label, "x": s.x, "y": s.y} for s in self._sensors]

    @Property("QVariantList", notify=frameUpdated)
    def sensorValues(self) -> list:
        """[float] in sensor order."""
        if not self._last:
            return []
        return [round(v, 3) for v in self._last.values]

    @Property("QVariantList", notify=frameUpdated)
    def sensorBands(self) -> list:
        """['in_range'|'high'|'low'] in sensor order."""
        if not self._last:
            return []
        return list(self._last.bands)

    @Property(float, notify=frameUpdated)
    def target(self) -> float:
        """Resolved band center (frame mean in auto mode, else set_point)."""
        return self._last.target if self._last else 149.0

    @Property(float, notify=frameUpdated)
    def margin(self) -> float:
        """Resolved band half-width (frame 1σ in auto mode, else margin)."""
        return self._last.margin if self._last else 1.0

    @Property(dict, notify=frameUpdated)
    def stats(self) -> dict:
        if not self._last:
            return {}
        s = self._last.stats
        return {"min": round(s.min, 2), "minIndex": s.min_index + 1,
                "max": round(s.max, 2), "maxIndex": s.max_index + 1,
                "diff": round(s.diff, 2), "avg": round(s.avg, 2),
                "sigma": round(s.sigma, 2), "threeSigma": round(s.three_sigma, 2)}

    @Property(str, notify=loadedFileChanged)
    def loadedFile(self) -> str: return self._loaded_file

    @Property("QVariantList", notify=frameUpdated)
    def overriddenSensors(self) -> list[int]:
        """Indices of sensors that currently have a replacement or offset."""
        return self._sensor_editor.active_indices()

    # ---- mode + thresholds ----
    @Slot(str)
    def setMode(self, mode: str) -> None:
        if mode == self._mode:
            return
        self.stopStream()
        self._play_timer.stop()
        self._mode = mode
        self.modeChanged.emit()

    @Slot(float, float, bool)
    def setThresholds(self, set_point: float, margin: float, auto: bool) -> None:
        self._model.set_thresholds(ThresholdConfig(set_point, margin, auto))
        if self._last:                     # re-band current frame in place
            self._reprocess_current()

    # ---- review: file load + playback ----
    @Slot(str)
    def loadFile(self, file_path: str) -> None:
        from pygui.backend.data_records import is_official_csv, read_data_records, read_official_csv

        sensors: list[Sensor] = []
        frames = []

        if is_official_csv(file_path):
            sensors, records = read_official_csv(file_path)
            frames = frames_from_wafer_data(None, records)
        else:
            try:
                data, _ = ZWaferParser().parse(file_path)
            except (ValueError, KeyError) as exc:
                log.warning("Could not parse %s: %s", file_path, exc)
                return
            if data is None or not data.sensors:
                log.warning("Could not parse %s", file_path)
                return
            records = read_data_records(file_path)
            sensors = data.sensors
            frames = frames_from_wafer_data(data, records)

        if not sensors or not frames:
            log.warning("No sensors or data in %s", file_path)
            return

        self._sensors = sensors
        self._player.load(frames)
        self._model.reset()
        self._loaded_file = file_path
        self.loadedFileChanged.emit()
        self.sensorsChanged.emit()
        self._emit_current()

    @Slot()
    def play(self) -> None:
        self._play_timer.start(self._next_interval_ms())

    @Slot()
    def pause(self) -> None: self._play_timer.stop()

    @Slot()
    def stop(self) -> None:
        self._play_timer.stop()
        self._player.seek(0)
        self._emit_current()

    @Slot(int)
    def step(self, delta: int) -> None:
        self._play_timer.stop()
        self._player.step(delta)
        self._emit_current()

    @Slot(int)
    def seek(self, i: int) -> None:
        self._player.seek(i)
        self._emit_current()

    @Slot(float)
    def setSpeed(self, x: float) -> None:
        self._speed = max(0.1, x)
        if self._play_timer.isActive():
            self._play_timer.start(self._next_interval_ms())

    def _next_interval_ms(self) -> int:
        """Timer interval in ms for the next frame, scaled by playback speed. Falls back to 500ms."""
        ms = self._player.next_frame_ms()
        if ms <= 0:
            ms = 500.0
        return max(1, int(ms / self._speed))

    def _advance(self) -> None:
        if self._player.at_end:
            self._play_timer.stop()
            return
        self._player.step(1)
        self._emit_current()
        self._play_timer.start(self._next_interval_ms())

    def _emit_current(self) -> None:
        frame = self._player.current()
        if frame is None:
            return
        self._last_raw_frame = frame
        edited = Frame(seq=frame.seq, time=frame.time,
                    values=self._sensor_editor.apply(frame.values))
        self._last = self._model.process(edited)
        self.frameUpdated.emit()
        self.stateChanged.emit()

    def _reprocess_current(self) -> None:
        """Re-run the model on the last raw frame"""
        frame = self._last_raw_frame
        if frame is None:
            return
        edited = Frame(seq=frame.seq, time=frame.time,
                    values=self._sensor_editor.apply(frame.values))
        self._last = self._model.process(edited)
        self.frameUpdated.emit()
        self.stateChanged.emit()

    # ---- live: stream start/stop ----
    @Slot(str)
    def startStream(self, port: str) -> None:
        from pygui.serialcomm.serial_port import SerialPort  # transport open
        import serial as pyserial

        def parse_line(raw: str, seq: int) -> Frame:
            parts = [float(x) for x in raw.split(",")]
            return Frame(seq=seq, time=parts[0], values=parts[1:])

        transport = pyserial.Serial(port, SerialPort.BAUDRATE, timeout=1)
        self._reader = StreamReader(
            transport, parse_line,
            on_frame=lambda f: self._liveFrame.emit(f))
        self._reader.start()
        self._repaint_timer.start()        # Q1: begin ~20 Hz repaints

    @Slot()
    def stopStream(self) -> None:
        self._repaint_timer.stop()
        if self._reader is not None:
            self._reader.stop()
            self._reader = None
        self.stopRecording()

    @Slot(object)
    def _on_live_frame(self, frame: Frame) -> None:
        # Main thread (queued). Record raw, process edited; mark dirty for repaint.
        self._last_raw_frame = frame
        edited = Frame(seq=frame.seq, time=frame.time,
                    values=self._sensor_editor.apply(frame.values))
        self._last = self._model.process(edited)
        if self._recorder.is_recording:
            self._recorder.write(frame)   # always record raw values, never edited
        self._dirty = True

    def _flush_repaint(self) -> None:
        if not self._dirty:
            return
        self._dirty = False
        self.frameUpdated.emit()
        self.stateChanged.emit()

    # ---- recording ----
    @Slot(str, str)
    def startRecording(self, path: str, serial: str = "") -> None:
        self._recorder.start(path, self._sensors, serial)
        self.recordingChanged.emit()

    @Slot()
    def stopRecording(self) -> None:
        if self._recorder.is_recording:
            self._recorder.stop()
            self.recordingChanged.emit()

    @Slot(int, float)
    def replaceSensor(self, index: int, value: float) -> None:
        """Override sensor `index` to display `value` every frame."""
        self._sensor_editor.set_replacement(index, value)
        self._reprocess_current()

    @Slot(int, float)
    def offsetSensor(self, index: int, delta: float) -> None:
        """Shift sensor `index` by `delta` every frame."""
        self._sensor_editor.set_offset(index, delta)
        self._reprocess_current()

    @Slot(int)
    def clearSensorEdit(self, index: int) -> None:
        """Remove all overrides for sensor `index`."""
        self._sensor_editor.clear(index)
        self._reprocess_current()

    @Slot()
    def clearSensorEdits(self) -> None:
        """Remove all sensor overrides."""
        self._sensor_editor.clear()
        self._reprocess_current()