# -*- coding: utf-8 -*-
"""
Mochi French & Anki Standalone Web Server
Học từ vựng trên trình duyệt từ mọi thiết bị (PC, Điện thoại, Tablet) qua Wi-Fi LAN hoặc Internet 4G/5G
Không cần mở Anki Desktop, không cần cài AnkiDroid.
"""

import os
import sys
import re
import html
import json
import time
import shutil
import socket
import sqlite3
import random
import mimetypes
import threading
import subprocess
import urllib.parse
import urllib.request
from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer

# Ensure UTF-8 console output
try:
    sys.stdout.reconfigure(encoding='utf-8')
    sys.stderr.reconfigure(encoding='utf-8')
except Exception:
    pass

IS_CLOUD_ENV = bool(os.environ.get("SPACE_ID") or os.environ.get("RENDER") or os.environ.get("CLOUD_MODE"))
PORT = int(os.environ.get("PORT", os.environ.get("MOCHI_PORT", 7860 if IS_CLOUD_ENV else 8686)))
BASE_DIR = os.path.dirname(os.path.abspath(__file__))

ANKI_USER_DIR = r"E:\AnkiPortable\AnkiData\User 1"
ANKI_COL_PATH = os.path.join(ANKI_USER_DIR, "collection.anki2")
LOCAL_MEDIA_DIR = os.path.join(ANKI_USER_DIR, "collection.media")
CLOUD_MEDIA_DIR = os.path.join(BASE_DIR, "collection.media")
ANKI_MEDIA_DIR = LOCAL_MEDIA_DIR if os.path.isdir(LOCAL_MEDIA_DIR) else CLOUD_MEDIA_DIR
MEDIA_PACK_TAR = os.path.join(BASE_DIR, "media_pack.tar")

SNAPSHOT_DB_PATH = os.path.join(BASE_DIR, "anki_snapshot.db")
PROGRESS_DB_PATH = os.path.join(BASE_DIR, "web_progress.db")

db_lock = threading.Lock()
tunnel_state = {
    "running": False,
    "public_url": None,
    "status": "idle",
    "proc": None,
    "error": None
}


def get_lan_ip():
    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.settimeout(0.5)
        s.connect(("8.8.8.8", 80))
        ip = s.getsockname()[0]
        s.close()
        return ip
    except Exception:
        return "127.0.0.1"


def clean_html(raw):
    if not raw:
        return ""
    txt = str(raw)
    txt = re.sub(r"\[sound:[^\]]+\]", "", txt)
    txt = re.sub(r"\{\{c\d+::(.*?)(?:::.*?)?\}\}", r"\1", txt, flags=re.IGNORECASE | re.DOTALL)
    txt = re.sub(r"<br\s*/?>", " ", txt, flags=re.IGNORECASE)
    txt = re.sub(r"<[^>]+>", "", txt)
    txt = html.unescape(txt)
    txt = txt.replace("\xa0", " ").replace("&nbsp;", " ")
    return re.sub(r"\s+", " ", txt).strip()


def extract_sound_filename(raw):
    if not raw:
        return ""
    txt = str(raw).strip()
    m = re.search(r"\[sound:([^\]]+)\]", txt)
    if m:
        return m.group(1).strip()
    txt = clean_html(txt)
    if txt.lower().endswith((".mp3", ".wav", ".ogg", ".m4a", ".aac", ".flac")):
        return txt
    return ""


def is_anki_connect_alive():
    try:
        with socket.create_connection(("127.0.0.1", 8765), timeout=0.12):
            return True
    except Exception:
        return False


def anki_connect_invoke(action, **params):
    """Gọi AnkiConnect nếu Anki Desktop đang mở (http://127.0.0.1:8765)."""
    if not is_anki_connect_alive():
        raise ConnectionError("AnkiConnect is not running")
    import urllib.request
    payload = json.dumps({"action": action, "version": 6, "params": params}).encode("utf-8")
    req = urllib.request.Request("http://127.0.0.1:8765", data=payload, headers={"Content-Type": "application/json"})
    with urllib.request.urlopen(req, timeout=0.8) as resp:
        return json.loads(resp.read().decode("utf-8"))


def init_progress_db():
    with db_lock:
        conn = sqlite3.connect(PROGRESS_DB_PATH)
        conn.execute("""
            CREATE TABLE IF NOT EXISTS card_progress (
                nid INTEGER PRIMARY KEY,
                deck_name TEXT,
                word TEXT,
                meaning TEXT,
                pos TEXT,
                pronunciation TEXT,
                explain TEXT,
                example TEXT,
                example_translated TEXT,
                collocation TEXT,
                synonym TEXT,
                antonym TEXT,
                audio_word TEXT,
                audio_example TEXT,
                image TEXT,
                choices_json TEXT,
                level INTEGER DEFAULT 0,
                ivl INTEGER DEFAULT 0,
                ease INTEGER DEFAULT 2500,
                due_ts INTEGER DEFAULT 0,
                reps INTEGER DEFAULT 0,
                lapses INTEGER DEFAULT 0,
                last_review_ts INTEGER DEFAULT 0
            )
        """)
        conn.execute("""
            CREATE TABLE IF NOT EXISTS review_log (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                nid INTEGER,
                deck_name TEXT,
                is_correct INTEGER,
                ease_chosen INTEGER,
                old_level INTEGER,
                new_level INTEGER,
                reviewed_at INTEGER
            )
        """)
        conn.execute("""
            CREATE TABLE IF NOT EXISTS pending_anki_writes (
                nid INTEGER PRIMARY KEY,
                is_correct INTEGER,
                ease_chosen INTEGER,
                new_ivl INTEGER,
                old_ivl INTEGER,
                ease INTEGER,
                reps INTEGER,
                lapses INTEGER,
                updated_at INTEGER
            )
        """)
        conn.execute("CREATE INDEX IF NOT EXISTS idx_deck_name ON card_progress(deck_name)")
        conn.execute("CREATE INDEX IF NOT EXISTS idx_level ON card_progress(level)")
        conn.execute("CREATE INDEX IF NOT EXISTS idx_due_ts ON card_progress(due_ts)")
        conn.commit()
        conn.close()


