#!/usr/bin/env python3
"""Decide, leyendo el escaneo, quien tiene razon en cada divergencia de synonyms.

Entra `synonyms_divergentes.json` y para cada par lee en la pagina impresa la
glosa que sigue a la palabra sanscrita. No comprueba hipotesis: LEE, igual que
`leer_palabra_impreso.py`, porque comprobar hipotesis fallaba en la mayoria de
los casos por una coma o una cursiva mal leidas.

Localizar la pagina por la palabra clave sola no sirve —«anna» sale cientos de
veces—, asi que se busca la clave junto con la glosa mas larga de las dos, que
es lo bastante rara para ser unica. Si con ninguna de las dos se encuentra la
pagina, el caso queda «sin pagina» y hay que mirar la imagen.

El OCR no distingue fiablemente cursiva ni acentos raros, asi que la lectura se
normaliza y solo se pronuncia cuando coincide sin ambiguedad con una de las dos
versiones. Cuando el impreso dice una tercera cosa, se informa: eso significa
que ni el repo ni D1 sirven el texto del papel.

Uso: python3 arbitrar_synonyms.py
"""
import json
import pathlib
import re
import sys

HERE = pathlib.Path(__file__).resolve().parent
sys.path.insert(0, str(HERE))
from pagina_de_ref import localizar, norm  # noqa: E402
from arbitrar_por_pagina import texto_pagina  # noqa: E402


def glosa(frag):
    """La parte de la derecha del par `palabra—glosa`."""
    p = re.split(r'[—–]', frag, 1)
    return p[1].strip() if len(p) > 1 else ''


def lee_glosa(texto, clave, n=6):
    """Las `n` palabras que siguen a la clave sanscrita en la pagina."""
    cl = norm(clave)
    pos = [i for i in range(len(texto)) if texto.startswith(cl, i)]
    if len(pos) != 1:
        return None
    return ' '.join(texto[pos[0] + len(cl):].split()[:n])


def main():
    casos = json.loads((HERE / 'synonyms_divergentes.json').read_text(encoding='utf-8'))
    res = {'D1 equivocado': [], 'repo equivocado': [], 'el impreso dice otra cosa': [],
           'sin pagina': [], 'sin contraparte en el repo': []}
    for x in casos:
        if not x.get('repo'):
            res['sin contraparte en el repo'].append(x)
            continue
        gd1, grepo = glosa(x['d1']), glosa(x['repo'])
        # la glosa mas larga hace de ancla: es la que tiene mas posibilidades
        # de ser unica en el libro entero
        ancla = max((gd1, grepo), key=len)
        hit = (localizar(x['ref'], f"{x['clave']} {ancla}")
               or localizar(x['ref'], f"{x['clave']} {min((gd1, grepo), key=len)}"))
        if not hit:
            res['sin pagina'].append(x)
            continue
        stem, pag = hit
        leido = lee_glosa(texto_pagina(x['ref'], pag, stem), x['clave'])
        if not leido:
            res['sin pagina'].append({**x, 'pagina': f'{stem} p.{pag}'})
            continue
        x = {**x, 'pagina': f'{stem} p.{pag}', 'impreso': leido}
        nd1, nrepo = norm(gd1), norm(grepo)
        if leido.startswith(nrepo) and not leido.startswith(nd1):
            res['D1 equivocado'].append(x)
        elif leido.startswith(nd1) and not leido.startswith(nrepo):
            res['repo equivocado'].append(x)
        else:
            res['el impreso dice otra cosa'].append(x)
    for k, v in res.items():
        print(f'  {len(v):4}  {k}')
    (HERE / 'synonyms_arbitrado.json').write_text(
        json.dumps(res, ensure_ascii=False, indent=1), encoding='utf-8')
    for k in ('D1 equivocado', 'repo equivocado', 'el impreso dice otra cosa'):
        if not res[k]:
            continue
        print(f'\n  {k}:')
        for x in res[k]:
            print(f"    {x['ref']:16} {x.get('pagina','')[:34]:36}")
            print(f"        impreso={x['impreso'][:44]!r}")
            print(f"        D1={glosa(x['d1'])[:34]!r:38} repo={glosa(x['repo'])[:34]!r}")
    return 0


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