from __future__ import annotations

import logging
import time

from sqlmodel import Session

from app.core.config import settings
from app.core.db import engine
from app.models import TerminalMessageRaw
from app.mqtt.parsers.mixed import parse_mixed_payload
from app.mqtt.repository import (
    fetch_pending_rows_for_update,
    mark_failed,
    mark_succeeded,
    update_device_state_from_events,
)

logger = logging.getLogger(__name__)


def _process_one_row(*, session: Session, row: TerminalMessageRaw) -> None:
    try:
        events = parse_mixed_payload(row.payload_bytes)
        update_device_state_from_events(session=session, row=row, events=events)
        mark_succeeded(session=session, row=row)
    except Exception as exc:  # pragma: no cover - safety net path
        mark_failed(
            session=session,
            row=row,
            parse_error=str(exc),
        )

    session.commit()


def process_pending_batch(*, session: Session, batch_size: int) -> int:
    rows = fetch_pending_rows_for_update(session=session, batch_size=batch_size)
    for row in rows:
        _process_one_row(session=session, row=row)
    return len(rows)


def run() -> None:
    logging.basicConfig(level=logging.INFO)
    sleep_seconds = max(settings.PARSER_POLL_INTERVAL_MS, 50) / 1000.0

    while True:
        with Session(engine) as session:
            processed = process_pending_batch(
                session=session, batch_size=settings.PARSER_BATCH_SIZE
            )
        if processed == 0:
            time.sleep(sleep_seconds)
        else:
            logger.info("Processed %s pending MQTT raw messages", processed)


if __name__ == "__main__":
    run()