scripts/pubs_rag/chunk_papers_lib.py

#!/usr/bin/env python3
"""
Section-Aware Chunker V6 for CMIP6 RAG Pipeline
================================================
Reads Docling .docling.json files (raw JSON, no Pydantic) and produces
semanticly coherent chunks with rich metadata.

V2: Major quality overhaul based on Gemini review of 6,938 chunks.
    Fixes: HTML noise, URN placeholders, figure-axis gibberish, author
    fragments, excessive overlap, URL-only captions.
V5: Data cleaning overhaul based on manual review of 4,567 chunks.
    Fixes: OCR 'ris' stripping restoration, stronger reference-list
    filtering, caption merging, content-hash dedup, section path validation.
V6: Sanitizer based on Gemini 3.1 Pro Preview audit of 4,060 chunks.
    Fixes: context-dependent k/e/Pa OCR fixes, +→C PDF glyph fix,
    digit-density garbage filter, strengthened ref/boilerplate filtering,
    expanded section path validation.

Output: rag/chunks.jsonl  (one JSON object per line)
"""

import json
import re
import sys
import argparse
import hashlib
from pathlib import Path
from typing import Optional

import tiktoken

# ── Configuration ──────────────────────────────────────────────────────────────
PARSED_DIR = Path(__file__).parent / "parsed"
PARSED_LEVANTE_DIR = Path(__file__).parent / "parsed_levante"
OUTPUT_FILE = Path(__file__).parent / "chunks.jsonl"
OUTPUT_LEVANTE_FILE = Path(__file__).parent / "chunks_levante.jsonl"

MAX_TOKENS = 1000       # target cap per chunk
TABLE_MAX_TOKENS = 1200 # hard cap for table chunks (larger allowed)
MIN_TOKENS = 80         # merge if below this
MIN_QUALITY_TOKENS = 30 # absolute minimum to emit a chunk
OVERLAP_RATIO = 0.05    # 5% overlap (reduced from 10% — review showed excessive)
ABSTRACT_SOLO = True    # abstract always gets its own chunk

# Sections to EXCLUDE from RAG (noise for retrieval)
EXCLUDE_SECTIONS = {
    # Academic boilerplate
    "references", "bibliography", "acknowledgements", "acknowledgments",
    "author information", "authors and affiliations", "contributions",
    "author contributions", "corresponding author", "corresponding authors",
    "ethics declarations", "competing interests", "conflict of interest",
    "additional information", "supplementary information", "supplementary material",
    "supplementary materials", "supplementary data",
    "rights and permissions", "about this article", "cite this article",
    "this article is cited by", "data availability", "data availability statement",
    "code availability", "code and data availability", "declarations", "funding",
    "financial support", "review statement", "disclaimer",
    "change history", "ethics and inclusion statement",
    "information & authors", "submission history", "notes",
    "peer review information", "peer review", "publisher's note",
    # V3: Front/back matter from Gemini review
    "lead authors", "contributing authors", "how to cite",
    "table of contents", "contents", "orcidids", "orcids",
    "correspondence", "correspondence to", "edited by", "reviewed by",
    "copyright", "open access", "license",
    "author affiliations", "affiliations",
    "create a new account",  # web UI bleed
    # V6: Boilerplate / publisher noise
    "general rights", "take down policy", "preamble",
    "citation for published version", "citation for published version:",
    "fair data use statement",
    "resources",  # PMC sidebar
    # Journal navigation (Nature, Wiley, AGU, PNAS, etc.)
    "explore content", "about the journal", "publish with us",
    "search", "quick links", "nature.com sitemap",
    "about nature portfolio", "discover content", "publishing policies",
    "author & researcher services", "libraries & institutions",
    "advertising & partnerships", "professional development",
    "regional websites", "similar content being viewed by others",
    "access options", "additional access options:", "subjects",
    "access through your institution", "buy or subscribe",
    # Wiley-specific
    "citing literature", "article metrics", "related articles",
    "connect with wiley", "change password", "forgot your password?",
    "request username", "login", "login / register",
    # PNAS-specific
    "sign up for pnas alerts", "metrics",
    # PMC-specific
    "links to ncbi databases", "cited by other articles",
    # IOP-specific
    "you may also like",
    # General
    "privacy preference center", "manage consent preferences",
    "essential cookies", "performance cookies", "functional cookies",
    "cookie list", "reviewpaper",
}

# Text patterns that indicate HTML navigation noise
NOISE_PATTERNS = [
    r"^skip to (?:main )?content$",
    r"^skip to article$",
    r"^thank you for visiting nature\.com",
    r"^you are using a browser version",
    r"^the best experience",
    r"^internet explorer\b",
    r"^this site uses cookies",
    r"^we use cookies",
    r"^accept all cookies",
    r"^jump to content$",
    r"^page not found$",
    r"^accessibility links$",
    r"^advertisement$",
    r"^log in$",
    r"^sign up$",
    r"^sign in$",
    r"^subscribe$",
    r"^view all",
    # Wiley / AGU / journal navigation
    r"^privacy policy$",
    r"^terms of use$",
    r"^about cookies$",
    r"^manage cookies$",
    r"^accessibility$",
    r"^wiley online library$",
    r"^publication (?:award|policies|ethics)",
    r"^submit a paper$",
    r"^usage statistics$",
    r"^scientific ethics$",
    r"^copyright ©",
    r"^© \d{4}",
    r"^volume \d+.*issue \d+",
    r"^\d+ pages?$",
    r"^open access$",
    r"^full access$",
    r"^free access$",
    r"^download pdf$",
    r"^share$",
    r"^cite$",
    r"^figures?$",
    r"^tables?$",
    r"^related$",
    r"^information$",
    r"^metrics$",
    r"^\s*doi:\s*$",
    # V2: Additional patterns from Gemini review
    r"^download (?:xlsx|pdf|csv|print version)$",
    r"^open in figure viewer$",
    r"^check for updates",
    r"^verify currency and authenticity",
    r"^crossmark$",
    r"^scite metrics$",
    r"^share qr code$",
    r"^altmetric",
    r"^article has an altmetric score",
    r"^forgot your password",
    r"^request username$",
    r"^change password$",
    r"^congrats!$",
    r"^your password must have",
    r"^a lower case character",
    r"^an upper case character",
    r"^a special character",
    r"^or a digit$",
    r"^send email$",
    r"^recipient\(s\) will receive",
    r"^article activity alert$",
    r"^\d+ publications? \d+ supporting",
    r"^this article also appears in",
    r"^multiple terms:",
    r"^we are sorry, but your search",
    r"^turn mathjax on$",
    r"^creative commons attribution",
    r"^data protection$",
    r"^full-text xml$",
    r"^bibtex$",
    r"^ris$",
    r"^endnote$",
    r"^sciencedirect$",
    r"^journals & books$",
    r"^my account$",
    r"^dieses dialogfeld schlie",
    r"^datenschutzrichtlinie",
    r"^geoscientific model development",
    r"^pnas nexus$",
    # URN placeholders (Wiley media refs)
    r"^urn:x-wiley:",
    # Standalone URLs
    r"^https?://",
    # Journal/publisher names as standalone text
    r"^nature climate change$",
    r"^nature communications$",
    r"^nature food$",
    r"^nature reviews",
    r"^scientific data$",
    r"^communications earth",
]
_noise_re = [re.compile(p, re.IGNORECASE) for p in NOISE_PATTERNS]

# Additional exact-match noise strings (lowercased)
_noise_exact = {
    "pdf", "xml", "ris", "abstract", "figures", "references", "related",
    "information", "metrics", "share", "cite", "tables", "home",
    "about", "help", "contact", "feedback", "search",
    "open menu", "close menu", "sections", "tools",
    "download", "save", "print", "export", "alerts",
    "sign in", "register", "my account", "cart",
    "back to top", "next", "previous", "show more",
    "supplementary data", "supplementary materials",
    "view article", "crossref", "google scholar",
    "pubmed", "web of science",
}

# Labels to always skip
SKIP_LABELS = {"page_header", "page_footer", "footnote"}

# ── V5: OCR "ris" Restoration ─────────────────────────────────────────────────
# Docling PDF parser strips the ligature "ris" from words. This dictionary
# maps corrupted forms → correct forms using strict word boundaries.
# Only SAFE corrections with \b boundaries are included.

