#!/usr/bin/env python3
"""
Mock ARC backend for task-delivery integration tests.

Stubs all endpoints NetworkService hits so a real ARC desktop app can connect,
run real devices, and process tasks that you inject from the outside.

At startup loads:
  - default_profile.json      → served as /current_profile (seed bank profiles
                                 with their materials so ARC's sync links them
                                 to real local device/material rows)
  - scenarios/pool/*.json     → pool of FETCH_TRANSACTIONS tasks, grouped
                                 by material_id for auto-bootstrap

On the FIRST /auth/login of a run the mock bootstraps the task queue:
  - 1 × FETCH_PROFILE per material seen in default_profile.json
  - N × FETCH_TRANSACTIONS per material, picked randomly from the pool
    (controlled by --ft-per-material, default 3)

Every injected task gets a unique `_task_id`. Results posted via
POST /task/task_result are paired (FIFO per material+type) to the matching
injected task. GET /_admin/report returns the full list of pairs so you can
see exactly which task JSON went out and what the app returned.

Usage:
    pip install flask
    python3 mock_server.py --port 8888

    # Point ARC at it: in config.ini set
    #   [net]
    #   apiBase=http://127.0.0.1:8888

    # Start ARC → it logs in, mock auto-queues bootstrap tasks, ARC processes
    # them on real devices and posts results back.

    # Inspect the full report of task ↔ result pairs:
    curl -s http://127.0.0.1:8888/_admin/report | jq
"""

import argparse
import copy
import json
import os
import random
import re
import shutil
import threading
import time
import uuid
from collections import defaultdict, deque
from datetime import datetime, timedelta, timezone
from pathlib import Path

from flask import Flask, Response, jsonify, request

app = Flask(__name__)
app.config["JSON_SORT_KEYS"] = False

HERE = Path(__file__).parent

_lock = threading.Lock()

_task_queue: deque = deque()
# _injected: list of {id, task, injected_at, result, result_at, status}
# status: "pending" | "completed"
_injected: list = []
# Per (material_id, type) → FIFO of _injected indices still waiting for a result
_pending_by_key: dict = defaultdict(deque)

_profile_id = "11111111-1111-1111-1111-111111111111"
_desktop_id = "22222222-2222-2222-2222-222222222222"

_bank_profiles: list = []  # seeded from default_profile.json
_devices_by_desktop: dict = {}
_pool_by_material: dict = defaultdict(list)
_device_label_by_material: dict = {}  # material_id -> "TECNO KM4" etc.
_in_flight: set = set()  # material_ids with a delivered-but-not-yet-resulted task
_bootstrap_done = False
_bootstrap_ft_count = 3
_bootstrap_banks: list | None = None  # None = all banks
_bootstrap_types: list | None = None  # None = all types (FETCH_PROFILE + FETCH_TRANSACTIONS)

_STATE_FILE = HERE / ".mock_state.json"


def _save_state():
    """Persist task state to disk so debug reloader doesn't lose it."""
    try:
        state = {
            "injected": _injected,
            "task_queue": list(_task_queue),
            "in_flight": list(_in_flight),
            "bootstrap_done": _bootstrap_done,
            "pending_by_key": {f"{k[0]}|{k[1]}": v for k, v in _pending_by_key.items()},
        }
        _STATE_FILE.write_text(json.dumps(state, default=str), encoding="utf-8")
    except Exception as e:
        print(f"[mock] failed to save state: {e}")


def _load_state() -> bool:
    """Restore state from disk. Returns True if loaded."""
    global _bootstrap_done
    if not _STATE_FILE.exists():
        return False
    try:
        state = json.loads(_STATE_FILE.read_text(encoding="utf-8"))
        _injected.clear()
        _injected.extend(state.get("injected", []))
        _task_queue.clear()
        _task_queue.extend(state.get("task_queue", []))
        _in_flight.clear()
        _in_flight.update(state.get("in_flight", []))
        _bootstrap_done = state.get("bootstrap_done", False)
        _pending_by_key.clear()
        for k, v in state.get("pending_by_key", {}).items():
            parts = k.split("|", 1)
            if len(parts) == 2:
                _pending_by_key[(parts[0], parts[1])] = v
        print(f"[mock] restored state: {len(_injected)} injected, "
              f"{len(_task_queue)} queued, bootstrap={'done' if _bootstrap_done else 'pending'}")
        return True
    except Exception as e:
        print(f"[mock] failed to load state: {e}")
        return False


def ok(data=None):
    return jsonify({"success": True, "data": data if data is not None else {}})


def log(tag, obj):
    text = json.dumps(obj, ensure_ascii=False)
    if len(text) > 400:
        text = text[:400] + "…"
    print(f"[{time.strftime('%H:%M:%S')}] {tag}: {text}")


# ---------------------------------------------------------------- startup load
def load_default_profile():
    global _bank_profiles
    p = HERE / "default_profile.json"
    if not p.exists():
        print(f"[mock] no {p.name} found — profile starts empty")
        return
    data = json.loads(p.read_text(encoding="utf-8"))
    _bank_profiles = data.get("bank_profiles", [])
    mats = sum(len(bp.get("materials", [])) for bp in _bank_profiles)

    # Build material_id → device_label map for report grouping
    _device_label_by_material.clear()
    for bp in _bank_profiles:
        label = bp.get("device_label") or (bp.get("device_id", "")[:8] + "…")
        for mat in bp.get("materials", []):
            mid = mat.get("id")
            if mid:
                _device_label_by_material[mid] = label

    print(f"[mock] loaded {p.name}: {len(_bank_profiles)} bank_profiles, {mats} materials")


