"""把问答对拼成训练用的 data/train.jsonl。

    python scripts/build_sft.py

- 读 data/pairs/*.jsonl（已经整理好的老数据，base.jsonl 就是之前那 7297 条）
  和 data/new/*.jsonl（teacher.py / teacher_hard.py 新出的、verify.py 复核过的）
- 测试库的题一律不要；SQL 在建表语句上跑不通的（表名、列名不存在）丢掉
- 按 (库, 问题) 去重，问题过短的丢掉
- 用 prompt.py 里的格式包装成 messages
- 顺手统计一下查询类型分布，看看数据偏不偏
"""

import argparse
import hashlib
import json
import random
import re
import sqlite3
from collections import Counter, defaultdict
from pathlib import Path

from prompt import build

# 包里脚本在 scripts/，schemas/ data/ 在上一级；GitHub 仓库是平铺的，两种都认
ROOT = Path(__file__).resolve().parent
if not (ROOT / "schemas").is_dir():
    ROOT = ROOT.parent
TEST_DBS = {"library", "gym", "hard_retail", "transit"}
OLD_SQLITE_UNSUPPORTED = re.compile(r"(?i)\b(?:right|full)\s+(?:outer\s+)?join\b")
NO_VALUES_SHARE = 0.2  # 这么多样本不带「部分字段的取值」，模型在没给取值时也得会用

# 分类字段的判断：名字、日期、联系方式这类列不算；日期、通配、数字这类字面量不算
NOT_CATEGORY_COL = re.compile(r"date|time|_at$|birth|since|name|title|phone|mobile|email|address|sku|code|_no$|_id$")
NOT_CATEGORY_LIT = re.compile(r"^(\d{4}(-\d\d){0,2}( [\d:]+)?|.*%.*|now|[+-]?\d+ \w+|start of \w+|-?\d+(\.\d+)?|)$", re.I)
NOT_ALIAS = {"on", "where", "join", "left", "right", "inner", "outer", "full", "cross", "natural",
             "group", "order", "limit", "having", "union", "using", "as"}


def schema_path(db: str) -> Path:
    for p in (ROOT / "schemas").rglob(f"{db}.sql"):
        return p
    raise FileNotFoundError(db)


def table_columns(ddl: str) -> dict[str, list[str]]:
    """{表: [列, ...]}，都转小写，按建表顺序。"""
    conn = sqlite3.connect(":memory:")
    conn.executescript(ddl)
    return {t.lower(): [c[1].lower() for c in conn.execute(f'pragma table_info("{t}")')]
            for (t,) in conn.execute("select name from sqlite_master where type='table' order by rowid")}


def category_literals(sql: str, cols: dict[str, list[str]]):
    """找出 SQL 里「分类列 = '值'」「分类列 IN ('值', ...)」，返回 [(表, 列, 值)]。别名按 FROM/JOIN 解析。"""
    alias = {}
    for t, a in re.findall(r"(?i)\b(?:from|join)\s+(\w+)(?:\s+(?:as\s+)?(\w+))?", sql):
        if t.lower() in cols:
            alias[t.lower()] = t.lower()
            if a and a.lower() not in NOT_ALIAS:
                alias[a.lower()] = t.lower()
    pairs = re.findall(r"(?:(\w+)\.)?(\w+)\s*(?:=|!=|<>)\s*'([^']*)'", sql)
    for a, col, body in re.findall(r"(?i)(?:(\w+)\.)?(\w+)\s+(?:not\s+)?in\s*\(([^()]*)\)", sql):
        pairs += [(a, col, lit) for lit in re.findall(r"'([^']*)'", body)]
    out = []
    for a, col, lit in pairs:
        col = col.lower()
        if NOT_CATEGORY_COL.search(col) or NOT_CATEGORY_LIT.match(lit):
            continue
        if a:
            t = alias.get(a.lower())
        else:
            owners = {t for t in alias.values() if col in cols[t]}
            t = owners.pop() if len(owners) == 1 else None
        if t and col in cols[t]:
            out.append((t, col, lit))
    return out


def style(lit: str) -> str:
    """值的写法：中文 / 全小写 / 全大写 / 首字母大写。真实库里一列只会用一种写法。"""
    if re.search(r"[一-鿿]", lit):
        return "zh"
    if lit.islower():
        return "lower"
    if lit.isupper():
        return "upper"
    return "title"