_OCR_RIS_CORRECTIONS = {
    # ── High-frequency scientific vocabulary ──
    r"\bcompaon\b": "comparison",
    r"\bcompaons\b": "comparisons",
    r"\bcharactetics\b": "characteristics",
    r"\bcharactetic\b": "characteristic",
    r"\bcharacteing\b": "characterising",
    r"\bcharacteed\b": "characterised",
    r"\bcharactee\b": "characterise",
    r"\bcharactees\b": "characterises",
    r"\bcharacteze\b": "characterize",
    r"\bcharactezed\b": "characterized",
    r"\bcharactezes\b": "characterizes",
    r"\bcharactezing\b": "characterizing",
    r"\bcharactezation\b": "characterization",
    r"\bparameteation\b": "parameterisation",
    r"\bparameteations\b": "parameterisations",
    r"\bparameteize\b": "parameterize",
    r"\bparameteized\b": "parameterized",
    r"\bparameteizes\b": "parameterizes",
    r"\bparameteizing\b": "parameterizing",
    r"\bparameteization\b": "parameterization",
    r"\bparameteizations\b": "parameterizations",
    r"\bcompe\b": "comprise",
    r"\bcomped\b": "comprised",
    r"\bcompes\b": "comprises",
    r"\bcomping\b": "comprising",
    r"\bsurpe\b": "surprise",
    r"\bsurped\b": "surprised",
    r"\bsurpes\b": "surprises",
    r"\bsurping\b": "surprising",
    r"\bsurpingly\b": "surprisingly",
    r"\bheutic\b": "heuristic",
    r"\bheutics\b": "heuristics",
    r"\bptine\b": "pristine",
    r"\btoum\b": "tourism",
    r"\btout\b": "tourist",
    r"\btouts\b": "tourists",
    r"\bnouhment\b": "nourishment",
    r"\bdeb\b": "debris",
    r"\ben\b": "risen",
    r"\baes\b": "arises",
    r"\baing\b": "arising",
    r"\bsummaed\b": "summarised",
    r"\bsummaes\b": "summarises",
    r"\bsummae\b": "summarise",
    r"\bregulaed\b": "regularised",
    r"\bregulae\b": "regularise",
    r"\bautherise\b": "authorise",
    r"\bautheed\b": "authorised",
    # ── Author names (case-sensitive) ──
    r"\bChtian\b": "Christian",
    r"\bChtians\b": "Christians",
    r"\bChtianity\b": "Christianity",
    r"\bChtopher\b": "Christopher",
    r"\bChtensen\b": "Christensen",
    r"\bChtoffersen\b": "Christoffersen",
    r"\bChtoph\b": "Christoph",
    r"\bChtophe\b": "Christophe",
    r"\bBbane\b": "Brisbane",
    r"\bKtie\b": "Katie",
    r"\bKtjansson\b": "Kristjansson",
    r"\bKtensen\b": "Kristensen",
    # ── Multi-word phrase fixes (safe context-dependent) ──
    r"\bgives e to\b": "gives rise to",
    r"\bgave e to\b": "gave rise to",
    r"\bgiven e to\b": "given rise to",
    r"\bgiving e to\b": "giving rise to",
    r"\bat k\b": "at risk",
    r"\bat k of\b": "at risk of",
    r"\bthe e of\b": "the rise of",
    r"\bthe e in\b": "the rise in",
    r"\bon the e\b": "on the rise",
    r"\btemperature e\b": "temperature rise",
    r"\bsea level e\b": "sea level rise",
    r"\bsea-level e\b": "sea-level rise",
    r"\bhigh k\b": "high risk",
    r"\blow k\b": "low risk",
    r"\bk assessment\b": "risk assessment",
    r"\bk assessments\b": "risk assessments",
    r"\bk factor\b": "risk factor",
    r"\bk factors\b": "risk factors",
    r"\bk management\b": "risk management",
    r"\bk of\b": "risk of",
    # V6: Expanded context-dependent "k" = risk
    r"\bk reduction\b": "risk reduction",
    r"\bk tolerance\b": "risk tolerance",
    r"\bk Information\b": "risk Information",
    r"\bflood k\b": "flood risk",
    r"\bfire k\b": "fire risk",
    r"\bmortality k\b": "mortality risk",
    r"\benvironmental k\b": "environmental risk",
    r"\bdisaster k\b": "disaster risk",
    r"\bclimate k\b": "climate risk",
    r"\bcompound ks\b": "compound risks",
    r"\bincreasing ks\b": "increasing risks",
    r"\bmeteo-hydrological ks\b": "meteo-hydrological risks",
    r"\bks ae\b": "risks arise",
    r"\bks from\b": "risks from",
    r"\bks and\b": "risks and",
    r"\bks to\b": "risks to",
    r"\bks of\b": "risks of",
    # V6: Expanded context-dependent "e" = rise
    r"\bGMSL e\b": "GMSL rise",
    r"\bing sea level\b": "rising sea level",
    r"\bing temperatures\b": "rising temperatures",
    r"\bing CO2\b": "rising CO2",
    r"\bing food prices\b": "rising food prices",
    r"\bmarked e\b": "marked rise",
    r"\brapid e\b": "rapid rise",
    r"\bglobal e\b": "global rise",
    # V6: "Pa" = Paris
    r"\bPa Agreement\b": "Paris Agreement",
    r"\bglobal climate cis\b": "global climate crisis",
    # V6: "+" → "C" PDF glyph fix
    r"\bHistorical C SSP\b": "Historical + SSP",
}

# Substring-based corrections — these are SAFE because the corrupted forms
# NEVER appear as valid English words/substrings. Used for compound words
# where \b word boundaries fail (e.g., "intercompaon", "compaons").
_OCR_SUBSTR_CORRECTIONS = {
    "compaon": "comparison",  # intercompaon, compaons, etc.
    "charactetic": "characteristic",  # charactetics, charactetically
    "characteing": "characterising",
    "characteed": "characterised",
    "characteze": "characterize",
    "charactezed": "characterized",
    "charactezing": "characterizing",
    "charactezation": "characterization",
    "parameteation": "parameterisation",
    "parameteization": "parameterization",
    "parameteize": "parameterize",
    "parameteized": "parameterized",
    # V6: Additional compound-word substrate fixes
    "enterpe": "enterprise",     # enterprise → enterpe
    "polaing": "polarising",     # polarising → polaing
    "Ctofanelli": "Cristofanelli",  # author name
    "Pco": "Prisco",              # author name
    "Kmer": "Krismer",             # author name
    " fi ": " fi",  # ligature: "signi fi cant" → "significant"
    " fl ": " fl",  # ligature: "in fl uence" → "influence"
    " fi\n": " fi\n",  # fi at line end — SKIP, leave as-is
}

# Build safe substring corrections: the fi/fl ligature fix needs special care.
# "signi fi cant" → rejoin then the word is correct: "significant"
# Strategy: remove the space around fi/fl to rejoin the word.
_OCR_LIGATURE_PATTERNS = [
    (re.compile(r'\b(\w+)\s+fi\s+(\w+)\b'), r'\1fi\2'),   # "signi fi cant" → "significant"
    (re.compile(r'\b(\w+)\s+fl\s+(\w+)\b'), r'\1fl\2'),   # "in fl uence" → "influence"
    (re.compile(r'\b(\w+)\s+ff\s+(\w+)\b'), r'\1ff\2'),   # "e ff ect" → "effect"
]

# Pre-compile word-boundary patterns for speed
_ocr_ris_compiled = [(re.compile(pat), repl) for pat, repl in _OCR_RIS_CORRECTIONS.items()]

# Pre-compile substring patterns (just plain string replace, no regex needed)
_ocr_substr_safe = [
    ("compaon", "comparison"),
    ("charactetic", "characteristic"),
    ("characteing", "characterising"),
    ("characteed", "characterised"),
    ("characteze", "characterize"),
    ("charactezed", "characterized"),
    ("charactezing", "characterizing"),
    ("charactezation", "characterization"),
    ("parameteation", "parameterisation"),
    ("parameteization", "parameterization"),
    ("parameteize", "parameterize"),
    ("parameteized", "parameterized"),
]


def fix_ocr_ris_stripping(text: str) -> str:
    """Fix systematic OCR corruption where 'ris' ligature is stripped from words.
    
    Three-pass approach:
    1. Word-boundary regex for isolated corrupted words
    2. Substring replacement for compound words (intercompaon, etc.)
    3. Ligature rejoining for split fi/fl/ff ligatures
    
    Safe: will never turn a valid word into something wrong.
    """
    # Pass 1: word-boundary corrections
    for pattern, replacement in _ocr_ris_compiled:
        text = pattern.sub(replacement, text)
    
    # Pass 2: substring corrections for compound words
    for old, new in _ocr_substr_safe:
        if old in text:
            text = text.replace(old, new)
    
    # Pass 3: rejoin split fi/fl/ff ligatures
    for pattern, replacement in _OCR_LIGATURE_PATTERNS:
        text = pattern.sub(replacement, text)
    
    return text


# ── V5: Garbage Section Path Detection ────────────────────────────────────────

