#!/usr/bin/env python3
"""Phase 1: Re-OCR with single Chandra instance (port 8521), 2 concurrent workers.
Updates DB rows to source_type='ocr_chandra_v2'.
Commits every doc for resilience. Skips already-processed docs.
"""
import duckdb, re, json, time, base64, io, os, sys, hashlib
import requests
from pathlib import Path
from PIL import Image
from concurrent.futures import ThreadPoolExecutor, as_completed
from collections import defaultdict
from qwen_vl_utils.vision_process import smart_resize
import logging

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s", handlers=[
    logging.StreamHandler(sys.stdout),
    logging.FileHandler("/tmp/reocr_phase1.log", mode="a"),
])
log = logging.getLogger("reocr")

DB_PATH = "/root/gwanbo-ocr/data/gwanbo.db"
ST_ROOT = Path("/root/peti/artifacts/searchThema/pdfs")
PETY_ROOT = Path("/root/peti/artifacts/pety/pdfs")
CHANDRA_URL = "http://localhost:8521/v1/chat/completions"
OCR_PROMPT = "OCR this image. Return the full text."
MAX_TOKENS = 8192
WORKERS = 2
MAX_PIXELS = 1280 * 1280
DPI = 150
LOG_INTERVAL = 25

CORRECTIONS = {
    "판보": "관보", "필요인": "금요일", "확요인": "화요일",
    "멸요인": "월요일", "분인": "본인", "동록재선": "등록재산",
    "변동사함": "변동사항", "평주직할시": "광주직할시",
    "대우남구": "대구남구", "썬울": "서울", "뷰산": "부산",
}

def fix_text(t):
    for a, b in CORRECTIONS.items():
        t = t.replace(a, b)
    return t

def load_cache():
    cache = defaultdict(list)
    for fn in ['/tmp/pdftotext_cache.jsonl', '/tmp/pdf_issue_cache_v2.jsonl']:
        if not os.path.exists(fn):
            continue
        with open(fn) as f:
            for line in f:
                rec = json.loads(line)
                iss = str(rec.get("issue", ""))
                if iss and rec.get("year"):
                    cache[(int(rec["year"]), iss)].append({
                        "path": rec["path"],
                        "pages": rec.get("pages", 0),
                    })
    return cache

def find_pdf(cache, year, issue, total_pages):
    key = (int(year), str(issue))
    if key not in cache:
        return None
    for c in cache[key]:
        if c["pages"] == total_pages:
            return c["path"]
    return cache[key][0]["path"] if cache[key] else None

def resolve_pdf_path(path_str):
    if path_str.startswith("/"):
        if os.path.exists(path_str):
            return path_str
        return None
    for root in [ST_ROOT, PETY_ROOT]:
        full = root.parent.parent / path_str
        if os.path.exists(str(full)):
            return str(full)
        full = root.parent / path_str
        if os.path.exists(str(full)):
            return str(full)
    return path_str if os.path.exists(path_str) else None

def render_page(pdf_path, page_num):
    import fitz
    doc = fitz.open(pdf_path)
    if page_num >= doc.page_count:
        doc.close()
        return None
    page = doc[page_num]
    mat = fitz.Matrix(DPI / 72, DPI / 72)
    pix = page.get_pixmap(matrix=mat)
    doc.close()
    img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
    h, w = smart_resize(img.height, img.width, factor=28, max_pixels=MAX_PIXELS)
    if (h, w) != (img.height, img.width):
        img = img.resize((w, h), Image.LANCZOS)
    buf = io.BytesIO()
    img.save(buf, format="JPEG", quality=75)
    return base64.b64encode(buf.getvalue()).decode()

