import re
import torch
from difflib import SequenceMatcher
from transformers import T5Tokenizer, T5ForConditionalGeneration
from transformers.utils import logging as hf_logging

hf_logging.set_verbosity_error()

MODEL_DIR = "t5-viet-qg-finetuned"

PATTERN = re.compile(
    r"""
    “([^”]{3,120})”
  | "([^"]{3,120})"
  | \b(?:là|gồm|do|theo)\s+([^,.;:\n]{3,120})
  | \b\d{4}\b
  | \b(?:Điều|Khoản)\s+\d+\b
    """,
    re.VERBOSE | re.IGNORECASE,
)


def norm(s: str) -> str:
    return re.sub(r"\s+", " ", s).strip()


def is_dup(q: str, qs: list[str], thr: float = 0.85) -> bool:
    ql = q.lower()
    for x in qs:
        if SequenceMatcher(None, ql, x.lower()).ratio() >= thr:
            return True
    return False


def extract_answers(ctx: str, max_n: int = 60) -> list[str]:
    ctx = norm(ctx)
    answers, seen = [], set()

    for m in PATTERN.finditer(ctx):
        for g in m.groups():
            if not g:
                continue
            g = norm(g)
            k = g.lower()
            if 3 <= len(g) <= 120 and k not in seen:
                seen.add(k)
                answers.append(g)
                if len(answers) >= max_n:
                    return answers

    if len(answers) < 8:
        for i in range(0, min(len(ctx), 500), 60):
            ch = norm(ctx[i : i + 60])
            k = ch.lower()
            if len(ch) >= 15 and k not in seen:
                seen.add(k)
                answers.append(ch)
            if len(answers) >= max_n:
                break

    if not answers and ctx:
        answers = [ctx[:120]]

    return answers


def load_model():
    tok = T5Tokenizer.from_pretrained(MODEL_DIR)
    mdl = T5ForConditionalGeneration.from_pretrained(MODEL_DIR)

    dev = "cuda" if torch.cuda.is_available() else "cpu"
    try:
        mdl = mdl.to(dev)
    except RuntimeError:
        dev = "cpu"
        try:
            torch.cuda.empty_cache()
        except Exception:
            pass
        mdl = mdl.to(dev)

    mdl.eval()
    return tok, mdl, dev


tokenizer, model, device = load_model()


def generate_questions(context: str, n: int = 20) -> list[str]:
    ctx = norm(context)
    answers = extract_answers(ctx, max_n=80)
    questions = []

    gen_cfg = dict(
        do_sample=True,
        top_k=80,
        top_p=0.98,
        temperature=1.05,
        max_new_tokens=72,
        no_repeat_ngram_size=3,
        repetition_penalty=1.08,
    )

    num_ret = 8 if n <= 20 else 10

    def run_prompt(ans: str, rounds: int):
        nonlocal gen_cfg
        prompt = f"answer: {ans}\ncontext: {ctx}\nquestion:"
        inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512).to(device)

        for _ in range(rounds):
            outs = model.generate(**inputs, num_return_sequences=num_ret, **gen_cfg)
            added = 0
            for o in outs:
                q = norm(tokenizer.decode(o, skip_special_tokens=True))
                if not q:
                    continue
                if not q.endswith("?"):
                    q += "?"
                if len(q) >= 6 and not is_dup(q, questions, thr=0.85):
                    questions.append(q)
                    added += 1
                if len(questions) >= n:
                    return
            if added == 0:
                gen_cfg["temperature"] = min(1.25, gen_cfg["temperature"] + 0.05)
                gen_cfg["top_p"] = min(0.995, gen_cfg["top_p"] + 0.005)

    with torch.inference_mode():
        for ans in answers:
            if len(questions) >= n:
                break
            run_prompt(ans, rounds=6)

        if len(questions) < n:
            run_prompt(ctx[:120], rounds=12)

    return questions[:n]


if __name__ == "__main__":
    ctx = input("\nNhập đoạn văn bản:\n").strip()
    try:
        n = int((input("\nNhập số lượng câu hỏi cần sinh: ").strip() or ""))
    except ValueError:
        n = 20

    n = max(1, min(n, 200))
    qs = generate_questions(ctx, n)

    print("\nCác câu hỏi sinh ra:")
    for i, q in enumerate(qs, 1):
        print(f"{i}. {q}")