"""
api/raw_elm.py — Сырое взаимодействие с ELM327 (локальное + удалённое через Android).

ЛОКАЛЬНЫЙ РЕЖИМ (ELM327 подключён к серверу напрямую):
  POST /api/v1/elm/raw          — отправить команду, получить сырой ответ
  POST /api/v1/elm/raw/batch    — несколько команд
  POST /api/v1/elm/raw/drain    — очистить буфер
  GET  /api/v1/elm/raw/available — байт в буфере
  GET  /api/v1/elm/raw/log      — история команд
  GET  /api/v1/elm/raw/mode     — режим (normal/raw)

УДАЛЁННЫЙ РЕЖИМ (Android-ретранслятор):
  POST /api/v1/elm/raw/hello     — Android: «я готов»
  POST /api/v1/elm/raw/cmd       — Copilot: поставить команду в очередь
  GET  /api/v1/elm/raw/cmd       — Android: забрать команду
  POST /api/v1/elm/raw/response  — Android: отправить ответ
  GET  /api/v1/elm/raw/response  — Copilot: прочитать ответ
  GET  /api/v1/elm/raw/status    — Copilot: статус устройства
"""

import logging
import threading
import time
from flask import jsonify, request, Blueprint

from api.db import Database

logger = logging.getLogger("elmer.raw_api")

# ══════════════════════════════════════════════════════════
# Локальное состояние (только для прямого подключения ELM)
# ══════════════════════════════════════════════════════════

_raw_mode = False
_raw_elm = None  # локальный RawELM (прямое подключение к серверу)


def is_raw_mode() -> bool:
    return _raw_mode

def set_raw_mode(on: bool):
    global _raw_mode
    _raw_mode = on
    logger.info(f"RawELM mode: {'ON' if on else 'OFF'}")

def set_raw_elm(instance):
    global _raw_elm
    _raw_elm = instance


bp = Blueprint("raw_elm", __name__)


# ══════════════════════════════════════════════════════════
# ЛОКАЛЬНЫЙ РЕЖИМ — ELM327 подключён к серверу напрямую
# ══════════════════════════════════════════════════════════

@bp.route("/api/v1/elm/raw", methods=["POST"])
def raw_command():
    if not _raw_elm:
        return jsonify({"error": "no local ELM connection"}), 503
    data = request.get_json(silent=True)
    if not data or "cmd" not in data:
        return jsonify({"error": "missing 'cmd'"}), 400
    cmd = data["cmd"].strip()
    if not cmd:
        return jsonify({"error": "empty cmd"}), 400
    timeout = data.get("timeout_ms")
    drain_first = data.get("drain_first", False)
    if drain_first:
        _raw_elm.drain()
    result = _raw_elm.send(cmd, timeout=timeout)
    return jsonify(result)


@bp.route("/api/v1/elm/raw/batch", methods=["POST"])
def raw_batch():
    if not _raw_elm:
        return jsonify({"error": "no local ELM connection"}), 503
    data = request.get_json(silent=True)
    if not data or "cmds" not in data:
        return jsonify({"error": "missing 'cmds'"}), 400
    cmds = data["cmds"]
    if len(cmds) > 100:
        return jsonify({"error": "too many commands (max 100)"}), 400
    timeout = data.get("timeout_ms")
    drain_between = data.get("drain_between", False)
    t0 = time.time()
    results = []
    for cmd in cmds:
        if drain_between:
            _raw_elm.drain()
        results.append(_raw_elm.send(cmd, timeout=timeout))
    total_elapsed = int((time.time() - t0) * 1000)
    return jsonify({"results": results, "total_elapsed_ms": total_elapsed})


@bp.route("/api/v1/elm/raw/drain", methods=["POST"])
def raw_drain():
    if not _raw_elm:
        return jsonify({"error": "no local ELM connection"}), 503
    return jsonify(_raw_elm.drain())


@bp.route("/api/v1/elm/raw/available", methods=["GET"])
def raw_available():
    if not _raw_elm:
        return jsonify({"error": "no local ELM connection"}), 503
    return jsonify({"available": _raw_elm.available()})