_JOURNAL_NAME_SECTIONS = {
    "journal of advances in modeling earth systems",
    "reviews of geophysics",
    "geoscientific model development",
    "earth system dynamics",
    "earth system science data",
    "nature climate change",
    "nature communications",
    "nature geoscience",
    "nature food",
    "scientific data",
    "communications earth & environment",
    "environmental research letters",
    "global change biology",
    "journal of climate",
    "pnas",
    "pnas nexus",
    "science advances",
    "science",
}

_garbage_section_re = re.compile(
    r"^-?\d+\.?\d*\s+\d+\.?\d*[°ºÅ]?$"  # coordinate-like: "-25 60", "0 180°"
    r"|^\d{1,4}$"                         # bare numbers: "691"
    r"|^[°ºÅ\d\s.,-]+$"                   # pure numeric/degree strings
    r"|^\w{1,3}$"                          # single tiny word: "net"
    # V6: More garbage patterns
    r"|^PUBLISHED$"                        # Wiley boilerplate
    r"|^Data:?$"                           # floating label
    r"|^[A-Z]{2,4}\s+[A-Z]{2,4}$"         # chart legend: "WCA ECA", "CAU EAU"
    r"|^\d+\|"                             # axis tick prefix: "210|"
    r"|^Figures?\s*\d"                     # "Figures 414", "Figure 3"
    r"|^Supplementary\s+Table\b"           # "Supplementary Table 1..."
    r"|^NPP:\s*"                           # "NPP: MODIS" axis label
)


def is_garbage_section_path(section_name: str) -> bool:
    """Detect section paths that are garbled coordinates, journal names, or gibberish."""
    s = section_name.strip()
    if not s:
        return True
    sl = s.lower()
    if sl in _JOURNAL_NAME_SECTIONS:
        return True
    if _garbage_section_re.match(s):
        return True
    return False

# ── V2: Advanced Noise Detectors ──────────────────────────────────────────────

_urn_re = re.compile(r"urn:x-wiley:", re.IGNORECASE)
_url_only_re = re.compile(r"^\s*https?://\S+\s*$")
_affiliation_re = re.compile(
    r"(?:department|school|university|institute|laboratory|center|centre|faculty)"
    r"|(?:@[a-z0-9.-]+\.[a-z]{2,})"
    r"|(?:orcid\.org)"
    r"|(?:\d{4}-\d{4}-\d{4}-\d{3}[0-9X])",
    re.IGNORECASE
)
_degree_coord_re = re.compile(r"[°ºÅ][NSEW]", re.IGNORECASE)
_ui_button_re = re.compile(
    r"(?:Download|Open in figure viewer|PowerPoint|Print Version|Download XLSX"
    r"|Download PDF|Download CSV|Full-text XML|BibTeX|EndNote|RIS)",
    re.IGNORECASE
)


def is_urn_placeholder(text: str) -> bool:
    """Check if text is mostly Wiley URN placeholders."""
    lines = text.strip().split("\n")
    urn_lines = sum(1 for l in lines if _urn_re.search(l))
    return urn_lines > len(lines) * 0.5


def is_url_only(text: str) -> bool:
    """Check if text is just a URL."""
    return bool(_url_only_re.match(text.strip()))


def is_affiliation_fragment(text: str) -> bool:
    """Check if text is a standalone author affiliation chunk."""
    t = text.strip()
    # Short text with affiliation markers
    if len(t) > 500:
        return False
    matches = len(_affiliation_re.findall(t))
    words = len(t.split())
    if words < 3:
        return False
    # High density of affiliation markers = likely affiliation
    return matches >= 2 and matches / max(words, 1) > 0.05


def is_figure_axis_gibberish(text: str) -> bool:
    """Detect text extracted from figure axes/legends (word-salad)."""
    t = text.strip()
    if len(t) < 30:
        return False
    
    # Heuristic: many degree/coordinate symbols
    coord_matches = len(_degree_coord_re.findall(t))
    if coord_matches > 5:
        return True
    
    # Heuristic: very fragmented text (many very short lines)
    lines = [l.strip() for l in t.split("\n") if l.strip()]
    if len(lines) > 5:
        short_lines = sum(1 for l in lines if len(l.split()) <= 3)
        if short_lines / len(lines) > 0.7:
            return True
    
    # Heuristic: repetitive short fragments separated by spaces
    words = t.split()
    if len(words) > 20:
        # Count 1-2 char "words" (likely axis ticks)
        tiny = sum(1 for w in words if len(w) <= 2 and not w.isalpha())
        if tiny / len(words) > 0.3:
            return True
    
    # V3: Short verb-less lines = axis labels (e.g. "RCP8.5", "Buenos Aires")
    if len(lines) > 8:
        # Check if most lines lack verbs (proxy: no words ending in common verb suffixes)
        verbless = 0
        for line in lines:
            wds = line.split()
            has_verb_like = any(
                w.lower().endswith(('ing', 'tion', 'ted', 'tes', 'ses', 'ize', 'ise', 'ate'))
                for w in wds if len(w) > 3
            )
            if not has_verb_like and len(wds) <= 5:
                verbless += 1
        if verbless / len(lines) > 0.6:
            return True
    
    return False


def is_digit_heavy_garbage(text: str, threshold: float = 0.30) -> bool:
    """V6: Detect chunks that are mostly numbers/symbols (axis data, coordinates).
    
    If >30% of characters are digits and special symbols, this is likely
    visual garbage from chart axes, coordinate grids, or figure annotations.
    """
    t = text.strip()
    if len(t) < 50:
        return False
    symbols = sum(1 for c in t if c.isdigit() or c in "°±+-.,|<>[]{}()=×÷")
    return symbols / len(t) > threshold


def is_boilerplate_noise(text: str) -> bool:
    """V6: Detect publisher boilerplate, copyright text, and preprint disclaimers."""
    t = text.strip().lower()
    boilerplate_markers = [
        "copyright and moral rights",
        "research square preprints are preliminary",
        "in the format provided by the authors and unedited",
        "take down policy",
        "general rights",
        "citation for published version",
        "verify currency and authenticity",
        "version of record",
    ]
    matches = sum(1 for m in boilerplate_markers if m in t)
    return matches >= 2 or (matches >= 1 and len(t) < 300)


# V3/V5: Reference-like text detector (strengthened in V5)
_ref_pattern = re.compile(
    r"(?:[A-Z][a-z]+(?:,\s*[A-Z]\.?)+\s*(?:,|&|and)\s*){2,}"
    r"|(?:\(\d{4}[a-z]?\))"
    r"|(?:et\s+al\.?,\s*\d{4})"
    r"|(?:doi:\s*10\.\d{4,})",
    re.IGNORECASE
)
_doi_re_v5 = re.compile(r"10\.\d{4,9}/\S+")
_year_bracket_re = re.compile(r"\(\d{4}[a-z]?\)")

def is_reference_block(text: str) -> bool:
    """Detect if text is mostly bibliographic references.
    
    V5: Added DOI density and year-bracket density checks.
    V6: Lowered thresholds (DOI 5→3, years 8→6), added "et al." density.
    """
    t = text.strip()
    if len(t) < 100:
        return False
    
    # V6: DOI density check — if 3+ DOIs in one chunk, it's a ref block
    doi_count = len(_doi_re_v5.findall(t))
    if doi_count >= 3:
        return True
    
    # V6: Year-bracket density — 6+ year citations like (2019) in one chunk
    year_count = len(_year_bracket_re.findall(t))
    if year_count >= 6:
        return True
    
    # V6: "et al." density — 6+ occurrences = bibliography
    et_al_count = t.lower().count("et al")
    if et_al_count >= 6:
        return True
    
    # V3: Line-based detection
    lines = [l.strip() for l in t.split("\n") if l.strip()]
    if len(lines) < 3:
        return False
    ref_lines = sum(1 for l in lines if _ref_pattern.search(l))
    # If >60% of lines look like references
    return ref_lines / len(lines) > 0.6


def has_repeating_loop(text: str, min_repeat: int = 3) -> bool:
    """Detect text with repeating string loops (e.g. 'Coral: Bard...' x10)."""
    t = text.strip()
    if len(t) < 200:
        return False
    # Check for any substring of 20+ chars repeating 3+ times
    for length in (50, 30, 20):
        for start in range(0, min(len(t) - length, 500), 10):
            substr = t[start:start + length]
            if t.count(substr) >= min_repeat:
                return True
    return False