class ValueHints:
    """训练样本的「部分字段的取值」。训练库没有真实数据，取值只能从训练 SQL 的字面量里攒；
    同一列的写法混着用（有的写 'active'、有的写 'Active'、有的写 '已批准'），所以每条样本只列和它
    标准答案同一种写法的值，等于每条样本看到的是一个「这列只用一种写法」的库。值太少的借同名列的凑数。"""

    def __init__(self, rows: list[dict], cols_of: dict[str, dict[str, list[str]]]):
        self.cols_of = cols_of
        self.seen = defaultdict(Counter)  # (db, 表, 列) -> 值的出现次数
        for r in rows:
            for t, c, lit in category_literals(r["sql"], cols_of[r["db"]]):
                self.seen[(r["db"], t, c)][lit] += 1
        # 凑数用：先借同一个库里同名列的值（account.status 借 loan.status），不够再借别的库的
        self.same_db = defaultdict(Counter)  # (库, 列名, 写法) -> 值
        self.by_name = defaultdict(Counter)  # (列名, 写法) -> 值
        for (db, _t, c), cnt in self.seen.items():
            for lit, n in cnt.items():
                self.same_db[(db, c, style(lit))][lit] += n
                self.by_name[(c, style(lit))][lit] += n

    def for_row(self, r: dict) -> dict[str, list[str]] | None:
        rng = random.Random(hashlib.md5(f"{r['db']}|{r['question']}".encode()).hexdigest())
        if rng.random() < NO_VALUES_SHARE:
            return None
        used = {(t, c): style(lit) for t, c, lit in category_literals(r["sql"], self.cols_of[r["db"]])}
        out = {}
        for t, cols in self.cols_of[r["db"]].items():
            for c in cols:
                cnt = self.seen.get((r["db"], t, c))
                if not cnt or len(cnt) > 20:  # 没出现过，或者值太散不像分类字段
                    continue
                # 标准答案用到这列就跟它的写法；没用到就用这列最常见的写法
                by_style = Counter()
                for lit, n in cnt.items():
                    by_style[style(lit)] += n
                want = used.get((t, c)) or by_style.most_common(1)[0][0]
                vals = {lit for lit in cnt if style(lit) == want}
                for pool, cap in ((self.same_db[(r["db"], c, want)], 5), (self.by_name[(c, want)], 3)):
                    for lit, _ in pool.most_common():
                        if len(vals) >= cap:
                            break
                        vals.add(lit)
                if vals:
                    out[f"{t}.{c}"] = sorted(vals)
        return out or None


def sql_kind(sql: str) -> str:
    s = sql.lower()
    for key, pat in (
        ("CTE", r"^\s*with\b"),
        ("窗口函数", r"\bover\s*\("),
        ("子查询", r"\(\s*select\b"),
        ("多表连接", r"\bjoin\b"),
        ("分组", r"\bgroup by\b"),
        ("排序", r"\border by\b"),
        ("取前几", r"\blimit\b"),
        ("聚合", r"\b(count|sum|avg|max|min)\s*\("),
    ):
        if re.search(pat, s):
            return key
    return "简单筛选"


def main() -> None:
    ap = argparse.ArgumentParser()
    ap.add_argument("--out", default="data/train.jsonl")
    # 消融用（run_paper.sh）：--skip 去掉文件名匹配的几份数据，--add 换上别的问答对文件
    ap.add_argument("--skip", default="", help="正则，匹配文件名（不带 .jsonl）的不读，比如 '_r2_para$'")
    ap.add_argument("--add", nargs="*", default=[], help="额外读的问答对 jsonl")
    args = ap.parse_args()

    files = sorted((ROOT / "data" / "pairs").glob("*.jsonl")) + sorted((ROOT / "data" / "new").glob("*.jsonl"))
    files = [p for p in files if not (args.skip and re.search(args.skip, p.stem))] + [ROOT / a for a in args.add]
    rows: list[dict] = []
    for p in files:
        for line in p.read_text(encoding="utf-8").splitlines():
            if not line.strip():
                continue
            r = json.loads(line)
            if len(r.get("question", "")) < 4 or not r.get("sql") or r["db"] in TEST_DBS:
                continue
            rows.append(r)

    # 库重新生成过而题没跟着重出，就会有引用不存在的表/列的 SQL，以前混进去过 36 条
    empty_dbs: dict[str, sqlite3.Connection] = {}
    broken = 0
    seen = set()
    keep = []
    for r in rows:
        key = (r["db"], re.sub(r"\s+", "", r["question"]))
        if key in seen:
            continue
        if r["db"] not in empty_dbs:
            empty_dbs[r["db"]] = sqlite3.connect(":memory:")
            empty_dbs[r["db"]].executescript(schema_path(r["db"]).read_text(encoding="utf-8"))
            empty_dbs[r["db"]].execute("PRAGMA query_only = ON")
        # RIGHT / FULL JOIN 要 SQLite 3.39+：Mac 上能跑，RunPod 镜像的 Python 带的是 3.37，评测和别人的环境都可能更老
        if OLD_SQLITE_UNSUPPORTED.search(r["sql"]):
            broken += 1
            continue
        try:
            empty_dbs[r["db"]].execute(r["sql"].rstrip(";")).fetchall()
        except sqlite3.Error:
            broken += 1
            continue
        seen.add(key)
        keep.append(r)

    ddls = {db: schema_path(db).read_text(encoding="utf-8") for db in {r["db"] for r in keep}}
    hints = ValueHints(keep, {db: table_columns(ddl) for db, ddl in ddls.items()})
    with_values = 0
    out = ROOT / args.out
    out.parent.mkdir(parents=True, exist_ok=True)
    with out.open("w", encoding="utf-8") as f:
        for r in keep:
            values = hints.for_row(r)
            with_values += values is not None
            msgs = build(ddls[r["db"]], r["question"], values)
            msgs.append({"role": "assistant", "content": r["sql"].rstrip(";") + ";"})
            f.write(json.dumps({"messages": msgs, "db": r["db"]}, ensure_ascii=False) + "\n")

    kinds = Counter(sql_kind(r["sql"]) for r in keep)
    dbs = Counter(r["db"] for r in keep)
    print(f"写好了 {len(keep)} 条 → {out}（原始 {len(rows)} 条，跑不通 {broken}，去重 {len(rows)-len(keep)-broken}）")
    print(f"带「部分字段的取值」的 {with_values} 条（{with_values / len(keep):.0%}）")
    print("库分布：", dict(sorted(dbs.items(), key=lambda x: -x[1])))
    print("类型分布：", dict(kinds.most_common()))


if __name__ == "__main__":
    main()