@bp.route("/api/v1/elm/raw/log", methods=["GET"])
def raw_log():
    if not _raw_elm:
        with Database() as db:
            rows = db.conn.execute(
                "SELECT seq, cmd, raw_response, elapsed_ms, prompt, error FROM command_queue WHERE status='done' ORDER BY id DESC LIMIT 50"
            ).fetchall()
            history = [{"seq": r["seq"], "cmd": r["cmd"], "raw": r["raw_response"],
                        "elapsed_ms": r["elapsed_ms"], "prompt": r["prompt"], "error": r["error"]}
                       for r in rows]
        return jsonify({"log": history, "count": len(history)})
    return jsonify({"log": _raw_elm.log, "count": len(_raw_elm.log)})


@bp.route("/api/v1/elm/raw/mode", methods=["GET", "POST"])
def raw_mode_control():
    global _raw_mode
    if request.method == "POST":
        data = request.get_json(silent=True) or {}
        on = data.get("raw_mode", False)
        set_raw_mode(on)
    with Database() as db:
        device = db.conn.execute(
            "SELECT device_id FROM command_queue ORDER BY id DESC LIMIT 1"
        ).fetchone()
    return jsonify({
        "raw_mode": _raw_mode,
        "has_local_elm": _raw_elm is not None,
        "device_ready": device is not None,
    })


# ══════════════════════════════════════════════════════════
# УДАЛЁННЫЙ РЕЖИМ — Android-ретранслятор (SQLite-очередь)
# ══════════════════════════════════════════════════════════

@bp.route("/api/v1/elm/raw/hello", methods=["POST"])
def raw_hello():
    """Android: «я подключился, готов принимать команды»."""
    data = request.get_json(silent=True) or {}
    device_id = data.get("device_id", "unknown")
    with Database() as db:
        # Очистить старые команды для этого устройства (новая сессия)
        db.conn.execute("DELETE FROM command_queue WHERE device_id = ?", (device_id,))
        db.conn.commit()
    logger.info(f"RawELM: device ready — {device_id} "
                f"({data.get('elm_version', '?')}, proto {data.get('protocol', '?')})")
    return jsonify({"ok": True, "seq": 0})


@bp.route("/api/v1/elm/raw/cmd", methods=["POST"])
def raw_enqueue_cmd():
    """Copilot: поставить команду в очередь."""
    data = request.get_json(silent=True)
    if not data or "cmd" not in data:
        return jsonify({"error": "missing 'cmd'"}), 400
    cmd = data["cmd"].strip()
    if not cmd:
        return jsonify({"error": "empty cmd"}), 400

    device_id = data.get("device_id", "unknown")
    tmo = data.get("timeout_ms", 500)
    drain = 1 if data.get("drain_first") else 0

    with Database() as db:
        cur = db.conn.execute("SELECT COALESCE(MAX(seq), 0) + 1 FROM command_queue WHERE device_id = ?", (device_id,))
        seq = cur.fetchone()[0]
        db.conn.execute(
            "INSERT INTO command_queue (device_id, seq, cmd, timeout_ms, drain_first, status) VALUES (?,?,?,?,?,'pending')",
            (device_id, seq, cmd, tmo, drain)
        )
        db.conn.commit()
    logger.info(f"RawELM: enqueued #{seq} → {cmd}")
    return jsonify({"ok": True, "seq": seq, "cmd": cmd})


@bp.route("/api/v1/elm/raw/cmd", methods=["GET"])
def raw_dequeue_cmd():
    """Android: забрать команду из очереди."""
    device_id = request.args.get("device_id", "unknown")
    with Database() as db:
        row = db.conn.execute(
            "SELECT id, seq, cmd, timeout_ms, drain_first FROM command_queue WHERE device_id=? AND status='pending' ORDER BY seq LIMIT 1",
            (device_id,)
        ).fetchone()
        if not row:
            return "", 204
        cur = db.conn.execute(
            "UPDATE command_queue SET status='sent', sent_at=datetime('now') WHERE id=? AND status='pending'",
            (row["id"],)
        )
        db.conn.commit()
        if cur.rowcount == 0:  # перехватил другой воркер
            return "", 204
        result = {"seq": row["seq"], "cmd": row["cmd"], "timeout_ms": row["timeout_ms"], "drain_first": bool(row["drain_first"])}
    logger.info(f"RawELM: dequeued #{row['seq']} → {row['cmd']}")
    return jsonify(result)