def load_pool():
    pool_dir = HERE / "scenarios" / "pool"
    if not pool_dir.exists():
        print(f"[mock] pool dir {pool_dir} missing — bootstrap disabled")
        return
    count = 0
    for f in sorted(pool_dir.glob("*.json")):
        try:
            task = json.loads(f.read_text(encoding="utf-8"))
        except Exception as e:
            print(f"[mock] skipping {f.name}: {e}")
            continue
        if task.get("type") != "FETCH_TRANSACTIONS":
            continue
        mid = task.get("material_id")
        if not mid:
            continue
        task["_source"] = f.name
        _pool_by_material[mid].append(task)
        count += 1
    print(f"[mock] loaded pool: {count} FETCH_TRANSACTIONS across "
          f"{len(_pool_by_material)} materials")
    for mid, lst in _pool_by_material.items():
        print(f"       {mid}: {len(lst)} tasks")


def enqueue_task(task: dict) -> dict:
    """Attach _task_id, store in queue, track in _injected."""
    task = copy.deepcopy(task)
    tid = str(uuid.uuid4())
    task["_task_id"] = tid
    entry = {
        "id": tid,
        "task": task,
        "injected_at": time.time(),
        "result": None,
        "result_at": None,
        "status": "pending",
    }
    _injected.append(entry)
    idx = len(_injected) - 1
    key = (task.get("material_id"), task.get("type"))
    _pending_by_key[key].append(idx)
    _task_queue.append(task)
    return entry


def bootstrap_tasks():
    """Queue 1 FETCH_PROFILE + N FETCH_TRANSACTIONS per seeded material."""
    global _bootstrap_done
    if _bootstrap_done:
        return
    queued = 0
    for bp in _bank_profiles:
        bank = bp.get("bank_name")
        if _bootstrap_banks and bank not in _bootstrap_banks:
            continue
        for mat in bp.get("materials", []):
            mid = mat.get("id")
            if not mid:
                continue
            # 1 × FETCH_PROFILE
            if not _bootstrap_types or "FETCH_PROFILE" in _bootstrap_types:
                enqueue_task({
                    "bank_name": bank,
                    "material_id": mid,
                    "type": "FETCH_PROFILE",
                    "body": {},
                    "_source": "bootstrap",
                })
                queued += 1

            # N × random FETCH_TRANSACTIONS from pool
            if not _bootstrap_types or "FETCH_TRANSACTIONS" in _bootstrap_types:
                pool = _pool_by_material.get(mid, [])
                if not pool:
                    print(f"[mock] bootstrap: no pool tasks for {mid} ({bank})")
                    continue
                pick = random.sample(pool, min(_bootstrap_ft_count, len(pool)))
                for t in pick:
                    enqueue_task(t)
                    queued += 1
    _bootstrap_done = True
    _save_state()
    print(f"[mock] bootstrap queued {queued} tasks")


# ---------------------------------------------------------------- auth
@app.post("/api/v1/auth/login")
def auth_login():
    body = request.get_json(silent=True) or {}
    log("POST /auth/login", body)
    with _lock:
        bootstrap_tasks()
    return ok({
        "access_token": "mock-access-token",
        "refresh_token": "mock-refresh-token",
        "expires_in": 3600,
    })


@app.post("/api/v1/auth/refresh_token")
def auth_refresh():
    return ok({
        "access_token": "mock-access-token",
        "refresh_token": "mock-refresh-token",
        "expires_in": 3600,
    })


# ---------------------------------------------------------------- desktop
@app.get("/api/v1/desktop/")
def desktop_list():
    return ok([{
        "id": _desktop_id,
        "profile_id": _profile_id,
        "hidden": False,
        "name": "mock-desktop",
    }])


@app.post("/api/v1/desktop/")
def desktop_create():
    body = request.get_json(silent=True) or {}
    log("POST /desktop/", body)
    return ok({"id": _desktop_id, "profile_id": _profile_id})


# ---------------------------------------------------------------- device
@app.get("/api/v1/device/<desktop_id>")
def device_list(desktop_id):
    return ok(_devices_by_desktop.get(desktop_id, []))


@app.post("/api/v1/device/")
def device_create():
    body = request.get_json(silent=True) or {}
    log("POST /device/", body)
    api_id = str(uuid.uuid4())
    dev = {
        "id": api_id,
        "name": body.get("name", "unknown"),
        "status": body.get("status", "OFFLINE"),
        "screen_width": body.get("screen_width", 0),
        "screen_height": body.get("screen_height", 0),
        "battery": body.get("battery", 0),
    }
    _devices_by_desktop.setdefault(_desktop_id, []).append(dev)
    return ok(dev)


@app.patch("/api/v1/device/<api_id>")
def device_patch(api_id):
    return ok({"id": api_id})


@app.delete("/api/v1/device/<api_id>")
def device_delete(api_id):
    return ok({"id": api_id})


@app.post("/api/v1/device/add_screenshot/<api_id>")
def device_screenshot(api_id):
    return ok({"id": api_id})


# ---------------------------------------------------------------- profile
@app.get("/api/v1/profile/current_profile")
def current_profile():
    return ok({
        "id": _profile_id,
        "bank_profiles": _bank_profiles,
    })


@app.post("/api/v1/profile/bank_profile")
def bank_profile_create():
    body = request.get_json(silent=True) or {}
    bp = dict(body)
    bp["id"] = bp.get("id") or str(uuid.uuid4())
    bp.setdefault("materials", [])
    _bank_profiles.append(bp)
    return ok(bp)


@app.patch("/api/v1/profile/bank_profile/<bp_id>/<state>")
def bank_profile_toggle(bp_id, state):
    return ok({"id": bp_id, "state": state})


@app.patch("/api/v1/profile/bank_profile/<bp_id>")
def bank_profile_update(bp_id):
    body = request.get_json(silent=True) or {}
    log("PATCH /bank_profile", {"id": bp_id, **body})
    for bp in _bank_profiles:
        if bp.get("id") == bp_id:
            bp.update(body)
            return ok(bp)
    # Не найден — создаём
    bp = dict(body)
    bp["id"] = bp_id
    bp.setdefault("materials", [])
    _bank_profiles.append(bp)
    return ok(bp)