def ocr_chandra(b64):
    payload = {
        "messages": [{"role": "user", "content": [
            {"type": "text", "text": OCR_PROMPT},
            {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{b64}"}},
        ]}],
        "max_tokens": MAX_TOKENS, "temperature": 0.0,
    }
    for attempt in range(3):
        try:
            r = requests.post(CHANDRA_URL, json=payload, timeout=600)
            if r.status_code == 200:
                d = r.json()
                txt = d["choices"][0]["message"]["content"]
                fin = d["choices"][0].get("finish_reason", "?")
                toks = d.get("usage", {}).get("completion_tokens", 0)
                return txt, toks, fin
            log.warning(f"HTTP {r.status_code}, attempt {attempt+1}")
            time.sleep(3)
        except Exception as e:
            log.warning(f"Request error: {e}, attempt {attempt+1}")
            time.sleep(5)
    return None, 0, "error"

def main():
    log.info("Loading cache...")
    cache = load_cache()
    log.info(f"  {len(cache)} issue keys")

    conn = duckdb.connect(DB_PATH)

    already_done = conn.execute("SELECT DISTINCT doc_id FROM page_texts WHERE source_type='ocr_chandra_v2'").fetchall()
    done_set = set(r[0] for r in already_done)
    log.info(f"  Already processed: {len(done_set)} docs (skipped)")

    total_done = 0
    total_fail = 0
    total_truncated = 0
    t_start = time.time()

    for src in ["ocr_chandra", "ocr_searchthema"]:
        log.info(f"=== Processing {src} ===")

        docs = conn.execute(f"""
            SELECT DISTINCT doc_id, year, total_pages
            FROM page_texts WHERE source_type='{src}'
        """).fetchall()
        log.info(f"  {len(docs)} total docs")

        work_items = []
        matched = 0
        skipped = 0
        unmatched = 0

        for doc_id, yr, tp in docs:
            if doc_id in done_set:
                skipped += 1
                continue

            page0 = conn.execute("""
                SELECT text_content FROM page_texts 
                WHERE doc_id=? AND source_type=? AND page_num=0
            """, [doc_id, src]).fetchone()

            first_text = page0[0] if page0 else ""
            issue_nums = re.findall(r'제(\d{4,5})호', first_text or "")
            if not issue_nums:
                issue_nums = re.findall(r'제(\d{4,5})', first_text or "")
            if not issue_nums:
                unmatched += 1
                continue

            pdf_path = find_pdf(cache, yr, issue_nums[0], tp)
            if not pdf_path:
                unmatched += 1
                continue

            resolved = resolve_pdf_path(pdf_path)
            if not resolved:
                unmatched += 1
                continue

            page_nums = conn.execute("""
                SELECT page_num FROM page_texts 
                WHERE doc_id=? AND source_type=? ORDER BY page_num
            """, [doc_id, src]).fetchall()
            page_nums = [r[0] for r in page_nums]

            work_items.append((doc_id, yr, issue_nums[0], resolved, page_nums))
            matched += 1

        log.info(f"  matched={matched}, skipped={skipped}, unmatched={unmatched}")
        if not work_items:
            continue

        src_done = 0

        def process_doc(item):
            doc_id, yr, issue, pdf_path, page_nums = item
            results = []
            for pn in page_nums:
                b64 = render_page(pdf_path, pn)
                if not b64:
                    results.append((pn, None, 0, "render_fail"))
                    continue
                txt, toks, fin = ocr_chandra(b64)
                if txt:
                    results.append((pn, fix_text(txt), toks, fin))
                else:
                    results.append((pn, None, 0, "ocr_fail"))
            return doc_id, results

        with ThreadPoolExecutor(max_workers=WORKERS) as pool:
            futures = {pool.submit(process_doc, item): item for item in work_items}

            for fut in as_completed(futures):
                doc_id, results = fut.result()
                src_done += 1

                updated = 0
                for pn, txt, toks, fin in results:
                    if txt:
                        tl = len(txt)
                        conn.execute("""
                            UPDATE page_texts 
                            SET text_content=?, text_len=?, source_type='ocr_chandra_v2' 
                            WHERE doc_id=? AND page_num=?
                        """, [txt, tl, doc_id, pn])
                        updated += 1
                        if fin == "length":
                            total_truncated += 1
                    else:
                        total_fail += 1

                conn.commit()
                done_set.add(doc_id)
                total_done += updated

                if src_done % LOG_INTERVAL == 0:
                    el = time.time() - t_start
                    rate = total_done / max(el, 1)
                    remaining = 55179 - total_done
                    eta = remaining / max(rate, 0.01) / 3600
                    log.info(f"[{src_done}/{len(work_items)}] pages={total_done:,} fail={total_fail} "
                             f"trunc={total_truncated} rate={rate:.2f}p/s ETA={eta:.1f}h")

        conn.commit()
        el = time.time() - t_start
        log.info(f"  {src} done: {src_done} docs processed in {el:.0f}s")

    conn.commit()
    el = time.time() - t_start

    log.info(f"=== Phase 1 Complete ===")
    log.info(f"  Total pages OCR'd: {total_done:,}")
    log.info(f"  Failed: {total_fail}")
    log.info(f"  Truncated: {total_truncated}")
    log.info(f"  Time: {el:.0f}s ({el/3600:.1f}h)")
    log.info(f"  Rate: {total_done/max(el,1):.2f} p/s")

    for st in ['ocr_chandra', 'ocr_searchthema', 'ocr_chandra_v2', 'digital', 'digital_gs']:
        c = conn.execute(f"SELECT count(*) FROM page_texts WHERE source_type='{st}'").fetchone()[0]
        log.info(f"  {st}: {c:,}")

    out = "/tmp/page_texts_phase1.parquet"
    conn.execute(f"COPY page_texts TO '{out}' (FORMAT PARQUET, COMPRESSION ZSTD)")
    sz = os.path.getsize(out) / 1e9
    log.info(f"Exported: {out} ({sz:.2f} GB)")

    conn.close()

if __name__ == "__main__":
    main()