@bp.route("/api/v1/elm/raw/response", methods=["POST"])
def raw_post_response():
    """Android: отправить ответ ELM327."""
    data = request.get_json(silent=True)
    if not data:
        return jsonify({"error": "empty body"}), 400
    device_id = data.get("device_id", "unknown")
    seq = data.get("seq", 0)
    raw_resp = data.get("raw", "")
    elapsed = data.get("elapsed_ms", 0)
    prompt = 1 if data.get("prompt") else 0
    error = data.get("error")

    with Database() as db:
        db.conn.execute(
            "UPDATE command_queue SET status='done', raw_response=?, elapsed_ms=?, prompt=?, error=?, responded_at=datetime('now') WHERE device_id=? AND seq=?",
            (raw_resp, elapsed, prompt, error, device_id, seq)
        )
        db.conn.commit()
    logger.info(f"RawELM: response #{seq} ← {raw_resp[:80]}")
    return jsonify({"ok": True})


@bp.route("/api/v1/elm/raw/response", methods=["GET"])
def raw_get_response():
    """Copilot: прочитать последний ответ."""
    seq = int(request.args.get("seq", 0))
    wait_s = int(request.args.get("wait", 0))

    if wait_s > 0:
        dl = time.time() + wait_s
        while time.time() < dl:
            with Database() as db:
                row = db.conn.execute(
                    "SELECT seq, cmd, raw_response, elapsed_ms, prompt, error FROM command_queue WHERE seq > ? AND status='done' ORDER BY seq DESC LIMIT 1",
                    (seq,)
                ).fetchone()
                if row:
                    return jsonify({"seq": row["seq"], "cmd": row["cmd"], "raw": row["raw_response"],
                                    "elapsed_ms": row["elapsed_ms"], "prompt": bool(row["prompt"]), "error": row["error"]})
            time.sleep(0.5)

    with Database() as db:
        row = db.conn.execute(
            "SELECT seq, cmd, raw_response, elapsed_ms, prompt, error FROM command_queue WHERE status='done' ORDER BY seq DESC LIMIT 1"
        ).fetchone()
    if not row:
        return jsonify({"error": "no response yet", "seq": 0})
    return jsonify({"seq": row["seq"], "cmd": row["cmd"], "raw": row["raw_response"],
                    "elapsed_ms": row["elapsed_ms"], "prompt": bool(row["prompt"]), "error": row["error"]})


@bp.route("/api/v1/elm/raw/status", methods=["GET"])
def raw_status():
    """Copilot: статус устройства."""
    device_id = request.args.get("device_id", "unknown")
    with Database() as db:
        # Чистка старых записей (старше 1 дня)
        db.conn.execute(
            "DELETE FROM command_queue WHERE responded_at < datetime('now', '-1 day')"
        )
        db.conn.commit()
        last = db.conn.execute(
            "SELECT seq, status FROM command_queue WHERE device_id=? ORDER BY id DESC LIMIT 1",
            (device_id,)
        ).fetchone()
        pending = db.conn.execute(
            "SELECT COUNT(*) FROM command_queue WHERE device_id=? AND status='pending'", (device_id,)
        ).fetchone()[0]
        total = db.conn.execute(
            "SELECT COUNT(*) FROM command_queue WHERE device_id=? AND status='done'", (device_id,)
        ).fetchone()[0]
    return jsonify({
        "device_ready": last is not None,
        "pending_cmd": pending > 0,
        "pending_seq": pending,
        "last_response_seq": last["seq"] if last else 0,
        "history_count": total,
    })


@bp.route("/api/v1/elm/raw/history", methods=["GET"])
def raw_history():
    """Copilot: история команд."""
    n = int(request.args.get("n", 50))
    with Database() as db:
        rows = db.conn.execute(
            "SELECT seq, cmd, raw_response, elapsed_ms, prompt, error FROM command_queue WHERE status='done' ORDER BY id DESC LIMIT ?",
            (n,)
        ).fetchall()
    history = [{"seq": r["seq"], "cmd": r["cmd"], "raw": r["raw_response"],
                "elapsed_ms": r["elapsed_ms"], "prompt": bool(r["prompt"]), "error": r["error"]}
               for r in rows]
    return jsonify({"history": history, "total": len(history)})