def ivl_to_level(ctype, ivl):
    """
    Quy đổi trạng thái thẻ thực tế trong Anki sang 5 cấp độ MochiVocab:
    - ctype == 0: Từ mới chưa học (Level 0)
    - ctype in (1, 3) hoặc ivl <= 3 ngày: Cấp độ 1
    - ivl 4..10 ngày: Cấp độ 2
    - ivl 11..21 ngày: Cấp độ 3
    - ivl 22..45 ngày: Cấp độ 4
    - ivl > 45 ngày: Cấp độ 5 (Master)
    """
    if ctype == 0:
        return 0
    if ctype in (1, 3) or ivl <= 3:
        return 1
    elif ivl <= 10:
        return 2
    elif ivl <= 21:
        return 3
    elif ivl <= 45:
        return 4
    else:
        return 5


def push_review_to_anki(nid, is_correct, ease_chosen, new_ivl, old_ivl, ease, reps, lapses):
    """
    Đồng bộ kết quả ôn tập từ Web ngược về Anki:
    1. Nếu Anki Desktop đang mở: Cập nhật trực tiếp qua AnkiConnect (setSpecificValueOfCard + insertReviews).
    2. Nếu Anki Desktop đang đóng: Ghi trực tiếp vào E:\\AnkiPortable\\AnkiData\\User 1\\collection.anki2.
    """
    now_ts = int(time.time())
    now_ms = int(time.time() * 1000)

    # Lấy crt từ snapshot hoặc collection để tính ngày due chuẩn của Anki
    crt = 1753736400
    try:
        db_for_crt = SNAPSHOT_DB_PATH if os.path.exists(SNAPSHOT_DB_PATH) else ANKI_COL_PATH
        with sqlite3.connect(db_for_crt) as c_crt:
            row_crt = c_crt.execute("SELECT crt FROM col LIMIT 1").fetchone()
            if row_crt:
                crt = int(row_crt[0])
    except Exception:
        pass

    today_days = int((now_ts - crt) // 86400)
    new_due_day = today_days + max(1, new_ivl)

    # Cách 1: Thử qua AnkiConnect nếu Anki đang mở
    try:
        cids_res = anki_connect_invoke("findCards", query=f"nid:{nid}")
        cids = cids_res.get("result") or []
        if cids:
            reviews_to_insert = []
            for idx, cid in enumerate(cids):
                anki_connect_invoke(
                    "setSpecificValueOfCard",
                    card=int(cid),
                    keys=["type", "queue", "ivl", "due", "factor", "reps", "lapses", "mod", "usn"],
                    newValues=[2, 2, int(new_ivl), int(new_due_day), int(ease), int(reps), int(lapses), now_ts, -1],
                    warning_check=True
                )
                reviews_to_insert.append([
                    now_ms + idx, int(cid), -1, int(ease_chosen),
                    int(new_ivl), int(old_ivl), int(ease), 4000, 1
                ])
            if reviews_to_insert:
                anki_connect_invoke("insertReviews", reviews=reviews_to_insert)
            return {"synced_to_anki": True, "mode": "ankiconnect", "cards_updated": len(cids)}
    except Exception:
        pass

    # Cách 2: Ghi trực tiếp vào file collection.anki2 khi Anki đang đóng
    try:
        aconn = sqlite3.connect(ANKI_COL_PATH, timeout=2.0)
        cids = [r[0] for r in aconn.execute("SELECT id FROM cards WHERE nid = ?", (nid,)).fetchall()]
        if cids:
            aconn.execute("""
                UPDATE cards
                SET type = 2, queue = 2, ivl = ?, due = ?, factor = ?, reps = ?, lapses = ?, mod = ?, usn = -1
                WHERE nid = ?
            """, (int(new_ivl), int(new_due_day), int(ease), int(reps), int(lapses), now_ts, int(nid)))

            for idx, cid in enumerate(cids):
                aconn.execute("""
                    INSERT OR IGNORE INTO revlog (id, cid, usn, ease, ivl, lastIvl, factor, time, type)
                    VALUES (?, ?, -1, ?, ?, ?, ?, 4000, 1)
                """, (now_ms + idx, int(cid), int(ease_chosen), int(new_ivl), int(old_ivl), int(ease)))

            aconn.commit()
        aconn.close()
        return {"synced_to_anki": True, "mode": "sqlite_direct", "cards_updated": len(cids)}
    except Exception as e:
        # Lưu vào hàng đợi chờ đồng bộ khi Anki đóng
        with db_lock:
            pconn = sqlite3.connect(PROGRESS_DB_PATH)
            pconn.execute("""
                INSERT OR REPLACE INTO pending_anki_writes
                (nid, is_correct, ease_chosen, new_ivl, old_ivl, ease, reps, lapses, updated_at)
                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
            """, (nid, 1 if is_correct else 0, ease_chosen, new_ivl, old_ivl, ease, reps, lapses, now_ts))
            pconn.commit()
            pconn.close()
        return {"synced_to_anki": False, "mode": "queued", "error": str(e)}


def flush_pending_anki_writes():
    with db_lock:
        conn = sqlite3.connect(PROGRESS_DB_PATH)
        rows = conn.execute("SELECT nid, is_correct, ease_chosen, new_ivl, old_ivl, ease, reps, lapses FROM pending_anki_writes").fetchall()
        conn.close()

    if not rows:
        return 0

    flushed = 0
    for nid, is_corr, ease_c, new_ivl, old_ivl, ease, reps, lapses in rows:
        res = push_review_to_anki(nid, bool(is_corr), ease_c, new_ivl, old_ivl, ease, reps, lapses)
        if res.get("synced_to_anki"):
            flushed += 1
            with db_lock:
                conn = sqlite3.connect(PROGRESS_DB_PATH)
                conn.execute("DELETE FROM pending_anki_writes WHERE nid = ?", (nid,))
                conn.commit()
                conn.close()
    return flushed


def sync_from_anki_collection(force_overwrite_srs=False):
    """
    Sao chép an toàn collection.anki2 (kể cả khi Anki đang mở) và đồng bộ chính xác tiến độ Anki <-> Web.
    """
    if not os.path.exists(ANKI_COL_PATH):
        print(f"[WARN] Không tìm thấy {ANKI_COL_PATH}")
        return {"synced": 0, "error": "Anki collection file not found"}

    flush_pending_anki_writes()

    try:
        shutil.copy2(ANKI_COL_PATH, SNAPSHOT_DB_PATH)
        for ext in ("-wal", "-shm"):
            if os.path.exists(ANKI_COL_PATH + ext):
                shutil.copy2(ANKI_COL_PATH + ext, SNAPSHOT_DB_PATH + ext)
            elif os.path.exists(SNAPSHOT_DB_PATH + ext):
                try:
                    os.remove(SNAPSHOT_DB_PATH + ext)
                except Exception:
                    pass
    except Exception as e:
        return {"synced": 0, "error": str(e)}

    anki_conn = sqlite3.connect(SNAPSHOT_DB_PATH)
    crt_row = anki_conn.execute("SELECT crt FROM col LIMIT 1").fetchone()
    crt = int(crt_row[0]) if crt_row else 1753736400
    now_ts = int(time.time())
    today_days = int((now_ts - crt) // 86400)

    decks_map = {}
    for did, dname in anki_conn.execute("SELECT id, name FROM decks").fetchall():
        decks_map[did] = dname.replace("\x1f", "::")

    fields_map = {}
    for ntid, ord_idx, fname in anki_conn.execute("SELECT ntid, ord, name FROM fields ORDER BY ntid, ord").fetchall():
        fields_map.setdefault(ntid, []).append(fname)

    rows = anki_conn.execute("""
        SELECT n.id, n.mid, n.flds,
               c.did,
               MAX(c.ivl),
               MAX(c.type),
               MAX(c.factor),
               SUM(c.reps),
               SUM(c.lapses),
               MIN(CASE
                   WHEN c.queue IN (1, 3) THEN ?
                   WHEN c.queue = 2 THEN c.due
                   ELSE 999999
               END),
               MAX(c.mod)
        FROM notes n
        JOIN cards c ON c.nid = n.id
        GROUP BY n.id
    """, (today_days,)).fetchall()
    anki_conn.close()

    synced_count = 0

    with db_lock:
        pconn = sqlite3.connect(PROGRESS_DB_PATH)
        pending_nids = set(r[0] for r in pconn.execute("SELECT nid FROM pending_anki_writes").fetchall())
        existing_srs = {}
        if not force_overwrite_srs:
            for r in pconn.execute("SELECT nid, level, ivl, ease, due_ts, reps, lapses, last_review_ts FROM card_progress").fetchall():
                existing_srs[r[0]] = r[1:]

        batch = []
        for nid, mid, flds_raw, did, max_ivl, max_type, max_factor, sum_reps, sum_lapses, min_due_day, max_mod in rows:
            fnames = fields_map.get(mid, [])
            fvals = flds_raw.split("\x1f")
            fdict = {}
            for i, fn in enumerate(fnames):
                if i < len(fvals):
                    fdict[fn.lower().strip()] = fvals[i]

            deck_name = decks_map.get(did, "Default")

            word_raw = fdict.get("word") or fdict.get("front") or fdict.get("vocabulary") or fdict.get("từ vựng") or fdict.get("learnable") or ""
            meaning_raw = fdict.get("meaning") or fdict.get("definition") or fdict.get("back") or fdict.get("nghĩa tiếng việt") or ""
            explain_raw = fdict.get("explain") or ""
            if not meaning_raw and explain_raw:
                meaning_raw, explain_raw = explain_raw, ""
            if fdict.get("definition") and fdict.get("meaning") and fdict.get("definition") != fdict.get("meaning") and not explain_raw:
                explain_raw = fdict.get("meaning")
                meaning_raw = fdict.get("definition")

            word = clean_html(word_raw)
            meaning = clean_html(meaning_raw)
            if not word or not meaning:
                continue

            pos = clean_html(fdict.get("pos") or fdict.get("part of speech") or fdict.get("từ loại") or "")
            pron = clean_html(fdict.get("pronunciation") or fdict.get("phonetic") or fdict.get("ipa") or "").strip("/")
            explain = clean_html(explain_raw)
            example = clean_html(fdict.get("example") or fdict.get("cloze sentence") or fdict.get("ví dụ") or fdict.get("ví dụ 1") or "")
            ex_trans = clean_html(fdict.get("example_translated") or fdict.get("example meaning") or "")
            collocation = clean_html(fdict.get("collocation") or "")
            synonym = clean_html(fdict.get("synonym") or fdict.get("synonyms") or "")
            antonym = clean_html(fdict.get("antonym") or "")

            audio_word = extract_sound_filename(fdict.get("audio_word") or fdict.get("audio_for_word") or word_raw or "")
            audio_ex = extract_sound_filename(fdict.get("audio") or fdict.get("sound") or fdict.get("example") or fdict.get("cloze sentence") or fdict.get("ví dụ") or "")
            if not audio_word and audio_ex and not example:
                audio_word = audio_ex

            choices_meta = {
                "meaning_choices": [clean_html(fdict.get(f"choice_{i}", "")) for i in (1, 2, 3, 4) if clean_html(fdict.get(f"choice_{i}", ""))],
                "correct_choice": int(clean_html(fdict.get("correct_choice", "1"))) if clean_html(fdict.get("correct_choice", "")).isdigit() else 1,
                "word_choices": [clean_html(fdict.get(f"choice_word_{i}", "")) for i in (1, 2, 3, 4) if clean_html(fdict.get(f"choice_word_{i}", ""))],
                "correct_choice_word": int(clean_html(fdict.get("correct_choice_word", "1"))) if clean_html(fdict.get("correct_choice_word", "")).isdigit() else 1,
                "audio_choices": [extract_sound_filename(fdict.get(f"choice_audio_{i}", "")) for i in (1, 2, 3, 4) if extract_sound_filename(fdict.get(f"choice_audio_{i}", ""))],
                "correct_choice_audio": int(clean_html(fdict.get("correct_choice_audio", "1"))) if clean_html(fdict.get("correct_choice_audio", "")).isdigit() else 1,
            }

            max_ivl = max_ivl or 0
            max_type = max_type or 0
            max_mod = max_mod or 0
            anki_lvl = ivl_to_level(max_type, max_ivl)

            if max_type == 0:
                anki_due_ts = 0
            elif min_due_day is not None and min_due_day <= today_days:
                anki_due_ts = crt + (int(min_due_day) * 86400)
            elif min_due_day is not None and min_due_day < 900000:
                anki_due_ts = max(now_ts + 3600, crt + (int(min_due_day) * 86400))
            else:
                anki_due_ts = now_ts + (max(1, max_ivl) * 86400)

            # Anki là nguồn dữ liệu gốc (chỉ giữ trạng thái tạm nếu thẻ đang nằm trong hàng đợi pending_anki_writes chưa kịp ghi)
            if nid in pending_nids and nid in existing_srs and not force_overwrite_srs:
                lvl, ivl, ease, due_ts, reps, lapses, last_rev = existing_srs[nid]
            else:
                lvl = anki_lvl
                ivl = max(0, max_ivl)
                ease = max_factor or 2500
                due_ts = anki_due_ts
                reps = sum_reps or 0
                lapses = sum_lapses or 0
                last_rev = 0

            batch.append((
                nid, deck_name, word, meaning, pos, pron, explain,
                example, ex_trans, collocation, synonym, antonym,
                audio_word, audio_ex, "", json.dumps(choices_meta, ensure_ascii=False),
                lvl, ivl, ease, due_ts, reps, lapses, last_rev
            ))
            synced_count += 1

        valid_nids = {r[0] for r in rows}
        all_prog_nids = {r[0] for r in pconn.execute("SELECT nid FROM card_progress").fetchall()}
        stale_nids = all_prog_nids - valid_nids
        if stale_nids:
            pconn.executemany("DELETE FROM card_progress WHERE nid = ?", [(x,) for x in stale_nids])

        pconn.executemany("""
            INSERT OR REPLACE INTO card_progress (
                nid, deck_name, word, meaning, pos, pronunciation, explain,
                example, example_translated, collocation, synonym, antonym,
                audio_word, audio_example, image, choices_json,
                level, ivl, ease, due_ts, reps, lapses, last_review_ts
            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        """, batch)
        pconn.commit()
        pconn.close()

    return {"synced": synced_count, "error": None}


def get_dashboard_stats(deck_filter="french2"):
    now_ts = int(time.time())
    today_start = now_ts - (now_ts % 86400)

    with db_lock:
        conn = sqlite3.connect(PROGRESS_DB_PATH)
        decks_rows = conn.execute("""
            SELECT deck_name, COUNT(*),
                   SUM(CASE WHEN level > 0 AND due_ts <= ? THEN 1 ELSE 0 END),
                   SUM(CASE WHEN level = 0 THEN 1 ELSE 0 END)
            FROM card_progress
            GROUP BY deck_name
            ORDER BY CASE WHEN deck_name = 'french2' THEN 0 WHEN deck_name = 'hoc_lom' THEN 1 WHEN deck_name = 'French' THEN 2 ELSE 3 END, COUNT(*) DESC
        """, (now_ts,)).fetchall()

        decks_list = [{"name": r[0], "total": r[1], "due": r[2], "new": r[3]} for r in decks_rows]

        if not deck_filter or deck_filter == "ALL":
            where_clause = ""
            params = ()
        else:
            where_clause = "WHERE deck_name = ? OR deck_name LIKE ?"
            params = (deck_filter, f"{deck_filter}::%")

        lvl_rows = conn.execute(f"""
            SELECT level, COUNT(*)
            FROM card_progress
            {where_clause}
            GROUP BY level
        """, params).fetchall()

        levels = [0, 0, 0, 0, 0]
        new_count = 0
        for lvl, cnt in lvl_rows:
            lvl_int = int(lvl or 0)
            if lvl_int == 0:
                new_count += cnt
            elif 1 <= lvl_int <= 5:
                levels[lvl_int - 1] += cnt

        total_learned = sum(levels)
        due_row = conn.execute(f"""
            SELECT COUNT(*)
            FROM card_progress
            {where_clause + (' AND ' if where_clause else 'WHERE ')} (level > 0 AND due_ts <= ?)
        """, params + (now_ts,)).fetchone()
        due_count = due_row[0] if due_row else 0

        today_rev = conn.execute("""
            SELECT COUNT(*), SUM(CASE WHEN is_correct = 1 THEN 1 ELSE 0 END)
            FROM review_log
            WHERE reviewed_at >= ?
        """, (today_start,)).fetchone()
        conn.close()

    reviewed_today = today_rev[0] or 0
    correct_today = today_rev[1] or 0

    return {
        "selected_deck": deck_filter,
        "decks": decks_list,
        "levels": levels,
        "new_count": new_count,
        "total_learned": total_learned,
        "total_words": total_learned + new_count,
        "due_count": due_count,
        "reviewed_today": reviewed_today,
        "correct_today": correct_today,
        "lan_url": f"http://{get_lan_ip()}:{PORT}",
        "public_url": tunnel_state.get("public_url"),
        "tunnel_status": tunnel_state.get("status")
    }


_ANKI_LIVE_CACHE = {"ts": 0, "due": None, "new": None, "stats": {}, "refreshing": False}


def _do_anki_live_refresh(decks):
    try:
        if not is_anki_connect_alive():
            _ANKI_LIVE_CACHE["ts"] = time.time()
            _ANKI_LIVE_CACHE["due"] = None
            _ANKI_LIVE_CACHE["new"] = None
            _ANKI_LIVE_CACHE["stats"] = {}
            return
        live_due_nids = None
        live_new_nids = None
        anki_deck_stats = {}
        ac_res = anki_connect_invoke("findNotes", query="(is:due OR is:learn) -is:suspended -is:buried")
        if isinstance(ac_res, dict) and ac_res.get("error") is None and isinstance(ac_res.get("result"), list):
            live_due_nids = set(int(x) for x in ac_res["result"])
        new_res = anki_connect_invoke("findNotes", query="is:new -is:suspended -is:buried")
        if isinstance(new_res, dict) and new_res.get("error") is None and isinstance(new_res.get("result"), list):
            live_new_nids = set(int(x) for x in new_res["result"])
        if decks:
            st_res = anki_connect_invoke("getDeckStats", decks=decks)
            if isinstance(st_res, dict) and isinstance(st_res.get("result"), dict):
                for _, dinfo in st_res["result"].items():
                    if isinstance(dinfo, dict) and dinfo.get("name"):
                        anki_deck_stats[dinfo["name"]] = {
                            "new_count": int(dinfo.get("new_count") or 0),
                            "learn_count": int(dinfo.get("learn_count") or 0),
                            "review_count": int(dinfo.get("review_count") or 0),
                            "total_in_deck": int(dinfo.get("total_in_deck") or 0)
                        }
        _ANKI_LIVE_CACHE["ts"] = time.time()
        _ANKI_LIVE_CACHE["due"] = live_due_nids
        _ANKI_LIVE_CACHE["new"] = live_new_nids
        _ANKI_LIVE_CACHE["stats"] = anki_deck_stats
    except Exception:
        _ANKI_LIVE_CACHE["ts"] = time.time()
    finally:
        _ANKI_LIVE_CACHE["refreshing"] = False


def _refresh_anki_live_cache(decks):
    now = time.time()
    if _ANKI_LIVE_CACHE["ts"] == 0:
        _ANKI_LIVE_CACHE["refreshing"] = True
        _do_anki_live_refresh(decks)
    elif now - _ANKI_LIVE_CACHE["ts"] > 5.0 and not _ANKI_LIVE_CACHE["refreshing"]:
        _ANKI_LIVE_CACHE["refreshing"] = True
        threading.Thread(target=_do_anki_live_refresh, args=(decks,), daemon=True).start()
    return _ANKI_LIVE_CACHE["due"], _ANKI_LIVE_CACHE["new"], _ANKI_LIVE_CACHE["stats"]


def fetch_all_cards_for_web(deck="ALL"):
    """Trả về toàn bộ danh sách thẻ kèm trạng thái SRS từ Anki để giao diện MochiVocab hiển thị tức thì."""
    now_ts = int(time.time())

    with db_lock:
        conn = sqlite3.connect(PROGRESS_DB_PATH)
        conn.row_factory = sqlite3.Row
        if deck and deck != "ALL":
            rows = conn.execute("""
                SELECT * FROM card_progress
                WHERE deck_name = ? OR deck_name LIKE ?
                ORDER BY due_ts ASC, nid ASC
            """, (deck, f"{deck}::%")).fetchall()
        else:
            rows = conn.execute("SELECT * FROM card_progress ORDER BY due_ts ASC, nid ASC").fetchall()

        decks = [r[0] for r in conn.execute("""
            SELECT deck_name FROM card_progress
            GROUP BY deck_name
            ORDER BY CASE WHEN deck_name = 'french2' THEN 0 WHEN deck_name = 'hoc_lom' THEN 1 WHEN deck_name = 'French' THEN 2 ELSE 3 END, COUNT(*) DESC
        """).fetchall()]
        conn.close()

    live_due_nids, live_new_nids, anki_deck_stats = _refresh_anki_live_cache(decks)

    cards_out = []
    for r in rows:
        pron = r["pronunciation"] or ""
        if pron and not pron.startswith("/"):
            pron = f"/{pron}/"

        meaning_str = r["meaning"] or ""
        explain_str = r["explain"] or ""
        if meaning_str and explain_str and explain_str.lower() != meaning_str.lower():
            full_meaning = f"{meaning_str} — {explain_str}"
        else:
            full_meaning = meaning_str or explain_str

        cmeta = {}
        try:
            cmeta = json.loads(r["choices_json"] or "{}")
        except Exception:
            pass

        nid_val = int(r["nid"])
        lvl_val = int(r["level"] or 0)
        due_val = int(r["due_ts"] or 0)
        has_anki_new = bool(live_new_nids and nid_val in live_new_nids) or (lvl_val == 0)

        if live_due_nids is not None:
            if nid_val in live_due_nids:
                lvl_val = max(1, lvl_val)
                due_val = min(due_val if due_val > 0 else now_ts, now_ts - 60)
            else:
                if lvl_val > 0 and due_val <= now_ts:
                    due_val = now_ts + 86400

        cards_out.append({
            "nid": nid_val,
            "deck": r["deck_name"],
            "word": r["word"],
            "meaning": full_meaning,
            "raw_meaning": meaning_str,
            "explain": explain_str,
            "pos": r["pos"],
            "ipa": pron,
            "pronunciation": r["pronunciation"],
            "example": r["example"],
            "example_trans": r["example_translated"],
            "example_translated": r["example_translated"],
            "collocation": r["collocation"],
            "synonym": r["synonym"],
            "antonym": r["antonym"],
            "word_audio": r["audio_word"],
            "audio_word": r["audio_word"],
            "example_audio": r["audio_example"],
            "audio_example": r["audio_example"],
            "choices": cmeta,
            "level": lvl_val,
            "ivl": r["ivl"],
            "next_review": due_val,
            "reps": r["reps"],
            "has_anki_new": has_anki_new
        })
    return {"cards": cards_out, "decks": decks, "deck_stats": anki_deck_stats}


def record_card_review(nid, is_correct, ease_chosen=None):
    """
    Cập nhật cấp độ nhớ (Level 1 -> 5), lưu vào web_progress.db VÀ đồng bộ ngược về Anki ở luồng nền (0ms delay)!
    """
    now_ts = int(time.time())
    if ease_chosen is None:
        ease_chosen = 3 if is_correct else 1

    with db_lock:
        conn = sqlite3.connect(PROGRESS_DB_PATH)
        row = conn.execute(
            "SELECT deck_name, level, ivl, ease, reps, lapses FROM card_progress WHERE nid = ?",
            (nid,)
        ).fetchone()
        if not row:
            conn.close()
            return None

        deck_name, old_lvl, old_ivl, ease, reps, lapses = row
        old_lvl = old_lvl or 0
        old_ivl = old_ivl or 0
        ease = ease or 2500
        reps = (reps or 0) + 1
        lapses = lapses or 0

        if ease_chosen == 1 or not is_correct:
            new_lvl = 1
            new_ivl = 1
            ease = max(1300, ease - 200)
            lapses += 1
        elif ease_chosen == 2:
            new_lvl = max(1, old_lvl)
            new_ivl = max(2, int(old_ivl * 1.2) if old_ivl > 0 else 2)
            ease = max(1300, ease - 150)
        elif ease_chosen == 3:
            new_lvl = min(5, (1 if old_lvl == 0 else old_lvl + 1))
            level_default_ivls = {1: 2, 2: 6, 3: 14, 4: 30, 5: 60}
            new_ivl = max(level_default_ivls.get(new_lvl, 4), int(old_ivl * (ease / 1000.0)) if old_ivl > 0 else 2)
        else:  # ease 4 (Easy)
            new_lvl = min(5, (2 if old_lvl <= 1 else old_lvl + 1))
            level_default_ivls = {1: 4, 2: 8, 3: 18, 4: 35, 5: 60}
            new_ivl = max(level_default_ivls.get(new_lvl, 7), int(old_ivl * (ease / 1000.0) * 1.3) if old_ivl > 0 else 4)
            ease = min(3500, ease + 150)

        due_ts = now_ts + (new_ivl * 86400)

        conn.execute("""
            UPDATE card_progress
            SET level = ?, ivl = ?, ease = ?, due_ts = ?, reps = ?, lapses = ?, last_review_ts = ?
            WHERE nid = ?
        """, (new_lvl, new_ivl, ease, due_ts, reps, lapses, now_ts, nid))

        conn.execute("""
            INSERT INTO review_log (nid, deck_name, is_correct, ease_chosen, old_level, new_level, reviewed_at)
            VALUES (?, ?, ?, ?, ?, ?, ?)
        """, (nid, deck_name, 1 if is_correct else 0, ease_chosen, old_lvl, new_lvl, now_ts))

        conn.commit()
        conn.close()

    if _ANKI_LIVE_CACHE["due"] and nid in _ANKI_LIVE_CACHE["due"]:
        _ANKI_LIVE_CACHE["due"].discard(nid)

    threading.Thread(
        target=push_review_to_anki,
        args=(nid, is_correct, ease_chosen, new_ivl, old_ivl, ease, reps, lapses),
        daemon=True
    ).start()

    return {
        "nid": nid,
        "old_level": old_lvl,
        "level": new_lvl,
        "new_level": new_lvl,
        "new_ivl": new_ivl,
        "next_review": due_ts,
        "anki_sync": {"synced_to_anki": True, "mode": "background"}
    }


def search_notebook_words(deck="french2", level=0, query="", limit=150):
    with db_lock:
        conn = sqlite3.connect(PROGRESS_DB_PATH)
        conn.row_factory = sqlite3.Row
        conds = []
        params = []
        if deck and deck != "ALL":
            conds.append("(deck_name = ? OR deck_name LIKE ?)")
            params.extend([deck, f"{deck}::%"])
        if level in (1, 2, 3, 4, 5):
            conds.append("level = ?")
            params.append(level)
        if query:
            q_like = f"%{query.strip()}%"
            conds.append("(word LIKE ? OR meaning LIKE ? OR explain LIKE ?)")
            params.extend([q_like, q_like, q_like])

        where_sql = ("WHERE " + " AND ".join(conds)) if conds else ""
        rows = conn.execute(f"""
            SELECT nid, word, meaning, explain, pos, pronunciation, example, audio_word, audio_example, level, ivl
            FROM card_progress
            {where_sql}
            ORDER BY level ASC, word ASC
            LIMIT ?
        """, params + [limit]).fetchall()
        conn.close()

    return [dict(r) for r in rows]


def start_public_tunnel():
    """
    Khởi tạo đường truyền Internet công khai qua SSH localhost.run (tích hợp sẵn trên Windows 10/11)
    để học trên điện thoại bằng 4G/5G ở bất kỳ đâu không cần chung mạng Wi-Fi.
    """
    if tunnel_state["running"] and tunnel_state["proc"] and tunnel_state["proc"].poll() is None:
        return tunnel_state

    ssh_bin = shutil.which("ssh") or r"C:\Windows\System32\OpenSSH\ssh.exe"
    if not os.path.exists(ssh_bin):
        tunnel_state["status"] = "error"
        tunnel_state["error"] = "Không tìm thấy OpenSSH trên hệ thống."
        return tunnel_state

    tunnel_state["status"] = "connecting"
    tunnel_state["error"] = None

    def _runner():
        try:
            cmd = [
                ssh_bin,
                "-o", "StrictHostKeyChecking=no",
                "-o", "UserKnownHostsFile=/dev/null",
                "-o", "ServerAliveInterval=30",
                "-R", f"80:127.0.0.1:{PORT}",
                "nokey@localhost.run"
            ]
            proc = subprocess.Popen(
                cmd,
                stdin=subprocess.PIPE,
                stdout=subprocess.PIPE,
                stderr=subprocess.STDOUT,
                text=True,
                encoding="utf-8",
                errors="replace",
                creationflags= getattr(subprocess, "CREATE_NO_WINDOW", 0)
            )
            tunnel_state["proc"] = proc
            tunnel_state["running"] = True

            for line in proc.stdout:
                m = re.search(r"(https://[a-zA-Z0-9.-]+\.lhr\.life)", line)
                if m:
                    tunnel_state["public_url"] = m.group(1)
                    tunnel_state["status"] = "connected"
                    print(f"[PUBLIC INTERNET URL] {tunnel_state['public_url']}")
        except Exception as e:
            tunnel_state["status"] = "error"
            tunnel_state["error"] = str(e)
        finally:
            tunnel_state["running"] = False
            if tunnel_state["status"] != "error":
                tunnel_state["status"] = "idle"
                tunnel_state["public_url"] = None

    t = threading.Thread(target=_runner, daemon=True)
    t.start()
    return tunnel_state


class MochiWebHandler(SimpleHTTPRequestHandler):
    protocol_version = "HTTP/1.1"

    def log_message(self, format, *args):
        pass  # Giữ console gọn gàng

    def send_json(self, data, status=200):
        raw = json.dumps(data, ensure_ascii=False).encode("utf-8")
        accept_enc = self.headers.get("Accept-Encoding", "")
        if len(raw) > 8192 and "gzip" in accept_enc:
            import gzip
            raw = gzip.compress(raw, compresslevel=5)
            self.send_response(status)
            self.send_header("Content-Type", "application/json; charset=utf-8")
            self.send_header("Content-Encoding", "gzip")
            self.send_header("Content-Length", str(len(raw)))
            self.send_header("Access-Control-Allow-Origin", "*")
            self.end_headers()
            self.wfile.write(raw)
            return
        self.send_response(status)
        self.send_header("Content-Type", "application/json; charset=utf-8")
        self.send_header("Content-Length", str(len(raw)))
        self.send_header("Access-Control-Allow-Origin", "*")
        self.end_headers()
        self.wfile.write(raw)

    def do_OPTIONS(self):
        self.send_response(200)
        self.send_header("Access-Control-Allow-Origin", "*")
        self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
        self.send_header("Access-Control-Allow-Headers", "Content-Type")
        self.end_headers()

    def do_GET(self):
        parsed = urllib.parse.urlparse(self.path)
        path = parsed.path
        qs = urllib.parse.parse_qs(parsed.query)

        if path == "/" or path == "/index.html":
            index_file = os.path.join(BASE_DIR, "index.html")
            if os.path.isfile(index_file):
                with open(index_file, "rb") as f:
                    content = f.read()
                self.send_response(200)
                self.send_header("Content-Type", "text/html; charset=utf-8")
                self.send_header("Content-Length", str(len(content)))
                self.end_headers()
                self.wfile.write(content)
                return

        if path == "/manifest.json":
            manifest = {
                "name": "Mochi French Web — Học Từ Vựng Mọi Nơi",
                "short_name": "MochiFrench",
                "start_url": "/",
                "display": "standalone",
                "background_color": "#0f172a",
                "theme_color": "#f59e0b",
                "icons": [
                    {
                        "src": "data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><circle cx='50' cy='50' r='48' fill='%23f59e0b'/><text x='50' y='68' font-size='55' text-anchor='middle'>🐱</text></svg>",
                        "sizes": "192x192",
                        "type": "image/svg+xml"
                    }
                ]
            }
            return self.send_json(manifest)

        if path.startswith("/media/"):
            filename = urllib.parse.unquote(path[len("/media/"):]).strip()
            filename = os.path.basename(filename)
            media_file = os.path.join(ANKI_MEDIA_DIR, filename)

            if not os.path.isfile(media_file):
                try:
                    os.makedirs(ANKI_MEDIA_DIR, exist_ok=True)
                    text_to_speak = ""
                    tl_lang = "fr"
                    with sqlite3.connect(PROGRESS_DB_PATH) as conn:
                        r = conn.execute(
                            "SELECT word, example, deck_name FROM card_progress WHERE audio_word = ? OR audio_example = ? LIMIT 1",
                            (filename, filename)
                        ).fetchone()
                        if r:
                            raw_w, raw_ex, d_name = r
                            if str(d_name or "").lower().startswith("hoc_lom"):
                                tl_lang = "en"
                            row_check = conn.execute(
                                "SELECT audio_word FROM card_progress WHERE audio_word = ? LIMIT 1",
                                (filename,)
                            ).fetchone()
                            text_to_speak = clean_html(raw_w if row_check else (raw_ex or raw_w))
                            text_to_speak = re.sub(r"\s*\([mf]\.?\)", "", text_to_speak, flags=re.I).strip()
                    if text_to_speak:
                        tts_url = f"https://translate.google.com/translate_tts?ie=UTF-8&q={urllib.parse.quote(text_to_speak[:180])}&tl={tl_lang}&client=tw-ob"
                        req = urllib.request.Request(tts_url, headers={"User-Agent": "Mozilla/5.0"})
                        with urllib.request.urlopen(req, timeout=2.5) as resp:
                            audio_bytes = resp.read()
                            if len(audio_bytes) > 400:
                                with open(media_file, "wb") as f_out:
                                    f_out.write(audio_bytes)
                except Exception:
                    pass

            if os.path.isfile(media_file):
                ctype, _ = mimetypes.guess_type(media_file)
                if not ctype:
                    ctype = "audio/mpeg" if filename.lower().endswith(".mp3") else "application/octet-stream"
                file_size = os.path.getsize(media_file)
                range_header = self.headers.get("Range")

                if range_header:
                    m = re.match(r"bytes=(\d+)-(\d*)", range_header)
                    if m:
                        start = int(m.group(1))
                        end = int(m.group(2)) if m.group(2) else file_size - 1
                        end = min(end, file_size - 1)
                        length = max(0, end - start + 1)
                        with open(media_file, "rb") as f:
                            f.seek(start)
                            chunk = f.read(length)
                        self.send_response(206)
                        self.send_header("Content-Type", ctype)
                        self.send_header("Accept-Ranges", "bytes")
                        self.send_header("Content-Range", f"bytes {start}-{end}/{file_size}")
                        self.send_header("Content-Length", str(len(chunk)))
                        self.send_header("Cache-Control", "public, max-age=86400")
                        self.end_headers()
                        self.wfile.write(chunk)
                        return

                with open(media_file, "rb") as f:
                    data = f.read()
                self.send_response(200)
                self.send_header("Content-Type", ctype)
                self.send_header("Accept-Ranges", "bytes")
                self.send_header("Content-Length", str(len(data)))
                self.send_header("Cache-Control", "public, max-age=86400")
                self.end_headers()
                self.wfile.write(data)
                return
            else:
                self.send_response(404)
                self.end_headers()
                return

        if path == "/api/stats":
            deck = qs.get("deck", ["french2"])[0]
            return self.send_json(get_dashboard_stats(deck))

        if path == "/api/cards":
            deck = qs.get("deck", ["ALL"])[0]
            data = fetch_all_cards_for_web(deck=deck)
            return self.send_json(data)

        if path == "/api/notebook":
            deck = qs.get("deck", ["french2"])[0]
            lvl = int(qs.get("level", ["0"])[0])
            q = qs.get("q", [""])[0]
            words = search_notebook_words(deck=deck, level=lvl, query=q, limit=200)
            return self.send_json({"words": words})

        if path == "/api/cloud/pull_reviews":
            with db_lock:
                conn = sqlite3.connect(PROGRESS_DB_PATH)
                conn.row_factory = sqlite3.Row
                pending = [dict(r) for r in conn.execute("SELECT * FROM pending_anki_writes").fetchall()]
                conn.close()
            return self.send_json({"ok": True, "pending": pending})

        if path == "/api/tunnel":
            return self.send_json({
                "lan_url": f"http://{get_lan_ip()}:{PORT}",
                "public_url": tunnel_state.get("public_url"),
                "status": tunnel_state.get("status"),
                "error": tunnel_state.get("error")
            })

        return super().do_GET()

    def do_POST(self):
        parsed = urllib.parse.urlparse(self.path)
        path = parsed.path
        length = int(self.headers.get("Content-Length", 0))
        body = {}
        if length > 0:
            try:
                body = json.loads(self.rfile.read(length).decode("utf-8"))
            except Exception:
                body = {}

        if path == "/api/review":
            nid = body.get("nid")
            is_correct = bool(body.get("correct", body.get("is_correct", True)))
            ease = body.get("ease")
            if nid is not None:
                res = record_card_review(int(nid), is_correct, int(ease) if ease else None)
                out = {"ok": True, "result": res}
                if res:
                    out.update(res)
                return self.send_json(out)
            return self.send_json({"ok": False, "error": "Missing nid"}, 400)

        if path == "/api/sync":
            force = bool(body.get("force", False))
            try:
                import Deploy_Va_Dong_Bo_Cloud as cloud_sync
                from huggingface_hub import HfApi
                cfg = cloud_sync.load_config()
                tok = (cfg.get("token") or cfg.get("hf_token") or "").strip()
                uname = cfg.get("username", "hung9066").strip()
                ds_repo = f"{uname}/{cfg.get('dataset_name', 'mochi-french-anki-data')}"
                sp_repo = f"{uname}/{cfg.get('space_name', 'mochi-french-anki')}"
                if tok:
                    api = HfApi(token=tok)
                    cloud_sync.sync_vocab_txt_and_anki(api, ds_repo)
                    cloud_sync.pull_cloud_reviews_into_anki(api, ds_repo)
            except Exception as e:
                print(f"[!] Cloud pull warning: {e}")

            info = sync_from_anki_collection(force_overwrite_srs=force)

            def _bg_push_cloud():
                try:
                    import Deploy_Va_Dong_Bo_Cloud as cloud_sync
                    from huggingface_hub import HfApi
                    cfg = cloud_sync.load_config()
                    tok = (cfg.get("token") or cfg.get("hf_token") or "").strip()
                    uname = cfg.get("username", "hung9066").strip()
                    ds_repo = f"{uname}/{cfg.get('dataset_name', 'mochi-french-anki-data')}"
                    sp_repo = f"{uname}/{cfg.get('space_name', 'mochi-french-anki')}"
                    if tok:
                        api = HfApi(token=tok)
                        cards, cards_json_path = cloud_sync.export_cards_json()
                        cloud_sync.deploy_static_space(api, sp_repo, cards_json_path)
                        cloud_sync.deploy_dataset_and_media(api, ds_repo, cards, cards_json_path, upload_media=False)
                except Exception:
                    pass
            threading.Thread(target=_bg_push_cloud, daemon=True).start()
            return self.send_json({"ok": True, "sync": info})

        if path == "/api/cloud/ack_reviews":
            nids = body.get("nids", [])
            if nids:
                with db_lock:
                    conn = sqlite3.connect(PROGRESS_DB_PATH)
                    conn.executemany("DELETE FROM pending_anki_writes WHERE nid = ?", [(int(x),) for x in nids])
                    conn.commit()
                    conn.close()
            return self.send_json({"ok": True, "cleared": len(nids)})

        if path == "/api/cloud/push_cards":
            cards = body.get("cards", [])
            if cards:
                with db_lock:
                    conn = sqlite3.connect(PROGRESS_DB_PATH)
                    for c in cards:
                        conn.execute("""
                            INSERT OR REPLACE INTO card_progress (
                                nid, deck_name, word, meaning, pos, pronunciation,
                                explain, example, example_translated, collocation,
                                synonym, antonym, audio_word, audio_example, image,
                                choices_json, level, ivl, ease, due_ts, reps, lapses, last_review_ts
                            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                        """, (
                            c["nid"], c["deck_name"], c["word"], c["meaning"], c["pos"], c["pronunciation"],
                            c["explain"], c["example"], c["example_translated"], c["collocation"],
                            c["synonym"], c["antonym"], c["audio_word"], c["audio_example"], c["image"],
                            c["choices_json"], c["level"], c["ivl"], c["ease"], c["due_ts"], c["reps"], c["lapses"], c["last_review_ts"]
                        ))
                    conn.commit()
                    conn.close()
            return self.send_json({"ok": True, "updated": len(cards)})

        if path == "/api/tunnel/start":
            start_public_tunnel()
            for _ in range(14):
                if tunnel_state.get("public_url") or tunnel_state.get("status") == "error":
                    break
                time.sleep(0.25)
            return self.send_json({
                "lan_url": f"http://{get_lan_ip()}:{PORT}",
                "public_url": tunnel_state.get("public_url"),
                "status": tunnel_state.get("status"),
                "error": tunnel_state.get("error")
            })

        return self.send_json({"error": "Not found"}, 404)


def extract_media_pack_if_needed():
    if os.path.isfile(MEDIA_PACK_TAR) and not os.path.isdir(LOCAL_MEDIA_DIR):
        os.makedirs(CLOUD_MEDIA_DIR, exist_ok=True)
        marker = os.path.join(CLOUD_MEDIA_DIR, ".extracted_ok")
        if not os.path.isfile(marker):
            print("  📦 Đang giải nén gói âm thanh media_pack.tar trên Cloud...")
            import tarfile
            try:
                with tarfile.open(MEDIA_PACK_TAR, "r") as tf:
                    tf.extractall(CLOUD_MEDIA_DIR)
                with open(marker, "w") as mf:
                    mf.write("ok")
                print("  ✓ Đã giải nén toàn bộ âm thanh Anki thành công!")
            except Exception as e:
                print(f"  [!] Lỗi giải nén media_pack.tar: {e}")


def disable_windows_console_quickedit():
    if os.name == "nt":
        try:
            import ctypes
            kernel32 = ctypes.windll.kernel32
            stdin_handle = kernel32.GetStdHandle(-10)  # STD_INPUT_HANDLE
            mode = ctypes.c_uint32()
            if kernel32.GetConsoleMode(stdin_handle, ctypes.byref(mode)):
                # Clear ENABLE_QUICK_EDIT_MODE (0x0040), set ENABLE_EXTENDED_FLAGS (0x0080)
                new_mode = (mode.value & ~0x0040) | 0x0080
                kernel32.SetConsoleMode(stdin_handle, new_mode)
        except Exception:
            pass


def main():
    disable_windows_console_quickedit()
    print("=" * 64)
    print("  🚀 MOCHI FRENCH & ANKI WEB SERVER (LOCAL & CLOUD 24/7)")
    print("=" * 64)
    extract_media_pack_if_needed()
    init_progress_db()
    sync_info = sync_from_anki_collection(force_overwrite_srs=False)
    print(f"  ✓ Đã đồng bộ dữ liệu từ Anki: {sync_info.get('synced', 0)} từ vựng")
    print(f"  ✓ Thư mục âm thanh gốc      : {ANKI_MEDIA_DIR}")

    lan_ip = get_lan_ip()
    print(f"  💻 Học trên máy tính này    : http://localhost:{PORT}")
    print(f"  📱 Học trên ĐT / iPad (WiFi): http://{lan_ip}:{PORT}")

    if not IS_CLOUD_ENV:
        start_public_tunnel()
        print("  🌐 Đang khởi tạo Link Internet 4G/5G công khai...")
    print("=" * 64)

    os.chdir(BASE_DIR)
    threading.Thread(target=lambda: fetch_all_cards_for_web("ALL"), daemon=True).start()
    ThreadingHTTPServer.allow_reuse_address = True
    server = ThreadingHTTPServer(("0.0.0.0", PORT), MochiWebHandler)

    # Bật thêm IPv6 [::1] trên Windows để trình duyệt gọi localhost:8686 phản hồi trong 0.1ms (không bị chờ 2s IPv6 fallback)
    try:
        class ThreadingHTTPServerV6(ThreadingHTTPServer):
            address_family = socket.AF_INET6
        server_v6 = ThreadingHTTPServerV6(("::1", PORT), MochiWebHandler)
        threading.Thread(target=server_v6.serve_forever, daemon=True).start()
    except Exception:
        pass

    if "--open-browser" in sys.argv:
        def _open_url():
            time.sleep(0.3)
            try:
                import webbrowser
                webbrowser.open(f"http://localhost:{PORT}")
            except Exception:
                pass
        threading.Thread(target=_open_url, daemon=True).start()

    try:
        server.serve_forever()
    except KeyboardInterrupt:
        print("\nĐã dừng server.")
        server.server_close()


if __name__ == "__main__":
    main()