@app.post("/api/v1/profile/material")
def material_create():
    body = request.get_json(silent=True) or {}
    mat = dict(body)
    mat["id"] = mat.get("id") or str(uuid.uuid4())
    return ok(mat)


@app.patch("/api/v1/profile/material/<mat_id>/<state>")
def material_toggle(mat_id, state):
    return ok({"id": mat_id, "state": state})


# ---------------------------------------------------------------- tasks
@app.get("/api/v1/task/get_tasks")
def get_tasks():
    """Deliver at most 1 task per material per poll.

    A material is blocked until the previous task's result arrives via
    POST /task/task_result.  This prevents the 5-min expire window in
    EventHandler from killing tasks that were just waiting in queue.
    """
    material_ids = request.args.getlist("materials_id")
    with _lock:
        if not _task_queue:
            return ok([])
        delivered = []
        delivered_mats = set()
        kept = deque()
        while _task_queue:
            t = _task_queue.popleft()
            mid = t.get("material_id")
            # Filter by requested materials
            if material_ids and mid not in material_ids:
                kept.append(t)
                continue
            # Skip if this material already has an in-flight task
            if mid in _in_flight or mid in delivered_mats:
                kept.append(t)
                continue
            delivered.append(t)
            delivered_mats.add(mid)
            _in_flight.add(mid)
        _task_queue.extend(kept)
    if delivered:
        _save_state()
        log("GET /task/get_tasks -> delivered",
            [{"type": t.get("type"), "material_id": t.get("material_id")}
             for t in delivered])
    return ok(delivered)


@app.post("/api/v1/task/task_result")
def task_result():
    body = request.get_json(silent=True) or {}
    mid = body.get("material_id")
    log("POST /task/task_result",
        {"type": body.get("type"), "material_id": mid})

    with _lock:
        # Unblock this material for the next task delivery
        _in_flight.discard(mid)

        # Клиент присылает ошибки с type="ERROR", но оригинальный тип задачи
        # лежит в data.event_type — им и матчимся, иначе ошибка повиснет
        # как unsolicited без привязки к задаче/устройству.
        rtype = body.get("type")
        if rtype == "ERROR":
            data = body.get("data") or {}
            rtype = data.get("event_type") or rtype

        key = (mid, rtype)
        idx = None
        if _pending_by_key[key]:
            idx = _pending_by_key[key].popleft()
        if idx is not None:
            _injected[idx]["result"] = body
            _injected[idx]["result_at"] = time.time()
            _injected[idx]["status"] = "completed"
        else:
            _injected.append({
                "id": str(uuid.uuid4()),
                "task": None,
                "injected_at": None,
                "result": body,
                "result_at": time.time(),
                "status": "unsolicited",
            })
        _save_state()
    return ok({})


# ---------------------------------------------------------------- monitoring
_monitoring_logs: list = []  # {type, event, message, has_image, image_id}
_SCREENSHOTS_DIR = HERE / ".mock_screenshots"


@app.post("/monitoring/log")
def monitoring_log():
    mtype = request.form.get("type", "")
    mevent = request.form.get("event", "")
    message = request.form.get("message", "")
    image_file = request.files.get("image")

    image_id = None
    if image_file:
        image_id = str(uuid.uuid4())
        _SCREENSHOTS_DIR.mkdir(exist_ok=True)
        (_SCREENSHOTS_DIR / f"{image_id}.png").write_bytes(image_file.read())

    entry = {
        "type": mtype,
        "event": mevent,
        "message": message,
        "has_image": image_id is not None,
        "image_id": image_id,
        "timestamp": time.time(),
    }
    with _lock:
        _monitoring_logs.append(entry)

    # Привязываем скриншот к задаче по internal_task_id
    internal_tid = request.form.get("internal_task_id", "")
    if image_id:
        if not internal_tid:
            print(f"[mock] WARNING: monitoring_log without internal_task_id, screenshot not linked")
        else:
            matched = False
            with _lock:
                for e in reversed(_injected):
                    r = e.get("result")
                    if r and str(r.get("internal_task_id", "")) == internal_tid:
                        e["screenshot_id"] = image_id
                        matched = True
                        break
            if matched:
                _save_state()
            else:
                print(f"[mock] WARNING: no task found for internal_task_id={internal_tid}")

    log("POST /monitoring/log", {"type": mtype, "event": mevent,
                                  "has_image": image_id is not None,
                                  "message": message[:100]})
    return ok({})


@app.get("/_admin/screenshot/<image_id>")
def get_screenshot(image_id):
    path = _SCREENSHOTS_DIR / f"{image_id}.png"
    if not path.exists():
        return "not found", 404
    return Response(path.read_bytes(), mimetype="image/png")


# ---------------------------------------------------------------- admin
@app.post("/_admin/inject")
def admin_inject():
    body = request.get_json(silent=True)
    if body is None:
        return jsonify({"error": "json body required"}), 400
    tasks = body if isinstance(body, list) else [body]
    with _lock:
        for t in tasks:
            enqueue_task(t)
    log("_admin/inject", {"queued": len(tasks)})
    return ok({"queued": len(tasks)})


@app.post("/_admin/seed_profile")
def admin_seed_profile():
    body = request.get_json(silent=True) or {}
    global _bank_profiles
    _bank_profiles = body.get("bank_profiles", [])
    return ok({"bank_profiles": len(_bank_profiles)})


@app.post("/_admin/seed_devices")
def admin_seed_devices():
    body = request.get_json(silent=True) or []
    _devices_by_desktop[_desktop_id] = body
    return ok({"devices": len(body)})


@app.post("/_admin/bootstrap")
def admin_bootstrap():
    """Re-run bootstrap manually (useful if ARC was already logged in)."""
    global _bootstrap_done
    with _lock:
        _bootstrap_done = False
        bootstrap_tasks()
    return ok({"queued": sum(1 for e in _injected if e["status"] == "pending")})


