#!/usr/bin/env python3
"""Comprueba, correccion a correccion, que lo de hoy esta en D1.

`verificar_paridad.py` responde a otra pregunta: si el fichero del repo y la fila
de D1 dicen lo MISMO. Eso mezcla dos cosas — lo que hemos cambiado hoy y las
divergencias que ya existian antes (D1 sirviendo texto de la edicion revisada) —
y con 85 divergentes de 244 no se distingue una de otra.

Aqui la pregunta es concreta: para cada par (viejo, nuevo) que hemos escrito hoy,
¿esta el NUEVO en D1? Si esta, la correccion llego. Si sigue el VIEJO, no llego.
Y si no aparece ninguno de los dos, es que D1 dice ahi una tercera cosa, que es
justamente una divergencia anterior.

Uso: python3 verificar_correcciones_d1.py [--fecha 2026-08-11]
"""
import json, re, sys, unicodedata, pathlib, collections

HERE = pathlib.Path(__file__).resolve().parent
REPO = pathlib.Path('/Users/jaganat/git_projects/vedabase-original')
sys.path.insert(0, str(HERE))
from sincronizar_diff import d1, q
from verificar_paridad import ref_de


def sd(s):
    """Normaliza SIN borrar la escritura india. La version anterior reducia a
    [A-Za-z0-9] y el devanagari desaparecia entero: comparaba cadenas vacias y
    daba por «no llegado» lo que si estaba."""
    s = unicodedata.normalize('NFC', s or '')
    return ' '.join(re.sub(r'[^A-Za-z0-9\u0900-\u097F\u0980-\u09FF]+', ' ',
                           s.lower()).split())


def main():
    fecha = sys.argv[sys.argv.index('--fecha') + 1] if '--fecha' in sys.argv else '2026-08-11'
    corr = []
    for l in open(REPO / 'corrections.jsonl', encoding='utf-8'):
        try: d = json.loads(l)
        except Exception: continue
        if d.get('date') != fecha or not d.get('file'): continue
        par = (d.get('replace') or {}).get('en') or []
        if len(par) != 2: continue
        r = ref_de(d['file'])
        if not r: continue
        corr.append((r, d['file'], par[0], par[1], d.get('note', '')))
    print(f'correcciones de {fecha} con referencia: {len(corr)}')

    porref = collections.defaultdict(list)
    for r, f, a, b, n in corr: porref[r].append((a, b, n))

    res = collections.Counter(); fallan = []
    refs = sorted(porref)
    for i in range(0, len(refs), 40):
        lote = refs[i:i + 40]
        filas = {x['ref']: x for x in d1(
            "SELECT ref, COALESCE(translation,'')||' '||COALESCE(purport,'')||' '||"
            "COALESCE(synonyms,'')||' '||COALESCE(verse_text,'')||' '||"
            "COALESCE(devanagari,'') t FROM verses "
            f"WHERE lang='en' AND ref IN ({','.join(q(x) for x in lote)})", js=True)}
        for r in lote:
            if r not in filas:
                res['sin fila en D1'] += len(porref[r]); continue
            t = sd(filas[r]['t'])
            for a, b, n in porref[r]:
                na, nb = sd(a), sd(b)
                # el nuevo puede ser cadena vacia (supresion) o el viejo vacio
                # (insercion); en cada caso se pregunta lo que corresponde
                if nb and nb in t: res['LLEGO'] += 1
                elif not nb and na not in t: res['LLEGO'] += 1     # supresion hecha
                elif na and na in t: res['NO llego: D1 sigue con el texto viejo'] += 1; fallan.append((r, a, b, n))
                else: res['D1 dice una tercera cosa (divergencia anterior)'] += 1; fallan.append((r, a, b, n))
        print(f'  {min(i+40,len(refs))}/{len(refs)}', end='\r')

    print()
    for k, v in res.most_common(): print(f'  {v:5}  {k}')
    json.dump([{'ref': r, 'viejo': a[:120], 'nuevo': b[:120], 'nota': n[:200]}
               for r, a, b, n in fallan],
              open(HERE / 'correcciones_sin_llegar.json', 'w'), ensure_ascii=False, indent=1)
    for r, a, b, n in fallan[:20]:
        print(f'  {r:22} {a[:44]!r} -> {b[:44]!r}')
    return 0


if __name__ == '__main__':
    sys.exit(main())