_line_noise_re = re.compile(
    r"^(?:"
    r"urn:x-wiley:|"
    r"https?://\S+$|"
    r"Dieses Dialogfeld|"
    r"Datenschutzrichtlinie|"
    r"This site uses cookies|"
    r"We use cookies|"
    r"Accept all cookies|"
    r"Forgot your password|"
    r"Request Username|"
    r"Change Password|"
    r"Your password must have|"
    r"a lower case character|"
    r"an upper case character|"
    r"a special character|"
    r"or a digit|"
    r"Congrats!|"
    r"Login / Register|"
    r"Scite metrics|"
    r"Share QR Code|"
    r"Access through your institution|"
    r"Buy or subscribe|"
    r"Check for updates|"
    r"Open in figure viewer|"
    r"Wiley Online Library|"
    r"Article Activity Alert|"
    r"Send Email|"
    r"Recipient\(s\) will receive|"
    r"Article has an altmetric score|"
    r"\d+ publications? \d+ supporting|"
    r"Download & links|"
    r"Full-text XML|"
    r"BibTeX|"
    r"Multiple terms:|"
    r"We are sorry, but your search|"
    r"Turn MathJax on|"
    r"Creative Commons|"
    r"Connect with Wiley|"
    r"Privacy Preference Center|"
    r"Manage Consent Preferences|"
    r"Essential cookies|"
    r"Performance cookies|"
    r"Functional cookies|"
    r"Cookie List|"
    # V3: Additional boilerplate patterns
    r"Correspondence to:|"
    r"Received:\s+\d|"
    r"Accepted:\s+\d|"
    r"Published:\s+\d|"
    r"Edited by:|"
    r"Reviewed by:|"
    r"Lead Authors?:|"
    r"Contributing Authors?:|"
    r"How to cite|"
    r"Crown copyright|"
    r"Attribution \d\.\d License|"
    r"An official website of the United States|"
    r"Search PMC|"
    r"Sorry, we could not find|"
    r"Go to Figure|"
    r"Open all in viewer|"
    r"There are no results for"
    r")",
    re.IGNORECASE
)


def clean_ui_from_text(text: str) -> str:
    """Strip embedded UI elements and noise lines from text."""
    # Remove "Open in figure viewer PowerPoint" etc.
    text = _ui_button_re.sub("", text)
    # Remove "Check for updates" boilerplate
    text = re.sub(r"Check for updates\.?\s*Verify currency and authenticity via CrossMark\.?", "", text)

    # V2: Line-level noise removal — strip individual noise lines
    lines = text.split("\n")
    clean_lines = []
    for line in lines:
        stripped = line.strip()
        if not stripped:
            clean_lines.append(line)
            continue
        if _line_noise_re.match(stripped):
            continue  # skip this line
        # Skip pure URN lines
        if stripped.startswith("urn:"):
            continue
        clean_lines.append(line)

    text = "\n".join(clean_lines)

    # Remove excessive blank lines
    text = re.sub(r"\n{3,}", "\n\n", text)
    return text.strip()

# ── Tokenizer ──────────────────────────────────────────────────────────────────
_enc = tiktoken.get_encoding("cl100k_base")


def count_tokens(text: str) -> int:
    """Count tokens using cl100k_base (≈same as Gemini tokenization)."""
    return len(_enc.encode(text))


# ── Noise Detection ────────────────────────────────────────────────────────────

def is_noise_text(text: str) -> bool:
    """Return True if text is HTML navigation / cookie banner noise."""
    t = text.strip()
    if len(t) < 3:
        return True
    tl = t.lower()
    if tl in _noise_exact:
        return True
    for pat in _noise_re:
        if pat.search(t):
            return True
    # V2: URN placeholders
    if is_urn_placeholder(t):
        return True
    # V2: Standalone URLs
    if is_url_only(t):
        return True
    return False


def is_excluded_section(section_name: str) -> bool:
    """Return True if section should be excluded from RAG."""
    return section_name.strip().lower() in EXCLUDE_SECTIONS


# ── Document Tree Walker ───────────────────────────────────────────────────────

class DocNode:
    """A node in the document tree."""
    __slots__ = ("label", "text", "children", "ref", "table_data")

    def __init__(self, label: str, text: str = "", ref: str = "",
                 table_data: Optional[dict] = None):
        self.label = label
        self.text = text
        self.children: list["DocNode"] = []
        self.ref = ref
        self.table_data = table_data


def build_item_index(doc: dict) -> dict:
    """Build a ref -> raw item lookup from the docling document."""
    items = {}
    for collection in ("texts", "groups", "tables", "pictures",
                       "key_value_items", "form_items"):
        for item in doc.get(collection, []):
            ref = item.get("self_ref", "")
            if ref:
                items[ref] = item
    return items


def resolve_ref(child_ptr: dict) -> str:
    """Extract the reference string from a child pointer."""
    return child_ptr.get("cref", child_ptr.get("$ref", ""))


def build_tree(doc: dict) -> DocNode:
    """Build a tree of DocNodes from the docling document body."""
    items = build_item_index(doc)
    root = DocNode(label="root", text="document")

    def _build(children_list: list) -> list[DocNode]:
        nodes = []
        for child_ptr in children_list:
            ref = resolve_ref(child_ptr)
            raw = items.get(ref, {})
            label = raw.get("label", "unknown")
            text = raw.get("text", "")

            # For tables, preserve the full data
            table_data = None
            if label == "table" or "tables" in ref:
                table_data = raw

            node = DocNode(label=label, text=text, ref=ref,
                           table_data=table_data)

            # Recurse into children
            if "children" in raw:
                node.children = _build(raw["children"])

            nodes.append(node)
        return nodes

    body = doc.get("body", {})
    root.children = _build(body.get("children", []))
    return root


# ── Section Collector ──────────────────────────────────────────────────────────

class Section:
    """A logical section of the document."""
    __slots__ = ("name", "path", "paragraphs", "tables", "captions", "level")

    def __init__(self, name: str, path: str, level: int = 0):
        self.name = name
        self.path = path
        self.level = level
        self.paragraphs: list[str] = []  # text blocks
        self.tables: list[dict] = []     # table data
        self.captions: list[str] = []    # figure/table captions


def collect_sections(root: DocNode) -> list[Section]:
    """Walk the document tree and collect sections with their content."""
    sections: list[Section] = []
    current_section = Section(name="Preamble", path="Preamble", level=0)

    def _walk(node: DocNode, section_path_parts: list[str], depth: int):
        nonlocal current_section

        # Skip noise
        if node.label in SKIP_LABELS:
            return
        if node.label in ("text", "list_item") and is_noise_text(node.text):
            return

        # Section header → start new section
        if node.label == "section_header":
            header_text = node.text.strip()
            if not header_text:
                return

            # Check if this section should be excluded
            if is_excluded_section(header_text):
                # Still process children but mark section as excluded
                excluded = Section(name=header_text,
                                   path=" > ".join(section_path_parts + [header_text]),
                                   level=depth)
                excluded.paragraphs.append("__EXCLUDED__")
                sections.append(excluded)
                return

            # Save current section if it has content
            if current_section.paragraphs or current_section.tables or current_section.captions:
                sections.append(current_section)

            new_path = section_path_parts + [header_text]
            current_section = Section(
                name=header_text,
                path=" > ".join(new_path),
                level=depth,
            )
            # Process children under this section header
            for child in node.children:
                _walk(child, new_path, depth + 1)
            return

        # Text content
        if node.label in ("text", "list_item"):
            text = node.text.strip()
            if text and len(text) > 5:
                current_section.paragraphs.append(text)

        # Caption
        elif node.label == "caption":
            text = node.text.strip()
            if text:
                current_section.captions.append(text)

        # Table
        elif node.label == "table" or node.table_data:
            current_section.tables.append(node.table_data or {"text": node.text})

        # Key-value area, list, group, picture, inline → recurse
        for child in node.children:
            _walk(child, section_path_parts, depth)

    for child in root.children:
        _walk(child, [], 0)

    # Don't forget the last section
    if current_section.paragraphs or current_section.tables or current_section.captions:
        sections.append(current_section)

    return sections


# ── Markdown Section Parser (MinerU VLM) ───────────────────────────────────────

_md_header_re = re.compile(r'^(#{1,6})\s+(.+)$', re.MULTILINE)
_md_table_line_re = re.compile(r'^\|.*\|\s*$')
_md_figure_caption_re = re.compile(
    r'^(?:Figure|Fig\.|Table|Plate|Scheme)\s+\d+',
    re.IGNORECASE
)
_md_image_ref_re = re.compile(r'^!\[.*\]\(.*\)$')