@app.get("/_admin/report")
def admin_report():
    """Full task ↔ result pairing report."""
    with _lock:
        errors = sum(1 for e in _injected if e["status"] == "completed" and _is_error_entry(e))
        summary = {
            "total": len(_injected),
            "pending": sum(1 for e in _injected if e["status"] == "pending"),
            "completed": sum(1 for e in _injected if e["status"] == "completed") - errors,
            "errors": errors,
            "unsolicited": sum(1 for e in _injected if e["status"] == "unsolicited"),
        }
        return jsonify({
            "summary": summary,
            "entries": _injected,
        })


@app.get("/_admin/report/pending")
def admin_report_pending():
    with _lock:
        return jsonify([e for e in _injected if e["status"] == "pending"])


def _is_error_entry(e) -> bool:
    """Check if a completed entry has an error in result data."""
    result = e.get("result")
    if not result:
        return False
    data = result.get("data")
    if isinstance(data, dict) and data.get("status") == "error":
        return True
    return False


def _snapshot_entries_and_summary():
    entries = list(_injected)
    errors = sum(1 for e in entries if e["status"] == "completed" and _is_error_entry(e))
    summary = {
        "total": len(entries),
        "pending": sum(1 for e in entries if e["status"] == "pending"),
        "completed": sum(1 for e in entries if e["status"] == "completed") - errors,
        "errors": errors,
        "unsolicited": sum(1 for e in entries if e["status"] == "unsolicited"),
    }
    return entries, summary


@app.get("/_admin/report/html")
def admin_report_html():
    """Pretty HTML view of task ↔ result pairs. Auto-refreshes via JS."""
    with _lock:
        entries, summary = _snapshot_entries_and_summary()
    return Response(render_report_html(entries, summary), mimetype="text/html")


@app.get("/_admin/report/fragment")
def admin_report_fragment():
    """JSON fragment for JS auto-refresh: rendered body HTML + summary counts."""
    with _lock:
        entries, summary = _snapshot_entries_and_summary()
    body = _render_grouped_blocks(entries) or '<div class="empty">Отчёт пуст</div>'
    return jsonify({"html": body, "summary": summary})


def _fmt_ts(ts):
    if not ts:
        return "—"
    return time.strftime("%H:%M:%S", time.localtime(ts))


def _esc(s: str) -> str:
    return (s.replace("&", "&amp;").replace("<", "&lt;")
             .replace(">", "&gt;").replace('"', "&quot;"))


def render_entry_html(e) -> str:
    import html as _html
    status = e["status"]
    is_error = _is_error_entry(e)
    display_status = "error" if is_error else status
    task = e.get("task") or {}
    result = e.get("result")
    ttype = _html.escape(task.get("type", "?"))
    mid = _html.escape((task.get("material_id") or "")[:8])
    src = _html.escape(task.get("_source", ""))
    bank = _html.escape(task.get("bank_name", ""))
    injected_at = _fmt_ts(e.get("injected_at"))
    result_at = _fmt_ts(e.get("result_at"))

    tid = _html.escape(e.get("id", ""))

    def json_block(obj):
        if obj is None:
            return '<span class="muted">—</span>'
        text = json.dumps(obj, ensure_ascii=False, indent=2)
        escaped = _html.escape(text)
        # data-json с escaped JSON для копирования
        raw = _html.escape(text, quote=True)
        return (f'<div class="json-wrap">'
                f'<button class="copy-btn" onclick="copyJson(this)" data-json="{raw}">Копировать</button>'
                f'<pre>{escaped}</pre></div>')

    result_summary = ""
    if is_error:
        d = result.get("data", {}) if result else {}
        result_summary = f'<div class="err">ERROR: {_html.escape(str(d.get("description", "")))}</div>'
    elif result and isinstance(result.get("data"), list):
        result_summary = f'<div class="muted">{len(result["data"])} items</div>'

    scr_id = e.get("screenshot_id")
    scr_pane = ""
    if scr_id:
        scr_pane = f"""
              <div class="pane screenshot-pane">
                <div class="label">Screenshot</div>
                <img src="/_admin/screenshot/{scr_id}" class="screenshot" loading="lazy">
              </div>"""

    has_screenshot = bool(scr_id)
    panes_cls = "panes panes-3" if has_screenshot else "panes"

    # Успешные — вся задача свёрнута, ошибки — развёрнуты
    if display_status == "completed":
        panes_html = f"""
          <div class="toggle-wrap" data-tid="{tid}">
            <button class="toggle-btn" onclick="this.parentElement.classList.toggle('open')">Показать JSON</button>
            <div class="toggle-content">
              <div class="{panes_cls}">
                <div class="pane task"><div class="label">Task JSON</div>{json_block(task)}</div>
                <div class="pane result"><div class="label">Result JSON</div>{result_summary}{json_block(result)}</div>
                {scr_pane}
              </div>
            </div>
          </div>"""
    else:
        panes_html = f"""
          <div class="{panes_cls}">
            <div class="pane task"><div class="label">Task JSON</div>{json_block(task)}</div>
            <div class="pane result"><div class="label">Result JSON</div>{result_summary}{json_block(result)}</div>
            {scr_pane}
          </div>"""

    return f"""
      <div class="entry {display_status}">
        <div class="head">
          <span class="badge {display_status}">{display_status}</span>
          <span class="type">{ttype}</span>
          <span class="bank">{bank}</span>
          <span class="mid">{mid}…</span>
          <span class="src">{src}</span>
          <span class="times">inj {injected_at} → res {result_at}</span>
        </div>
        {panes_html}
      </div>
    """


