#!/usr/bin/env python3
"""Compara el devanagari/bengali del repo contra el del escaneo, linea a linea.

Por que no se puede hacer como el resto. El alineador general trabaja con
`difflib` sobre la secuencia entera; en el indio hay que comparar CARACTER a
caracter —el escaneo junta el verso en un renglon y el repo lo parte en dos— y
eso, sobre los millones de caracteres del Caitanya-caritamrta, es cuadratico y
no termina.

La via rapida: cada linea india del repo se busca COMO SUBCADENA en el texto
indio del escaneo. Si aparece, coincide y no hay nada que mirar. Lo que no
aparece es lo unico que hay que revisar, y ademas se puede decir cuanto se
parece a su vecina mas cercana.

Se comparan sin puntuacion latina ni espacios: el escaneo mete el dandas y los
numeros de verso de otra forma.

Uso: python3 diff_indio.py <libro|--todos>
"""
import json, re, sys, difflib, pathlib, collections

HERE = pathlib.Path(__file__).resolve().parent
REPO = pathlib.Path('/Users/jaganat/git_projects/vedabase-original')
SURYA = HERE / 'surya'
OUT = HERE / 'out_indio'
INDIO = re.compile(r'[ऀ-ॿঀ-৿]')
SOLO = re.compile(r'[^ऀ-ॿঀ-৿]+')
# los signos que el impreso y el repo puntuan distinto y no son texto
QUITA = re.compile(r'[।॥০-৯०-९]')   # dandas y cifras indias


def limpia(s):
    return QUITA.sub('', SOLO.sub('', s))


def lineas_repo(md):
    return [limpia(l) for l in md.splitlines()
            if l.strip().startswith('>') and INDIO.search(l)]


def texto_scan(libro):
    t = []
    for d in sorted((SURYA / libro).glob('*')):
        if not d.is_dir(): continue
        for p in sorted(d.glob('p*.surya.txt')):
            for l in p.read_text(encoding='utf-8').splitlines():
                if INDIO.search(l): t.append(limpia(l))
    return ''.join(t)


def main():
    if len(sys.argv) < 2: print(__doc__); return 1
    OUT.mkdir(exist_ok=True)
    libros = ([d.name for d in SURYA.iterdir() if d.is_dir() and (REPO / d.name).exists()]
              if sys.argv[1] == '--todos' else [sys.argv[1]])
    for b in sorted(libros):
        esc = texto_scan(b)
        if not esc:
            print(f'  {b}: el escaneo no trae indio'); continue
        casos = []; n = 0
        for f in sorted((REPO / b).rglob('*.md')):
            for l in lineas_repo(f.read_text(encoding='utf-8')):
                if len(l) < 8: continue
                n += 1
                if l in esc: continue
                # cuanto se parece a lo mas cercano: se ancla por un trozo del
                # centro, que es lo que menos sufre en los bordes de linea
                mid = l[len(l)//3: len(l)//3 + 12]
                j = esc.find(mid) if len(mid) >= 8 else -1
                cerca = esc[max(0, j - len(l)): j + len(l)] if j >= 0 else ''
                par = difflib.SequenceMatcher(None, l, cerca).ratio() if cerca else 0.0
                casos.append({'file': str(f.relative_to(REPO)), 'repo': l[:160],
                              'parecido': round(par, 3), 'cerca': cerca[:160],
                              'region': 'indio'})
        print(f'  {b}: {n} lineas indias | sin coincidencia exacta: {len(casos)}')
        if casos:
            with open(OUT / f'{b}.candidates.jsonl', 'w', encoding='utf-8') as fh:
                for x in casos: fh.write(json.dumps(x, ensure_ascii=False) + '\n')
    return 0


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