def parse_markdown_sections(md_text: str) -> list["Section"]:
    """Parse MinerU VLM markdown into Section objects using # headers.
    
    Handles:
    - # / ## / ### headers → section boundaries
    - Markdown tables (| col | col |) → table entries
    - Figure/Table captions → caption entries
    - Image references ![...](...) → skipped
    - Everything else → text paragraphs
    """
    sections: list[Section] = []
    current_section = Section(name="Preamble", path="Preamble", level=0)
    section_stack: list[tuple[int, str]] = []  # (level, name) for building paths
    
    lines = md_text.split('\n')
    i = 0
    
    while i < len(lines):
        line = lines[i]
        stripped = line.strip()
        
        # Skip empty lines
        if not stripped:
            i += 1
            continue
        
        # Skip image references
        if _md_image_ref_re.match(stripped):
            i += 1
            continue
        
        # Check for header
        header_match = _md_header_re.match(stripped)
        if header_match:
            level = len(header_match.group(1))  # number of #s
            header_text = header_match.group(2).strip()
            
            if not header_text:
                i += 1
                continue
            
            # Save current section if it has content
            if current_section.paragraphs or current_section.tables or current_section.captions:
                sections.append(current_section)
            
            # Update section stack
            while section_stack and section_stack[-1][0] >= level:
                section_stack.pop()
            section_stack.append((level, header_text))
            
            # Build section path from stack
            path_parts = [name for _, name in section_stack]
            section_path = " > ".join(path_parts)
            
            # Check if excluded
            if is_excluded_section(header_text):
                current_section = Section(name=header_text, path=section_path, level=level)
                current_section.paragraphs.append("__EXCLUDED__")
                sections.append(current_section)
                # Skip content until next header of same or higher level
                i += 1
                while i < len(lines):
                    next_match = _md_header_re.match(lines[i].strip())
                    if next_match and len(next_match.group(1)) <= level:
                        break
                    i += 1
                current_section = Section(name="[continued]", path="[continued]", level=0)
                continue
            
            current_section = Section(name=header_text, path=section_path, level=level)
            i += 1
            continue
        
        # Check for markdown table block
        if _md_table_line_re.match(stripped):
            table_lines = []
            while i < len(lines) and _md_table_line_re.match(lines[i].strip()):
                table_lines.append(lines[i].strip())
                i += 1
            if table_lines:
                table_text = '\n'.join(table_lines)
                current_section.tables.append({"text": table_text})
            continue
        
        # Check for figure/table caption
        if _md_figure_caption_re.match(stripped):
            # Collect multi-line caption
            caption_lines = [stripped]
            i += 1
            while i < len(lines) and lines[i].strip() and not _md_header_re.match(lines[i].strip()):
                if _md_table_line_re.match(lines[i].strip()):
                    break
                if _md_image_ref_re.match(lines[i].strip()):
                    i += 1
                    continue
                if _md_figure_caption_re.match(lines[i].strip()):
                    break  # new caption starts
                caption_lines.append(lines[i].strip())
                i += 1
            current_section.captions.append(' '.join(caption_lines))
            continue
        
        # Regular text — skip noise
        if is_noise_text(stripped):
            i += 1
            continue
        
        # Collect paragraph (consecutive non-empty, non-header lines)
        para_lines = [stripped]
        i += 1
        while i < len(lines):
            next_stripped = lines[i].strip()
            if not next_stripped:  # blank line = paragraph break
                break
            if _md_header_re.match(next_stripped):
                break
            if _md_table_line_re.match(next_stripped):
                break
            if _md_image_ref_re.match(next_stripped):
                i += 1
                continue
            if is_noise_text(next_stripped):
                i += 1
                continue
            para_lines.append(next_stripped)
            i += 1
        
        para_text = ' '.join(para_lines)
        if len(para_text) > 5:
            current_section.paragraphs.append(para_text)
    
    # Don't forget the last section
    if current_section.paragraphs or current_section.tables or current_section.captions:
        sections.append(current_section)
    
    return sections


def chunk_markdown_document(md_path: Path, paper_id: str) -> list[dict]:
    """Chunk a MinerU VLM markdown file using the same pipeline as docling.
    
    Reuses: all filters, OCR fixes, overlap, token budget, dedup, etc.
    """
    with open(md_path, 'r', encoding='utf-8', errors='replace') as f:
        md_text = f.read()
    
    meta_path = md_path.with_suffix(".meta.json")
    meta = {}
    if meta_path.exists():
        with open(meta_path, 'r', encoding='utf-8') as mf:
            try:
                meta = json.load(mf)
            except Exception:
                pass

    # Extract DOI from paper_id (folder name or meta)
    doi = meta.get("doi")
    if not doi:
        parts = paper_id.split('_', 2)
        if len(parts) >= 3 and parts[0] == '10':
            doi = f"10.{parts[1]}/{parts[2].replace('_', '.')}"
        else:
            doi = paper_id.replace('_', '/')
    
    title = meta.get("title", "")
    year = meta.get("year", "")
    journal = meta.get("journal", "")
    tier = meta.get("tier", "UNKNOWN")
    
    # Parse markdown into sections
    sections = parse_markdown_sections(md_text)
    
    # ── Reuse the EXACT same chunking pipeline ──
    chunks_out = []
    chunk_counter = 0
    seen_hashes = set()
    
    for section in sections:
        if section.paragraphs == ["__EXCLUDED__"]:
            continue
        
        section_path = section.path
        if is_garbage_section_path(section.name):
            section_path = "[section unknown]"
        
        # ── Text chunks ──
        if section.paragraphs:
            full_text = "\n\n".join(section.paragraphs)
            full_text = fix_ocr_ris_stripping(full_text)
            text_tokens = count_tokens(full_text)
            
            is_abstract = section.name.strip().lower() == "abstract"
            chunk_type = "abstract" if is_abstract else "text"
            
            if text_tokens <= MAX_TOKENS:
                raw_chunks = [full_text]
            else:
                raw_chunks = chunk_text_block(full_text, MAX_TOKENS)
            
            if len(raw_chunks) > 1:
                raw_chunks = add_overlap(raw_chunks, OVERLAP_RATIO)
            
            capped = []
            for rc in raw_chunks:
                if count_tokens(rc) > MAX_TOKENS + 50:
                    capped.extend(chunk_text_block(rc, MAX_TOKENS))
                else:
                    capped.append(rc)
            raw_chunks = capped
            
            for i_chunk, chunk_text in enumerate(raw_chunks):
                ct = count_tokens(chunk_text)
                if ct < MIN_QUALITY_TOKENS:
                    continue
                chunk_text = clean_ui_from_text(chunk_text)
                if not chunk_text or count_tokens(chunk_text) < MIN_QUALITY_TOKENS:
                    continue
                if is_figure_axis_gibberish(chunk_text):
                    continue
                if is_digit_heavy_garbage(chunk_text):
                    continue
                if is_boilerplate_noise(chunk_text):
                    continue
                if is_affiliation_fragment(chunk_text):
                    continue
                if is_reference_block(chunk_text):
                    continue
                if has_repeating_loop(chunk_text):
                    continue
                
                content_hash = hashlib.md5(chunk_text.encode()).hexdigest()
                if content_hash in seen_hashes:
                    continue
                seen_hashes.add(content_hash)
                
                prefix = f'Paper: "{title}"' if title else f'Paper: {paper_id}'
                if year:
                    prefix += f" ({year}"
                    if journal:
                        prefix += f", {journal}"
                    prefix += ")"
                elif journal:
                    prefix += f" ({journal})"
                prefix += f"\nDOI: {doi}"
                prefix += f"\nSection: {section_path}"
                prefix += "\n---\n"
                
                text_with_prefix = prefix + chunk_text
                chunk_id = f"{paper_id}__{content_hash[:12]}"
                
                chunks_out.append({
                    "chunk_id": chunk_id,
                    "paper_id": doi,
                    "doi": doi,
                    "title": title,
                    "year": int(year) if str(year).isdigit() else year,
                    "journal": journal,
                    "tier": tier,
                    "section_path": section_path,
                    "section_name": section.name,
                    "chunk_type": chunk_type,
                    "chunk_index": chunk_counter,
                    "token_count": count_tokens(text_with_prefix),
                    "text_with_prefix": text_with_prefix,
                    "text_raw": chunk_text,
                })
                chunk_counter += 1
        
        # ── Table chunks ──
        for j, tbl in enumerate(section.tables):
            tbl_text = tbl.get("text", "")
            if not tbl_text or count_tokens(tbl_text) < 10:
                continue
            
            caption = ""
            if j < len(section.captions):
                caption = section.captions[j]
            
            context = f"[TABLE in section: {section_path}]"
            if caption:
                context += f"\nCaption: {caption}"
            full_table = context + "\n\n" + tbl_text
            
            prefix = f'Paper: "{title}"' if title else f'Paper: {paper_id}'
            if year:
                prefix += f" ({year}"
                if journal:
                    prefix += f", {journal}"
                prefix += ")"
            prefix += f"\nDOI: {doi}"
            prefix += f"\nSection: {section_path}"
            prefix += "\n---\n"
            
            text_with_prefix = prefix + full_table
            chunk_id_raw = f"{doi}__table__{section_path}__{j}"
            chunk_id = hashlib.md5(chunk_id_raw.encode()).hexdigest()[:12]
            chunk_id = f"{paper_id}__tbl_{chunk_id}"
            
            # Truncate oversized tables
            if count_tokens(tbl_text) > TABLE_MAX_TOKENS:
                tbl_lines = tbl_text.split('\n')
                kept = []
                tok_count = 0
                for tl in tbl_lines:
                    lt = count_tokens(tl)
                    if tok_count + lt > TABLE_MAX_TOKENS - 20:
                        break
                    kept.append(tl)
                    tok_count += lt
                tbl_text = '\n'.join(kept) + f"\n[... TABLE TRUNCATED ...]"
                full_table = context + "\n\n" + tbl_text
                text_with_prefix = prefix + full_table
            
            chunks_out.append({
                "chunk_id": chunk_id,
                "paper_id": doi,
                "doi": doi,
                "title": title,
                "year": int(year) if str(year).isdigit() else year,
                "journal": journal,
                "tier": tier,
                "section_path": section_path,
                "section_name": section.name,
                "chunk_type": "table",
                "chunk_index": chunk_counter,
                "token_count": count_tokens(text_with_prefix),
                "text_with_prefix": text_with_prefix,
                "text_raw": full_table,
            })
            chunk_counter += 1
        
        # ── Standalone captions ──
        unpaired = section.captions[len(section.tables):]
        for k, cap in enumerate(unpaired):
            if count_tokens(cap) < 10:
                continue
            if is_url_only(cap):
                continue
            cap = clean_ui_from_text(cap)
            if not cap or count_tokens(cap) < 10:
                continue
            cap = fix_ocr_ris_stripping(cap)
            
            prefix = f'Paper: "{title}"' if title else f'Paper: {paper_id}'
            if year:
                prefix += f" ({year}"
                if journal:
                    prefix += f", {journal}"
                prefix += ")"
            prefix += f"\nDOI: {doi}"
            prefix += f"\nSection: {section_path}"
            prefix += "\n---\n"
            
            text_with_prefix = prefix + f"[FIGURE CAPTION]\n{cap}"
            chunk_id_raw = f"{doi}__caption__{section_path}__{k}"
            chunk_id = hashlib.md5(chunk_id_raw.encode()).hexdigest()[:12]
            chunk_id = f"{paper_id}__cap_{chunk_id}"
            
            chunks_out.append({
                "chunk_id": chunk_id,
                "paper_id": doi,
                "doi": doi,
                "title": title,
                "year": int(year) if str(year).isdigit() else year,
                "journal": journal,
                "tier": tier,
                "section_path": section_path,
                "section_name": section.name,
                "chunk_type": "caption",
                "chunk_index": chunk_counter,
                "token_count": count_tokens(text_with_prefix),
                "text_with_prefix": text_with_prefix,
                "text_raw": cap,
            })
            chunk_counter += 1
    
    # ── Post-process: merge tiny chunks ──
    MIN_CAPTION_STANDALONE = 150
    merged = []
    ii = 0
    while ii < len(chunks_out):
        chunk = chunks_out[ii]
        if (chunk["token_count"] < MIN_TOKENS and
                chunk["chunk_type"] == "text" and
                ii + 1 < len(chunks_out) and
                chunks_out[ii + 1]["section_path"] == chunk["section_path"] and
                chunks_out[ii + 1]["chunk_type"] == "text"):
            next_chunk = chunks_out[ii + 1]
            merged_text = chunk["text_raw"] + "\n\n" + next_chunk["text_raw"]
            merged_prefix = chunk["text_with_prefix"].split("---\n", 1)[0] + "---\n" + merged_text
            next_chunk["text_raw"] = merged_text
            next_chunk["text_with_prefix"] = merged_prefix
            next_chunk["token_count"] = count_tokens(merged_prefix)
            ii += 1
        elif (chunk["chunk_type"] == "caption" and
              chunk["token_count"] < MIN_CAPTION_STANDALONE and
              merged and
              merged[-1]["section_path"] == chunk["section_path"] and
              merged[-1]["chunk_type"] == "text"):
            prev = merged[-1]
            appended_text = prev["text_raw"] + "\n\n[Figure caption: " + chunk["text_raw"] + "]"
            appended_prefix = prev["text_with_prefix"].split("---\n", 1)[0] + "---\n" + appended_text
            prev["text_raw"] = appended_text
            prev["text_with_prefix"] = appended_prefix
            prev["token_count"] = count_tokens(appended_prefix)
            ii += 1
        else:
            merged.append(chunk)
            ii += 1
    
    for idx, c in enumerate(merged):
        c["chunk_index"] = idx
    
    return merged