def render_profile_section() -> str:
    """Render loaded bank profiles / materials as an HTML info block."""
    import html as _html
    if not _bank_profiles:
        return '<div class="profile-section muted">Профиль не загружен</div>'

    # Group by device
    devices: dict = {}
    for bp in _bank_profiles:
        dev_id = bp.get("device_id", "?")
        label = bp.get("device_label") or (dev_id[:8] + "…")
        if dev_id not in devices:
            devices[dev_id] = {"label": label, "profiles": []}
        devices[dev_id]["profiles"].append(bp)

    device_blocks = []
    for dev_id, dev in devices.items():
        label = _html.escape(dev["label"])
        dev_mats = sum(len(bp.get("materials", [])) for bp in dev["profiles"])
        bp_cards = []
        for bp in dev["profiles"]:
            bank = _html.escape(bp.get("bank_name", "?"))
            first = bp.get("first_name") or ""
            last = bp.get("last_name") or ""
            name = _html.escape(f"{first} {last}".strip() or "—")
            phone = _html.escape(bp.get("phone_number") or "—")
            mats = bp.get("materials", [])
            mat_rows = []
            for m in mats:
                mid = _html.escape(m.get("id", "?")[:12])
                card = _html.escape(m.get("card_number") or "—")
                cur = m.get("currency", "")
                state = _html.escape(m.get("state", "?"))
                # Count pool tasks for this material
                pool_n = len(_pool_by_material.get(m.get("id", ""), []))
                pool_badge = (f'<span class="pool-ok">{pool_n}</span>'
                              if pool_n > 0 else '<span class="muted">0</span>')
                mat_rows.append(
                    f'<tr><td class="mono">{mid}…</td>'
                    f'<td>{card}</td><td>{cur}</td>'
                    f'<td><span class="badge-sm {state}">{state}</span></td>'
                    f'<td>{pool_badge}</td></tr>'
                )
            mat_table = ""
            if mat_rows:
                mat_table = (
                    '<table class="mat-table">'
                    '<tr><th>Material ID</th><th>Карта</th><th>Валюта</th>'
                    '<th>Статус</th><th>Пул</th></tr>'
                    + "".join(mat_rows)
                    + '</table>'
                )
            bp_cards.append(
                f'<div class="bp-card">'
                f'<div class="bp-header">'
                f'<span class="bp-bank">{bank}</span>'
                f'<span class="bp-name">{name}</span>'
                f'<span class="bp-phone">{phone}</span>'
                f'</div>'
                f'{mat_table}'
                f'</div>'
            )

        device_blocks.append(
            f'<div class="dev-group">'
            f'<div class="dev-group-header">'
            f'<span class="dev-label">{label}</span>'
            f'<span class="muted">{len(dev["profiles"])} профилей, {dev_mats} материалов</span>'
            f'</div>'
            f'<div class="bp-grid">{"".join(bp_cards)}</div>'
            f'</div>'
        )

    pool_count = sum(len(v) for v in _pool_by_material.values())
    pool_info = (f'<span class="pool-ok">{pool_count} задач в пуле</span>'
                 if pool_count > 0
                 else '<span class="pool-empty">пул пуст</span>')
    total_mats = sum(len(bp.get("materials", [])) for bp in _bank_profiles)

    return (
        '<details class="profile-section" open>'
        '<summary>Загруженные данные '
        f'<span class="muted">({len(devices)} устройств, '
        f'{len(_bank_profiles)} профилей, '
        f'{total_mats} материалов, '
        f'{pool_info})</span></summary>'
        + "".join(device_blocks)
        + '</details>'
    )


def _render_grouped_blocks(entries) -> str:
    import html as _html

    # Group by device label → bank_name
    devices: dict = defaultdict(lambda: defaultdict(list))
    for e in entries:
        task = e.get("task") or {}
        mid = task.get("material_id")
        label = _device_label_by_material.get(mid) or (
            "(без устройства)" if mid is None else f"{mid[:8]}…"
        )
        bank = task.get("bank_name", "unknown")
        devices[label][bank].append(e)

    group_blocks = []
    for label in sorted(devices.keys()):
        banks = devices[label]
        # Device-level stats
        all_entries = [e for bl in banks.values() for e in bl]
        g_total = len(all_entries)
        g_err = sum(1 for e in all_entries if _is_error_entry(e))
        g_done = sum(1 for e in all_entries if e["status"] == "completed") - g_err
        g_pend = sum(1 for e in all_entries if e["status"] == "pending")
        err_badge = f' <span style="color:var(--unsolicited)">ошибки: {g_err}</span>' if g_err else ''

        bank_blocks = []
        for bank in sorted(banks.keys()):
            bentries = banks[bank]
            b_total = len(bentries)
            b_err = sum(1 for e in bentries if _is_error_entry(e))
            b_done = sum(1 for e in bentries if e["status"] == "completed") - b_err
            b_pend = sum(1 for e in bentries if e["status"] == "pending")
            b_err_badge = f' <span style="color:var(--unsolicited)">{b_err}</span>' if b_err else ''
            rows_html = "\n".join(render_entry_html(e) for e in bentries)
            bank_blocks.append(
                f'<div class="bank-group">'
                f'<h3><span class="bank">{_html.escape(bank)}</span>'
                f'<span class="g-stats">'
                f'<span class="g-done">{b_done}</span>'
                f' / <span class="g-total">{b_total}</span>'
                f'{b_err_badge}'
                f' <span class="muted">(ожидают: {b_pend})</span>'
                f'</span></h3>'
                f'{rows_html}</div>'
            )

        group_blocks.append(f"""
          <section class="group">
            <h2>
              <span class="dev">{_html.escape(label)}</span>
              <span class="g-stats">
                <span class="g-done">{g_done}</span>
                / <span class="g-total">{g_total}</span>
                {err_badge}
                <span class="muted">(ожидают: {g_pend})</span>
              </span>
            </h2>
            {"".join(bank_blocks)}
          </section>
        """)

    return "\n".join(group_blocks)


