# Chunk parameters
CHUNK_SIZE = 800            # Characters per chunk
CHUNK_OVERLAP = 300         # Overlap between consecutive chunks
MAX_CHUNKS_CONTEXTO = 3     # Maximum chunks to send per document

def chunking_con_solapamiento(contenido: str) -> list:
    """
    Divide content into fixed-size chunks with overlap.
    
    Returns:
        List of dicts: {"texto": str, "seccion": str, "indice": int}
    """
    chunks = []
    inicio = 0
    total = len(contenido)
    idx = 0
    
    while inicio < total:
        fin = min(inicio + CHUNK_SIZE, total)
        
        # Extend to next newline to avoid cutting words
        if fin < total:
            salto = contenido.find('\n', fin)
            if salto != -1 and salto - fin < 100:
                fin = salto
        
        texto_chunk = contenido[inicio:fin]
        
        # Determine active section from previous context
        contexto_previo = contenido[max(0, inicio - 500):inicio]
        seccion = _ultimo_encabezado(contexto_previo + texto_chunk)
        
        chunks.append({
            "texto": texto_chunk,
            "seccion": seccion,
            "indice": idx,
        })
        
        idx += 1
        # Advance with overlap
        inicio += CHUNK_SIZE - CHUNK_OVERLAP
    
    return chunks

def _ultimo_encabezado(texto: str) -> str:
    """Find the last Markdown heading in text."""
    encabezados = re.findall(r'^#{1,3}\s+(.+)$', texto, re.MULTILINE)
    if encabezados:
        # Remove markdown formatting (*_`) and uppercase
        return re.sub(r'[*_`]', '', encabezados[-1]).strip().upper()
    return "INICIO"

chunks_por_doc = {}  # Global index: {doc_name: [chunk1, chunk2, ...]}
chunks_lock = threading.Lock()

def cargar_documentos():
    nuevos_chunks = {}
    
    for ruta in archivos:
        nombre_clave = os.path.basename(ruta).lower()
        with open(ruta, "r", encoding="utf-8") as f:
            contenido = f.read()
        
        # Pre-calculate chunks with overlap
        chunks = chunking_con_solapamiento(contenido)
        nuevos_chunks[nombre_clave] = chunks
        
        print(
            f"  [Doc] {nombre_clave} "
            f"({len(contenido):,} chars, {len(chunks)} chunks)"
        )
    
    with chunks_lock:
        chunks_por_doc = nuevos_chunks

def extraer_fragmento(nombre_doc: str, pregunta: str) -> str:
    with chunks_lock:
        chunks = chunks_por_doc.get(nombre_doc, [])
    
    if not chunks:
        return ""
    
    palabras = set(tokenizar(pregunta.lower()))
    terminos_prio = obtener_terminos_prioritarios(nombre_doc)
    
    # Score every chunk
    scored = []
    for chunk in chunks:
        pts = puntuar_chunk(chunk, palabras, pregunta, terminos_prio)
        if pts > 0:
            scored.append((pts, chunk["indice"], chunk))
    
    scored.sort(reverse=True)
    
    # Dynamic pruning: return 1-3 chunks based on score ratio
    # (See document-routing.mdx for details)
    ...

def puntuar_chunk(chunk: dict, palabras: set, pregunta_norm: str,
                  terminos_prio: set, idf_local: dict = None) -> float:
    """
    Score chunk relevance using multiple signals.
    
    Scoring system:
      +base×idf_local per keyword match (rare terms score higher)
      +15 if full question text appears in chunk
      +10 if chunk contains article with degree marker (art. 5°)
      +5  if chunk contains article without degree (artículo 5)
      +4  if chunk contains numbered list (procedures)
      +0-20 proximity bonus (keywords clustered within 150 chars)
    """
    texto = chunk["texto"].lower()
    puntos = 0.0
    
    # Keyword matching with TF-IDF
    for w in palabras:
        count = texto.count(w)
        if count > 0:
            tf = 1.0 + math.log(count)  # Log-normalized: 1→1.0, 2→1.69, 5→2.61
            base = 3.0 if w in terminos_prio else 1.0
            if idf_local and w in idf_local:
                base *= idf_local[w]
            puntos += tf * base
    
    # Full question match (strongest signal)
    if pregunta_norm in texto:
        puntos += 15.0
    
    # Article bonus
    if PATRON_ARTICULO_GRADO.search(chunk["texto"]):
        puntos += 10.0  # "artículo 5°", "art. 5º"
    elif PATRON_ARTICULO_SIMPLE.search(chunk["texto"]):
        puntos += 5.0   # "artículo 5"
    
    # Numbered list bonus (procedures)
    if re.search(r'^\s*\d+[\.\)]\s+\S', chunk["texto"], re.MULTILINE):
        puntos += 4.0
    
    # Proximity bonus: keywords clustered in 150-char window
    if len(palabras) >= 2:
        VENTANA = 150
        PASO = 50
        max_densidad = 0.0
        for i in range(0, max(1, len(texto) - VENTANA), PASO):
            v = texto[i:i+VENTANA]
            matches = sum(1 for w in palabras if w in v)
            if matches >= 2:
                d = matches / len(palabras)
                max_densidad = max(max_densidad, d)
        
        if   max_densidad >= 0.90: puntos += 20.0  # 90%+ keywords together
        elif max_densidad >= 0.70: puntos += 12.0
        elif max_densidad >= 0.50: puntos += 6.0
        elif max_densidad >= 0.30: puntos += 2.0
    
    return puntos

if len(scored) >= 2:
    s1, s2 = scored[0][0], scored[1][0]
    ratio = s1 / max(s2, 0.01)
    
    if ratio >= 3.0:
        chunks_a_usar = 1   # High certainty → 1 chunk (~200 tokens)
        modo = "FRANCOTIRADOR"
    elif ratio >= 1.8:
        chunks_a_usar = 2   # Medium certainty → 2 chunks (~400 tokens)
        modo = "BINÓCULO"
    else:
        chunks_a_usar = MAX_CHUNKS_CONTEXTO  # Ambiguous → 3 chunks
        modo = "ESCOPETA"
    
    print(f"  [PODA] {nombre_doc[:25]} ratio={ratio:.2f} → {chunks_a_usar}chunk [{modo}]", flush=True)

PATRONES_LISTADO = [
    "cuáles son", "cuales son", "qué secciones", "que secciones",
    "enumera", "lista los", "nombra", "menciona",
    "cuántas secciones", "qué tipos", ...
]

def es_pregunta_listado(pregunta: str) -> bool:
    p = pregunta.lower()
    return any(pat in p for pat in PATRONES_LISTADO)

# In extractor:
if es_listado:
    chunks_a_usar = max_chunks_efectivo if ratio < 1.8 else 2
    modo = "LISTADO-BINÓCULO" if chunks_a_usar == 2 else "LISTADO-ESCOPETA"

for pts, idx, chunk in scored[:chunks_a_usar * 2]:
    if idx in indices_usados:
        continue
    
    texto = chunk["texto"]
    meta = f"[SEC: {chunk['seccion'][:60]} | CHUNK: {idx}]"
    seleccionados.append(meta + "\n" + texto)
    indices_usados.add(idx)

nombre_display = os.path.splitext(doc["nombre_original"])[0].upper()
etiqueta = f"[DOC: {nombre_display}]"
separador = "\n" + "═" * 60 + "\n"

return etiqueta + "\n" + "\n\n".join(seleccionados) + separador