# ── Sentence Splitter ──────────────────────────────────────────────────────────

_sent_re = re.compile(
    r'(?<=[.!?])\s+(?=[A-Z])'    # Split after sentence-ending punct + space + capital
    r'|(?<=[.!?])\s*\n'          # or after punct + newline
)


def split_sentences(text: str) -> list[str]:
    """Split text into sentences (conservative)."""
    parts = _sent_re.split(text)
    return [s.strip() for s in parts if s.strip()]


# ── Smart Chunking ─────────────────────────────────────────────────────────────

def chunk_text_block(text: str, max_tokens: int = MAX_TOKENS) -> list[str]:
    """Split a text block into chunks respecting sentence boundaries."""
    sentences = split_sentences(text)
    if not sentences:
        return [text] if text.strip() else []

    chunks = []
    current = []
    current_tokens = 0

    for sent in sentences:
        sent_tokens = count_tokens(sent)

        # If single sentence exceeds max, force-split by words
        if sent_tokens > max_tokens:
            if current:
                chunks.append(" ".join(current))
                current = []
                current_tokens = 0
            words = sent.split()
            buf = []
            buf_tokens = 0
            for w in words:
                wt = count_tokens(w + " ")
                if buf_tokens + wt > max_tokens and buf:
                    chunks.append(" ".join(buf))
                    buf = []
                    buf_tokens = 0
                buf.append(w)
                buf_tokens += wt
            if buf:
                chunks.append(" ".join(buf))
            continue

        if current_tokens + sent_tokens > max_tokens and current:
            chunks.append(" ".join(current))
            current = []
            current_tokens = 0

        current.append(sent)
        current_tokens += sent_tokens

    if current:
        chunks.append(" ".join(current))

    return chunks


def add_overlap(chunks: list[str], ratio: float = OVERLAP_RATIO) -> list[str]:
    """Add sentence-level overlap between consecutive chunks."""
    if len(chunks) <= 1:
        return chunks

    result = [chunks[0]]
    for i in range(1, len(chunks)):
        prev_sents = split_sentences(chunks[i - 1])
        if not prev_sents:
            result.append(chunks[i])
            continue

        # Take last N sentences as overlap
        overlap_tokens_target = int(count_tokens(chunks[i - 1]) * ratio)
        overlap_sents = []
        overlap_tokens = 0
        for s in reversed(prev_sents):
            st = count_tokens(s)
            if overlap_tokens + st > overlap_tokens_target and overlap_sents:
                break
            overlap_sents.insert(0, s)
            overlap_tokens += st

        overlap_text = " ".join(overlap_sents)
        result.append(overlap_text + " " + chunks[i])

    return result


def table_to_text(table_data: dict, max_tokens: int = TABLE_MAX_TOKENS) -> str:
    """Convert a Docling table to text representation, truncating if needed."""
    if not table_data:
        return ""

    raw = ""
    # Try to extract grid data
    grid = table_data.get("data", {}).get("grid", [])
    if grid:
        lines = []
        for row in grid:
            cells = []
            for cell in row:
                text = cell.get("text", "")
                cells.append(text)
            lines.append(" | ".join(cells))
        raw = "\n".join(lines)
    else:
        # Fallback: use text or markdown representation
        raw = table_data.get("text", "")

    if not raw:
        return "[Table content not extractable]"

    # Truncate oversized tables
    if count_tokens(raw) > max_tokens:
        # Keep first N rows that fit within token budget
        lines = raw.split("\n")
        kept = []
        tok_count = 0
        for line in lines:
            lt = count_tokens(line)
            if tok_count + lt > max_tokens - 20:  # leave room for truncation marker
                break
            kept.append(line)
            tok_count += lt
        raw = "\n".join(kept) + f"\n[... TABLE TRUNCATED, {len(lines) - len(kept)} more rows ...]"

    return raw


# ── Main Chunking Pipeline ─────────────────────────────────────────────────────