def render_report_html(entries, summary) -> str:
    body_rows = _render_grouped_blocks(entries) or '<div class="empty">Отчёт пуст — бутстрап ещё не сработал или результаты ещё не пришли.</div>'

    return f"""<!doctype html>
<html lang="ru">
<head>
<meta charset="utf-8">
<title>ARC mock — отчёт</title>
<style>
  :root {{
    --bg: #0f1115;
    --panel: #1a1d25;
    --muted: #7d8594;
    --text: #e6e8ec;
    --task: #1f2430;
    --result: #1b2420;
    --pending: #c9a227;
    --completed: #4caf50;
    --unsolicited: #d04343;
    --border: #2a2f3a;
  }}
  * {{ box-sizing: border-box; }}
  body {{
    margin: 0; padding: 20px;
    background: var(--bg); color: var(--text);
    font-family: -apple-system, "SF Pro Text", Helvetica, Arial, sans-serif;
    font-size: 13px;
  }}
  h1 {{ margin: 0 0 8px; font-size: 18px; }}
  .summary {{
    display: flex; gap: 12px; flex-wrap: wrap;
    margin-bottom: 16px; font-size: 13px;
  }}
  .summary .cell {{
    background: var(--panel); padding: 6px 12px;
    border: 1px solid var(--border); border-radius: 4px;
  }}
  .summary .cell .n {{ font-size: 16px; font-weight: bold; }}
  .summary .pending .n {{ color: var(--pending); }}
  .summary .completed .n {{ color: var(--completed); }}
  .summary .unsolicited .n {{ color: var(--unsolicited); }}
  .entry {{
    background: var(--panel);
    border: 1px solid var(--border);
    border-radius: 6px;
    margin-bottom: 12px;
    overflow: hidden;
  }}
  .entry.completed {{ border-left: 4px solid var(--completed); }}
  .entry.error {{ border-left: 4px solid var(--unsolicited); }}
  .entry.pending {{ border-left: 4px solid var(--pending); }}
  .entry.unsolicited {{ border-left: 4px solid var(--unsolicited); }}
  .head {{
    display: flex; align-items: center; gap: 10px;
    padding: 8px 12px; background: #161921; font-size: 12px;
    flex-wrap: wrap;
  }}
  .badge {{
    padding: 2px 8px; border-radius: 10px; font-weight: 600;
    text-transform: uppercase; font-size: 10px;
  }}
  .badge.pending {{ background: var(--pending); color: #1a1600; }}
  .badge.completed {{ background: var(--completed); color: #0a1a0a; }}
  .badge.error {{ background: var(--unsolicited); color: #200; }}
  .badge.unsolicited {{ background: var(--unsolicited); color: #200; }}
  .type {{ font-weight: 600; color: #9cdcfe; }}
  .bank {{ color: #ffb86c; }}
  .mid {{ color: var(--muted); font-family: monospace; }}
  .src {{ color: var(--muted); font-style: italic; }}
  .times {{ color: var(--muted); margin-left: auto; font-family: monospace; }}
  .panes {{ display: grid; grid-template-columns: 1fr 1fr; gap: 1px; background: var(--border); }}
  .panes-3 {{ grid-template-columns: 1fr 1fr auto; }}
  .pane {{ padding: 10px 12px; }}
  .pane.task {{ background: var(--task); }}
  .pane.result {{ background: var(--result); }}
  .pane .label {{
    font-size: 10px; text-transform: uppercase; letter-spacing: 0.05em;
    color: var(--muted); margin-bottom: 4px;
  }}
  pre {{
    margin: 0; white-space: pre-wrap; word-break: break-word;
    font-family: "SF Mono", Menlo, Consolas, monospace; font-size: 12px;
    line-height: 1.45;
  }}
  .muted {{ color: var(--muted); font-style: italic; }}
  .err {{ color: #ff6b6b; font-weight: 600; margin-bottom: 4px; }}
  .toggle-wrap .toggle-content {{ display: none; }}
  .toggle-wrap.open .toggle-content {{ display: block; }}
  .toggle-btn {{
    background: var(--panel); color: var(--muted);
    border: 1px solid var(--border); border-radius: 4px;
    padding: 4px 12px; margin: 8px 12px;
    cursor: pointer; font-size: 11px;
    transition: background 0.15s, color 0.15s;
  }}
  .toggle-btn:hover {{ background: var(--border); color: var(--text); }}
  .json-wrap {{ position: relative; }}
  .copy-btn {{
    position: absolute; top: 6px; right: 6px;
    background: var(--border); color: var(--muted);
    border: none; border-radius: 4px;
    padding: 5px 12px; font-size: 12px;
    cursor: pointer; opacity: 0; transition: opacity 0.15s;
  }}
  .json-wrap:hover .copy-btn {{ opacity: 1; }}
  .copy-btn:hover {{ color: var(--text); background: #3a3f4a; }}
  .copy-btn.copied {{ color: var(--completed); }}
  .screenshot-pane {{ background: var(--panel); max-width: 280px; }}
  .screenshot {{ max-height: 200px; width: auto; border-radius: 4px; margin-top: 4px; cursor: pointer; transition: opacity 0.15s; }}
  .screenshot:hover {{ opacity: 0.8; }}
  .lightbox {{
    display: none; position: fixed; inset: 0; z-index: 1000;
    background: rgba(0,0,0,0.85); align-items: center; justify-content: center;
    cursor: zoom-out;
  }}
  .lightbox.open {{ display: flex; }}
  .lightbox img {{ max-width: 90vw; max-height: 90vh; border-radius: 6px; }}
  .empty {{ color: var(--muted); text-align: center; padding: 40px; }}
  a {{ color: #9cdcfe; }}
  .group {{
    margin-bottom: 24px;
    border: 1px solid var(--border);
    border-radius: 8px;
    background: #13161d;
    padding: 12px 16px;
  }}
  .group h2 {{
    margin: 0 0 12px;
    font-size: 15px;
    display: flex;
    align-items: baseline;
    gap: 10px;
    padding-bottom: 8px;
    border-bottom: 1px solid var(--border);
  }}
  .group h2 .dev {{ color: #ffb86c; font-weight: 700; }}
  .group h2 .g-stats {{ margin-left: auto; font-family: monospace; font-size: 13px; }}
  .group h2 .g-done {{ color: var(--completed); font-weight: 700; }}
  .group h2 .g-total {{ color: var(--muted); }}
  .bank-group {{
    margin: 8px 0 16px;
    padding-left: 12px;
    border-left: 2px solid var(--border);
  }}
  .bank-group h3 {{
    margin: 0 0 8px;
    font-size: 13px;
    display: flex;
    align-items: baseline;
    gap: 10px;
  }}
  .bank-group h3 .bank {{ color: #9cdcfe; font-weight: 600; }}
  .bank-group h3 .g-stats {{ margin-left: auto; font-family: monospace; font-size: 12px; }}
  .bank-group h3 .g-done {{ color: var(--completed); font-weight: 700; }}
  .bank-group h3 .g-total {{ color: var(--muted); }}
  .updating {{ opacity: 0.6; }}
  /* ─── Profile section ─── */
  .profile-section {{
    margin-bottom: 16px;
    border: 1px solid var(--border);
    border-radius: 6px;
    background: var(--panel);
    padding: 10px 14px;
  }}
  .profile-section summary {{
    cursor: pointer;
    font-weight: 600;
    font-size: 14px;
    padding: 4px 0;
    user-select: none;
  }}
  .bp-grid {{
    display: flex; flex-wrap: wrap; gap: 10px;
    margin-top: 10px;
  }}
  .bp-card {{
    background: #161921;
    border: 1px solid var(--border);
    border-radius: 6px;
    padding: 10px 12px;
    min-width: 320px;
    flex: 1;
  }}
  .bp-header {{
    display: flex; gap: 10px; align-items: center;
    margin-bottom: 8px; flex-wrap: wrap;
  }}
  .dev-label {{ color: #ffb86c; font-weight: 700; }}
  .bp-bank {{ color: #9cdcfe; font-weight: 600; }}
  .bp-name {{ color: var(--text); }}
  .bp-phone {{ color: var(--muted); font-family: monospace; font-size: 12px; }}
  .mat-table {{
    width: 100%;
    border-collapse: collapse;
    font-size: 12px;
  }}
  .mat-table th {{
    text-align: left;
    color: var(--muted);
    font-weight: 500;
    border-bottom: 1px solid var(--border);
    padding: 3px 6px;
    font-size: 10px;
    text-transform: uppercase;
    letter-spacing: 0.04em;
  }}
  .mat-table td {{
    padding: 4px 6px;
    border-bottom: 1px solid #1f232d;
  }}
  .mono {{ font-family: "SF Mono", Menlo, Consolas, monospace; }}
  .badge-sm {{
    padding: 1px 6px; border-radius: 8px;
    font-size: 10px; font-weight: 600; text-transform: uppercase;
  }}
  .badge-sm.enabled {{ background: var(--completed); color: #0a1a0a; }}
  .badge-sm.disabled {{ background: var(--muted); color: #1a1d25; }}
  .pool-ok {{ color: var(--completed); }}
  .pool-empty {{ color: var(--pending); }}
  .dev-group {{
    margin-top: 12px;
    border: 1px solid var(--border);
    border-radius: 6px;
    background: #13161d;
    padding: 10px 14px;
  }}
  .dev-group-header {{
    display: flex; align-items: baseline; gap: 10px;
    padding-bottom: 8px; margin-bottom: 10px;
    border-bottom: 1px solid var(--border);
  }}
  .dev-group-header .dev-label {{ font-size: 14px; }}
</style>
</head>
<body>
  <h1>ARC mock — отчёт <span class="muted" id="refresh-status">(автообновление 2 сек)</span></h1>
  <div class="summary">
    <div class="cell"><div class="n">{summary['total']}</div>всего</div>
    <div class="cell completed"><div class="n">{summary['completed']}</div>выполнено</div>
    <div class="cell unsolicited"><div class="n">{summary['errors']}</div>ошибки</div>
    <div class="cell pending"><div class="n">{summary['pending']}</div>в очереди</div>
  </div>
  {render_profile_section()}
  <div id="report-body">
    {body_rows}
  </div>
<script>
(function() {{
  const REFRESH_MS = 2000;
  const bodyEl = document.getElementById('report-body');
  const statusEl = document.getElementById('refresh-status');
  const summaryEls = {{
    total: document.querySelector('.summary .cell:nth-child(1) .n'),
    completed: document.querySelector('.summary .cell.completed .n'),
    errors: document.querySelector('.summary .cell.unsolicited .n'),
    pending: document.querySelector('.summary .cell.pending .n'),
  }};

  function saveToggleState() {{
    const state = new Set();
    bodyEl.querySelectorAll('.toggle-wrap[data-tid]').forEach(el => {{
      if (el.classList.contains('open')) state.add(el.dataset.tid);
    }});
    return state;
  }}

  function restoreToggleState(state) {{
    bodyEl.querySelectorAll('.toggle-wrap[data-tid]').forEach(el => {{
      if (state.has(el.dataset.tid)) el.classList.add('open');
    }});
    updateToggleLabels();
  }}

  function updateToggleLabels() {{
    bodyEl.querySelectorAll('.toggle-wrap').forEach(el => {{
      const btn = el.querySelector('.toggle-btn');
      if (btn) btn.textContent = el.classList.contains('open') ? 'Свернуть JSON' : 'Показать JSON';
    }});
  }}

  document.addEventListener('click', e => {{
    if (e.target.classList.contains('toggle-btn')) updateToggleLabels();
  }});

  async function tick() {{
    try {{
      const resp = await fetch('/_admin/report/fragment', {{cache: 'no-store'}});
      if (!resp.ok) throw new Error(resp.status);
      const data = await resp.json();
      const saved = saveToggleState();
      bodyEl.innerHTML = data.html;
      restoreToggleState(saved);
      summaryEls.total.textContent = data.summary.total;
      summaryEls.completed.textContent = data.summary.completed;
      summaryEls.errors.textContent = data.summary.errors;
      summaryEls.pending.textContent = data.summary.pending;
      statusEl.textContent = '(обновлено ' + new Date().toLocaleTimeString() + ')';
    }} catch (e) {{
      statusEl.textContent = '(ошибка обновления: ' + e + ')';
    }}
  }}

  setInterval(tick, REFRESH_MS);
}})();
</script>
<script>
function copyJson(btn) {{
  const text = btn.dataset.json;
  navigator.clipboard.writeText(text).then(() => {{
    btn.textContent = 'Скопировано';
    btn.classList.add('copied');
    setTimeout(() => {{ btn.textContent = 'Копировать'; btn.classList.remove('copied'); }}, 1500);
  }});
}}
</script>
<div class="lightbox" id="lightbox" onclick="this.classList.remove('open')">
  <img id="lightbox-img" src="" alt="">
</div>
<script>
document.addEventListener('click', function(e) {{
  if (e.target.classList.contains('screenshot')) {{
    const lb = document.getElementById('lightbox');
    document.getElementById('lightbox-img').src = e.target.src;
    lb.classList.add('open');
  }}
}});
document.addEventListener('keydown', function(e) {{
  if (e.key === 'Escape') document.getElementById('lightbox').classList.remove('open');
}});
</script>
</body>
</html>
"""


