"""
Generate planner-3B greedy predictions on BIRD-train, save as JSONL.
Used downstream by build_validator_paper_format.py to build paper-format SFT data.

Output JSONL row: {sample_id, db_id, db_path, question, evidence, gold_sql, pred_sql,
                   gold_exec, pred_exec, planner_correct}
"""
import argparse, json, os, re, sqlite3, threading, time
os.environ.setdefault("PYTHONNOUSERSITE", "1")
os.environ["NO_PROXY"] = "localhost,127.0.0.1"
import requests
from datasets import load_dataset


def safe_exec(db_path, sql, timeout=5):
    r = [None]; e = [None]
    def _run():
        try:
            c = sqlite3.connect(db_path); c.text_factory = lambda b: b.decode(errors="ignore")
            r[0] = c.execute(sql).fetchmany(100); c.close()
        except Exception as ex:
            e[0] = str(ex)
    t = threading.Thread(target=_run, daemon=True); t.start(); t.join(timeout)
    return (None, "TIMEOUT") if t.is_alive() else (r[0], e[0])


def results_match(g, p):
    if g is None or p is None: return False
    def n(rs): return sorted(tuple(str(v).strip().lower() if v is not None else "" for v in r) for r in rs)
    return n(g) == n(p)


def extract_sql(text):
    m = re.search(r"```(?:sql)?\s*(.*?)\s*```", text, re.DOTALL)
    if m:
        s = m.group(1).strip()
        return s[3:].strip() if s.upper().startswith("SQL") else s
    return ""


def qwen_chat(p):
    return f"<|im_start|>user\n{p}<|im_end|>\n<|im_start|>assistant\n"


def vllm_complete_batch(host, prompts, temperature, max_tokens, seed):
    """Batch completion: prompts is a list, returns list of completion strings (one per prompt)."""
    try:
        r = requests.post(f"{host}/v1/completions", json={
            "model": "planner", "prompt": prompts, "n": 1, "temperature": temperature,
            "top_p": 1.0 if temperature == 0 else 0.9, "max_tokens": max_tokens,
            "seed": seed, "stop": ["<|im_end|>"],
        }, timeout=600)
        r.raise_for_status()
        return [c["text"].strip() for c in r.json()["choices"]]
    except Exception as e:
        print(f"  vLLM batch error: {e}", flush=True)
        return [""] * len(prompts)


def preview(rows, err, limit=300):
    if err: return f"Error: {err[:200]}"
    if rows is None: return "Empty"
    return f"OK. Result rows (preview): {str(rows[:5])[:limit]}"


def main():
    p = argparse.ArgumentParser()
    p.add_argument("--planner_host", default="http://localhost:8100")
    p.add_argument("--out", required=True)
    p.add_argument("--max_questions", type=int, default=-1)
    p.add_argument("--batch_size", type=int, default=64)
    args = p.parse_args()

    with open("data/sft_bird_with_evidence_train_text2sql.json") as f:
        bird_train = json.load(f)

    ds_g = load_dataset("griffith-bigdata/sft_text2sql", split="train_sft",
                        cache_dir="/weka/s225250685/Huggingface/hub").filter(
        lambda x: x["model_name"] == "deepseek-reasoner")
    griffith = {}
    for row in ds_g:
        sid = int(row["sample_id"])
        if not (0 <= sid < len(bird_train)): continue
        user_msg = row["messages"][1]["content"]
        q_m = re.search(r"Question:\s*(.+?)(?:\n|$)", user_msg)
        if not q_m: continue
        q = q_m.group(1).strip()
        if q.lower() == bird_train[sid]["question"].strip().lower():
            griffith[sid] = user_msg
    print(f"griffith prompts: {len(griffith)}", flush=True)

    # Build list of (sid, db_path, planning_prompt) tuples, filtering missing dbs
    work = []
    for sid, user_msg in sorted(griffith.items()):
        bt = bird_train[sid]
        db_path = bt.get("db_path") or f"data/train_databases/{bt['db_id']}/{bt['db_id']}.sqlite"
        if not os.path.exists(db_path):
            cand = bt["db_path"].lstrip("./")
            if os.path.exists(cand): db_path = cand
            else: continue
        planning_prompt = user_msg.rstrip() + "\n\nPlanning:"
        work.append((sid, db_path, planning_prompt, user_msg))
    if args.max_questions > 0: work = work[:args.max_questions]
    print(f"Work items: {len(work)}", flush=True)

    out_f = open(args.out, "w")
    n_done = 0; n_correct = 0
    t0 = time.time()
    for i in range(0, len(work), args.batch_size):
        batch = work[i:i + args.batch_size]
        chat_prompts = [qwen_chat(item[2]) for item in batch]
        completions = vllm_complete_batch(args.planner_host, chat_prompts,
                                          temperature=0.0, max_tokens=1024, seed=42 + i)
        for (sid, db_path, _planning_prompt, user_msg), text in zip(batch, completions):
            bt = bird_train[sid]
            pred_sql = extract_sql(text) if text else ""
            gold_res, gold_err = safe_exec(db_path, bt["sql"])
            pred_res, pred_err = safe_exec(db_path, pred_sql) if pred_sql else (None, "EMPTY")
            planner_correct = (not pred_err) and gold_res is not None and results_match(gold_res, pred_res)
            if planner_correct: n_correct += 1

            rec = {
                "sample_id": sid, "db_id": bt["db_id"], "db_path": db_path,
                "question": bt["question"], "evidence": bt.get("evidence", ""),
                "gold_sql": bt["sql"], "pred_sql": pred_sql,
                "gold_exec": preview(gold_res, gold_err),
                "pred_exec": preview(pred_res, pred_err),
                "planner_correct": planner_correct,
                "user_msg": user_msg,
            }
            out_f.write(json.dumps(rec) + "\n")
            n_done += 1
        out_f.flush()
        elapsed = time.time() - t0
        print(f"  [{n_done}/{len(work)}] correct={n_correct} ({100*n_correct/max(1,n_done):.1f}%) "
              f"elapsed={elapsed:.0f}s ({n_done/max(1,elapsed):.1f}/s)", flush=True)
    out_f.close()
    print(f"\nTotal: {n_done} predictions, {n_correct} correct ({100*n_correct/max(1,n_done):.1f}%)", flush=True)
    print(f"Saved → {args.out}", flush=True)


if __name__ == "__main__":
    main()