def chunk_document(docling_path: Path, meta_path: Path) -> list[dict]:
    """Chunk a single document into retrieval-ready pieces."""
    # Load docling JSON (raw, fast)
    with open(docling_path) as f:
        doc = json.load(f)

    # Load metadata
    meta = {}
    if meta_path.exists():
        with open(meta_path) as f:
            meta = json.load(f)

    doi = meta.get("doi", docling_path.stem.replace("_", "/", 1)
                   .replace("_", ".", 1))
    title = meta.get("title", doc.get("name", "Unknown"))
    year = meta.get("year", "")
    journal = meta.get("journal", "")
    tier = meta.get("tier", "CORE")
    paper_id = doi

    # Build tree and collect sections
    tree = build_tree(doc)
    sections = collect_sections(tree)

    chunks_out = []
    chunk_counter = 0
    seen_hashes = set()  # V5: content-hash deduplication

    for section in sections:
        # Skip excluded sections
        if section.paragraphs == ["__EXCLUDED__"]:
            continue

        section_path = section.path
        # V5: Fix garbage section paths
        if is_garbage_section_path(section.name):
            section_path = f"[section unknown]"

        # ── Text chunks ──
        if section.paragraphs:
            full_text = "\n\n".join(section.paragraphs)
            # V5: Apply OCR "ris" restoration
            full_text = fix_ocr_ris_stripping(full_text)
            text_tokens = count_tokens(full_text)

            # Determine chunk type
            is_abstract = section.name.strip().lower() == "abstract"
            chunk_type = "abstract" if is_abstract else "text"

            if text_tokens <= MAX_TOKENS:
                # Section fits in one chunk
                raw_chunks = [full_text]
            else:
                # Split by sentence boundaries
                raw_chunks = chunk_text_block(full_text, MAX_TOKENS)

            # Add overlap between chunks in same section
            if len(raw_chunks) > 1:
                raw_chunks = add_overlap(raw_chunks, OVERLAP_RATIO)

            # Hard cap: re-split any chunks that exceeded MAX_TOKENS after overlap
            capped = []
            for rc in raw_chunks:
                if count_tokens(rc) > MAX_TOKENS + 50:  # small slack
                    capped.extend(chunk_text_block(rc, MAX_TOKENS))
                else:
                    capped.append(rc)
            raw_chunks = capped

            for i, chunk_text in enumerate(raw_chunks):
                ct = count_tokens(chunk_text)
                if ct < MIN_QUALITY_TOKENS:
                    continue

                # V2: Clean UI remnants from text
                chunk_text = clean_ui_from_text(chunk_text)
                if not chunk_text or count_tokens(chunk_text) < MIN_QUALITY_TOKENS:
                    continue

                # V2: Skip figure axis gibberish
                if is_figure_axis_gibberish(chunk_text):
                    continue

                # V6: Skip digit-heavy garbage (axis data, coordinate grids)
                if is_digit_heavy_garbage(chunk_text):
                    continue

                # V6: Skip publisher boilerplate
                if is_boilerplate_noise(chunk_text):
                    continue

                # V2: Skip affiliation fragments
                if is_affiliation_fragment(chunk_text):
                    continue

                # V3/V6: Skip reference blocks (refs hidden under wrong section headers)
                if is_reference_block(chunk_text):
                    continue

                # V3: Skip repeating string loops
                if has_repeating_loop(chunk_text):
                    continue

                # V5: Content-hash deduplication
                content_hash = hashlib.md5(chunk_text.encode()).hexdigest()
                if content_hash in seen_hashes:
                    continue
                seen_hashes.add(content_hash)

                # Build metadata prefix
                prefix = f'Paper: "{title}"'
                if year:
                    prefix += f" ({year}"
                    if journal:
                        prefix += f", {journal}"
                    prefix += ")"
                elif journal:
                    prefix += f" ({journal})"
                prefix += f"\nDOI: {doi}"
                prefix += f"\nSection: {section_path}"
                prefix += "\n---\n"

                text_with_prefix = prefix + chunk_text

                # V5: Generate content-based chunk ID (stable, dedup-safe)
                chunk_id = f"{doi.replace('/', '_').replace('.', '_')}__{content_hash[:12]}"

                chunks_out.append({
                    "chunk_id": chunk_id,
                    "paper_id": paper_id,
                    "doi": doi,
                    "title": title,
                    "year": int(year) if str(year).isdigit() else year,
                    "journal": journal,
                    "tier": tier,
                    "section_path": section_path,
                    "section_name": section.name,
                    "chunk_type": chunk_type,
                    "chunk_index": chunk_counter,
                    "token_count": count_tokens(text_with_prefix),
                    "text_with_prefix": text_with_prefix,
                    "text_raw": chunk_text,
                })
                chunk_counter += 1

        # ── Table chunks (atomic) ──
        for j, tbl in enumerate(section.tables):
            tbl_text = table_to_text(tbl)
            if not tbl_text or count_tokens(tbl_text) < 10:
                continue

            # Include relevant captions
            caption = ""
            if j < len(section.captions):
                caption = section.captions[j]

            context = f"[TABLE in section: {section_path}]"
            if caption:
                context += f"\nCaption: {caption}"
            full_table = context + "\n\n" + tbl_text

            prefix = f'Paper: "{title}"'
            if year:
                prefix += f" ({year}"
                if journal:
                    prefix += f", {journal}"
                prefix += ")"
            prefix += f"\nDOI: {doi}"
            prefix += f"\nSection: {section_path}"
            prefix += "\n---\n"

            text_with_prefix = prefix + full_table
            chunk_id_raw = f"{paper_id}__table__{section_path}__{j}"
            chunk_id = hashlib.md5(chunk_id_raw.encode()).hexdigest()[:12]
            chunk_id = f"{doi.replace('/', '_').replace('.', '_')}__tbl_{chunk_id}"

            chunks_out.append({
                "chunk_id": chunk_id,
                "paper_id": paper_id,
                "doi": doi,
                "title": title,
                "year": int(year) if str(year).isdigit() else year,
                "journal": journal,
                "tier": tier,
                "section_path": section_path,
                "section_name": section.name,
                "chunk_type": "table",
                "chunk_index": chunk_counter,
                "token_count": count_tokens(text_with_prefix),
                "text_with_prefix": text_with_prefix,
                "text_raw": full_table,
            })
            chunk_counter += 1

        # ── Standalone captions (not paired with tables) ──
        unpaired_captions = section.captions[len(section.tables):]
        for k, cap in enumerate(unpaired_captions):
            if count_tokens(cap) < 10:
                continue

            # V2: Skip URL-only captions
            if is_url_only(cap):
                continue

            # V2: Clean UI from captions
            cap = clean_ui_from_text(cap)
            if not cap or count_tokens(cap) < 10:
                continue

            # V5: Apply OCR fix to captions
            cap = fix_ocr_ris_stripping(cap)

            prefix = f'Paper: "{title}"'
            if year:
                prefix += f" ({year}"
                if journal:
                    prefix += f", {journal}"
                prefix += ")"
            prefix += f"\nDOI: {doi}"
            prefix += f"\nSection: {section_path}"
            prefix += "\n---\n"

            text_with_prefix = prefix + f"[FIGURE CAPTION]\n{cap}"
            chunk_id_raw = f"{paper_id}__caption__{section_path}__{k}"
            chunk_id = hashlib.md5(chunk_id_raw.encode()).hexdigest()[:12]
            chunk_id = f"{doi.replace('/', '_').replace('.', '_')}__cap_{chunk_id}"

            chunks_out.append({
                "chunk_id": chunk_id,
                "paper_id": paper_id,
                "doi": doi,
                "title": title,
                "year": int(year) if str(year).isdigit() else year,
                "journal": journal,
                "tier": tier,
                "section_path": section_path,
                "section_name": section.name,
                "chunk_type": "caption",
                "chunk_index": chunk_counter,
                "token_count": count_tokens(text_with_prefix),
                "text_with_prefix": text_with_prefix,
                "text_raw": cap,
            })
            chunk_counter += 1

    # ── Post-process: merge tiny chunks with neighbors ──
    # V5: Also merge tiny captions into preceding text chunks
    MIN_CAPTION_STANDALONE = 150  # captions below this get merged
    merged = []
    i = 0
    while i < len(chunks_out):
        chunk = chunks_out[i]
        # Merge tiny TEXT chunks into next text chunk in same section
        if (chunk["token_count"] < MIN_TOKENS and
                chunk["chunk_type"] == "text" and
                i + 1 < len(chunks_out) and
                chunks_out[i + 1]["section_path"] == chunk["section_path"] and
                chunks_out[i + 1]["chunk_type"] == "text"):
            next_chunk = chunks_out[i + 1]
            merged_text = chunk["text_raw"] + "\n\n" + next_chunk["text_raw"]
            merged_prefix = chunk["text_with_prefix"].split("---\n", 1)[0] + "---\n" + merged_text
            next_chunk["text_raw"] = merged_text
            next_chunk["text_with_prefix"] = merged_prefix
            next_chunk["token_count"] = count_tokens(merged_prefix)
            i += 1  # skip current, will pick up merged next
        # V5: Merge tiny CAPTION chunks into preceding text chunk
        elif (chunk["chunk_type"] == "caption" and
              chunk["token_count"] < MIN_CAPTION_STANDALONE and
              merged and
              merged[-1]["section_path"] == chunk["section_path"] and
              merged[-1]["chunk_type"] == "text"):
            prev = merged[-1]
            appended_text = prev["text_raw"] + "\n\n[Figure caption: " + chunk["text_raw"] + "]"
            appended_prefix = prev["text_with_prefix"].split("---\n", 1)[0] + "---\n" + appended_text
            prev["text_raw"] = appended_text
            prev["text_with_prefix"] = appended_prefix
            prev["token_count"] = count_tokens(appended_prefix)
            i += 1  # skip caption, it's merged
        else:
            merged.append(chunk)
            i += 1

    # Re-index
    for idx, c in enumerate(merged):
        c["chunk_index"] = idx

    return merged