@app.post("/_admin/reset")
def admin_reset():
    global _bootstrap_done
    with _lock:
        _task_queue.clear()
        _injected.clear()
        _pending_by_key.clear()
        _in_flight.clear()
        _monitoring_logs.clear()
        _bootstrap_done = False
    if _SCREENSHOTS_DIR.exists():
        shutil.rmtree(_SCREENSHOTS_DIR)
    if _STATE_FILE.exists():
        _STATE_FILE.unlink()
    return ok({})


@app.get("/_admin/state")
def admin_state():
    with _lock:
        return jsonify({
            "queued_tasks": len(_task_queue),
            "injected": len(_injected),
            "completed": sum(1 for e in _injected if e["status"] == "completed"),
            "pending": sum(1 for e in _injected if e["status"] == "pending"),
            "bank_profiles": len(_bank_profiles),
            "pool_materials": len(_pool_by_material),
            "bootstrap_done": _bootstrap_done,
        })


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--host", default="127.0.0.1")
    parser.add_argument("--port", type=int, default=8888)
    parser.add_argument("--ft-per-material", type=int, default=3,
                        help="How many random FETCH_TRANSACTIONS to bootstrap per material")
    parser.add_argument("--banks", nargs="+", default=None,
                        help="Only bootstrap tasks for these banks (e.g. --banks ozon dushanbe_city_bank)")
    parser.add_argument("--seed", type=int, default=None,
                        help="RNG seed for reproducible bootstrap picks")
    parser.add_argument("--types", nargs="+", default=None,
                        help="Only bootstrap these task types (e.g. --types FETCH_TRANSACTIONS)")
    parser.add_argument("--debug", action="store_true",
                        help="Run Flask in debug mode (auto-reload on code changes)")
    args = parser.parse_args()

    _bootstrap_ft_count = args.ft_per_material
    _bootstrap_banks = args.banks
    _bootstrap_types = args.types
    if _bootstrap_banks:
        print(f"[mock] bootstrap limited to banks: {_bootstrap_banks}")
    if _bootstrap_types:
        print(f"[mock] bootstrap limited to types: {_bootstrap_types}")
    if args.seed is not None:
        random.seed(args.seed)

    load_default_profile()
    load_pool()

    is_reload = os.environ.get("WERKZEUG_RUN_MAIN") == "true"

    if args.debug and is_reload and _load_state():
        # Auto-reload в debug — восстанавливаем состояние
        print("[mock] auto-reload: state restored from disk")
    else:
        # Первый запуск (или без --debug) — чистим всё
        _task_queue.clear()
        _injected.clear()
        _pending_by_key.clear()
        _in_flight.clear()
        _monitoring_logs.clear()
        _bootstrap_done = False
        if _STATE_FILE.exists():
            _STATE_FILE.unlink()
        import shutil
        if _SCREENSHOTS_DIR.exists():
            shutil.rmtree(_SCREENSHOTS_DIR)
        # Чистим events в БД приложения чтобы не было "App restarted" при старте
        try:
            import configparser
            import sqlite3
            project_root = (HERE / ".." / "..").resolve()
            for cfg in [project_root / "config.ini", project_root / "build_test" / "config.ini"]:
                if cfg.exists():
                    cp = configparser.ConfigParser()
                    cp.read(str(cfg), encoding="utf-8")
                    raw = cp.get("db", "dbPath", fallback="")
                    if raw:
                        db = Path(os.path.expanduser(raw))
                        if not db.is_absolute():
                            db = cfg.parent / db
                        if db.exists():
                            conn = sqlite3.connect(str(db))
                            n = conn.execute("SELECT count(*) FROM events").fetchone()[0]
                            if n > 0:
                                conn.execute("DELETE FROM events")
                                conn.commit()
                                print(f"[mock] cleaned {n} events from {db.name}")
                            conn.close()
                    break
        except Exception as e:
            print(f"[mock] warning: could not clean events DB: {e}")
        print("[mock] starting fresh (clean slate)")

    app.run(host=args.host, port=args.port, threaded=True, debug=args.debug)