# ── Main ───────────────────────────────────────────────────────────────────────

def find_markdown_papers(input_dir: Path) -> list[tuple[str, Path]]:
    """Find all MinerU VLM markdown files in parsed_levante or cleaned_levante structure.
    
    Structure 1 (parsed): {input_dir}/{DOI_folder}/vlm/{DOI_folder}.md
    Structure 2 (cleaned): {input_dir}/{DOI_filename}.md
    Returns: list of (paper_id, md_path) tuples
    """
    papers = []
    for item in sorted(input_dir.iterdir()):
        if item.is_dir():
            paper_id = item.name
            # Look for vlm/*.md
            vlm_dir = item / "vlm"
            if vlm_dir.is_dir():
                md_files = list(vlm_dir.glob("*.md"))
                if md_files:
                    papers.append((paper_id, md_files[0]))
            else:
                # Maybe .md directly in the folder
                md_files = list(item.glob("*.md"))
                if md_files:
                    papers.append((paper_id, md_files[0]))
        elif item.is_file() and item.suffix == ".md":
            # Flat directory structure (cleaned_levante)
            paper_id = item.stem
            papers.append((paper_id, item))
    return papers


def print_summary(all_chunks: list, total_papers: int, errors: list, output_path: Path):
    """Print chunking summary statistics."""
    print(f"\n{'='*60}")
    print(f"CHUNKING COMPLETE")
    print(f"{'='*60}")
    print(f"Papers processed: {total_papers - len(errors)}/{total_papers}")
    print(f"Errors: {len(errors)}")
    print(f"Total chunks: {len(all_chunks)}")

    if all_chunks:
        tokens = [c["token_count"] for c in all_chunks]
        print(f"Token range: {min(tokens)}-{max(tokens)}")
        print(f"Mean tokens: {sum(tokens)/len(tokens):.0f}")
        print(f"Median tokens: {sorted(tokens)[len(tokens)//2]}")

        buckets = {"<100": 0, "100-200": 0, "200-500": 0, "500-1000": 0,
                   "1000-1200": 0, ">1200": 0}
        for t in tokens:
            if t < 100: buckets["<100"] += 1
            elif t < 200: buckets["100-200"] += 1
            elif t < 500: buckets["200-500"] += 1
            elif t < 1000: buckets["500-1000"] += 1
            elif t < 1200: buckets["1000-1200"] += 1
            else: buckets[">1200"] += 1
        print(f"\nToken distribution:")
        for k, v in buckets.items():
            pct = v / len(tokens) * 100
            bar = "█" * int(pct / 2)
            print(f"  {k:>10}: {v:5d} ({pct:5.1f}%) {bar}")

        types = {}
        for c in all_chunks:
            ct = c["chunk_type"]
            types[ct] = types.get(ct, 0) + 1
        print(f"\nChunk types:")
        for ct, count in sorted(types.items()):
            print(f"  {ct}: {count}")

        papers = set(c["paper_id"] for c in all_chunks)
        print(f"\nUnique papers: {len(papers)}")

    if errors:
        print(f"\nFailed papers ({len(errors)}):")
        for stem, err in errors[:20]:
            print(f"  {stem}: {err}")
        if len(errors) > 20:
            print(f"  ... and {len(errors) - 20} more")

    print(f"\nOutput: {output_path}")


def main():
    parser = argparse.ArgumentParser(description="CMIP6 RAG Chunker V6")
    parser.add_argument("--input-dir", type=str, default=None,
                        help="Input directory (auto-detects docling vs markdown)")
    parser.add_argument("--output", type=str, default=None,
                        help="Output JSONL file path")
    parser.add_argument("--max-papers", type=int, default=None,
                        help="Max papers to process (for testing)")
    args = parser.parse_args()

    input_dir = Path(args.input_dir) if args.input_dir else None

    # ── Auto-detect mode ──
    use_markdown = False
    if input_dir:
        # Check if input_dir has VLM markdown structure
        test_dirs = [d for d in input_dir.iterdir() if d.is_dir()][:5]
        has_vlm = any((d / "vlm").is_dir() for d in test_dirs)
        has_md_nested = any(list(d.glob("*.md")) for d in test_dirs if d.is_dir())
        has_md_flat = any(list(input_dir.glob("*.md"))[:1])
        has_docling = any(list(input_dir.glob("*.docling.json"))[:1])

        if has_vlm or (has_md_nested and not has_docling) or (has_md_flat and not has_docling):
            use_markdown = True
    else:
        # Default: try parsed_levante first, then parsed
        if PARSED_LEVANTE_DIR.exists() and any(PARSED_LEVANTE_DIR.iterdir()):
            input_dir = PARSED_LEVANTE_DIR
            use_markdown = True
        else:
            input_dir = PARSED_DIR
            use_markdown = False

    if use_markdown:
        # ── MinerU VLM Markdown Mode ──
        output_path = Path(args.output) if args.output else OUTPUT_LEVANTE_FILE
        papers = find_markdown_papers(input_dir)
        if args.max_papers:
            papers = papers[:args.max_papers]
        print(f"Mode: MinerU VLM Markdown")
        print(f"Found {len(papers)} papers in {input_dir}")
        print(f"Output: {output_path}")
        print()

        if not papers:
            print("ERROR: No markdown files found!")
            return

        all_chunks = []
        errors = []

        for i, (paper_id, md_path) in enumerate(papers):
            try:
                chunks = chunk_markdown_document(md_path, paper_id)
                all_chunks.extend(chunks)
                tokens = [c["token_count"] for c in chunks]
                avg_t = sum(tokens) / len(tokens) if tokens else 0
                if (i + 1) % 100 == 0 or (i + 1) == len(papers) or i < 5:
                    print(f"[{i+1:5d}/{len(papers)}] {paper_id}: "
                          f"{len(chunks)} chunks, "
                          f"avg {avg_t:.0f} tokens")
            except Exception as e:
                print(f"[{i+1:5d}/{len(papers)}] ERROR {paper_id}: {e}")
                errors.append((paper_id, str(e)))

        with open(output_path, "w") as f:
            for chunk in all_chunks:
                f.write(json.dumps(chunk, ensure_ascii=False) + "\n")

        print_summary(all_chunks, len(papers), errors, output_path)

    else:
        # ── Original Docling JSON Mode ──
        output_path = Path(args.output) if args.output else OUTPUT_FILE
        docling_files = sorted(input_dir.glob("*.docling.json"))
        if args.max_papers:
            docling_files = docling_files[:args.max_papers]
        print(f"Mode: Docling JSON")
        print(f"Found {len(docling_files)} docling files in {input_dir}")

        if not docling_files:
            print("ERROR: No .docling.json files found!")
            return

        all_chunks = []
        errors = []

        for i, dp in enumerate(docling_files):
            stem = dp.name.replace(".docling.json", "")
            meta_path = input_dir / f"{stem}.json"

            try:
                chunks = chunk_document(dp, meta_path)
                all_chunks.extend(chunks)
                tokens = [c["token_count"] for c in chunks]
                avg_t = sum(tokens) / len(tokens) if tokens else 0
                print(f"[{i+1:3d}/{len(docling_files)}] {stem}: "
                      f"{len(chunks)} chunks, "
                      f"avg {avg_t:.0f} tokens, "
                      f"range [{min(tokens) if tokens else 0}-{max(tokens) if tokens else 0}]")
            except Exception as e:
                print(f"[{i+1:3d}/{len(docling_files)}] ERROR {stem}: {e}")
                errors.append((stem, str(e)))

        with open(output_path, "w") as f:
            for chunk in all_chunks:
                f.write(json.dumps(chunk, ensure_ascii=False) + "\n")

        print_summary(all_chunks, len(docling_files), errors, output_path)


if __name__ == "__main__":
    main()