#!/usr/bin/env python3
"""Comprueba, una por una, las palabras que el impreso escribe de las dos formas.

Por que no se puede decidir por corpus. Se penso que «motorcars», «tranquillity»
o «girlfriend» eran modernizaciones sistematicas de la edicion digital y que
bastaba un reemplazo general. No lo son: el papel escribe LAS DOS formas, y en
proporciones que no dejan elegir una:

    motorcar / motor car        5 / 5
    tranquillity / tranquility  6 / 34
    riverbank / river bank      3 / 5
    girlfriend / girl friend    6 / 61

Un reemplazo general acierta unas y estropea otras, que es exactamente lo que
paso el 15-ago con «girlfriend»: se cambio el libro entero por la evidencia de
UN contexto y hubo que revertirlo.

Asi que cada aparicion se comprueba contra SU pagina: se toma el contexto
izquierdo del repo, se localiza la pagina y se lee lo que viene detras.

Uso:
    python3 verificar_compuestas.py                  # todas las clases
    python3 verificar_compuestas.py --clase girlfriend
"""
import json
import pathlib
import re
import sys

HERE = pathlib.Path(__file__).resolve().parent
REPO = pathlib.Path('/Users/jaganat/git_projects/vedabase-original')
sys.path.insert(0, str(HERE))
from pagina_de_ref import localizar, norm  # noqa: E402
from arbitrar_por_pagina import texto_pagina  # noqa: E402
from verificar_paridad import ref_de  # noqa: E402
from arbitrar_deriva import LIBRO  # noqa: E402

CLASES = [('motorcar', 'motor car'), ('tranquillity', 'tranquility'),
          ('rainwater', 'rain water'), ('riverbank', 'river bank'),
          ('girlfriend', 'girl friend')]


def lee_tras(texto, izq, n):
    """Las `n` palabras que siguen al contexto izquierdo, o None si no es unico."""
    pal = izq.split()
    for k in (5, 4, 3):
        if len(pal) < k:
            continue
        aguja = ' '.join(pal[-k:])
        pos = [i for i in range(len(texto)) if texto.startswith(aguja, i)]
        if len(pos) != 1:
            continue
        return ' '.join(texto[pos[0] + len(aguja):].split()[:n])
    return None


def main():
    solo = (sys.argv[sys.argv.index('--clase') + 1] if '--clase' in sys.argv else None)
    clases = [c for c in CLASES if not solo or c[0] == solo]
    salida = []
    for junto, sep in clases:
        # cualquiera de las dos formas, con plural opcional
        pat = re.compile(r'(?<![\w-])(' + junto + r's?|' + sep.replace(' ', r'[\s-]') + r's?)(?![\w])',
                         re.I)
        n = ok = mal = indec = 0
        for libro, carp in LIBRO.items():
            d = REPO / carp
            if not d.is_dir():
                continue
            for f in sorted(d.rglob('*.md')):
                t = f.read_text(encoding='utf-8', errors='ignore')
                for m in pat.finditer(t):
                    n += 1
                    ref = ref_de(str(f.relative_to(REPO)))
                    if not ref:
                        continue
                    izq = norm(' '.join(t[:m.start()].split()[-5:]))
                    hit = localizar(ref, izq + ' ' + m.group(0))
                    if not hit:
                        indec += 1
                        continue
                    stem, pag = hit
                    leido = lee_tras(texto_pagina(ref, pag, stem), izq, 2)
                    if not leido:
                        indec += 1
                        continue
                    esperado = norm(m.group(0))
                    if leido.startswith(esperado):
                        ok += 1
                    else:
                        mal += 1
                        salida.append({'clase': junto, 'ref': ref,
                                       'file': str(f.relative_to(REPO)),
                                       'repo': m.group(0), 'impreso': leido,
                                       'pagina': f'{stem} p.{pag}',
                                       'izq': ' '.join(t[:m.start()].split()[-5:])})
        print(f'  {junto+" / "+sep:26} apariciones={n:4}  coinciden={ok:4}  '
              f'discrepan={mal:3}  sin decidir={indec:4}')
    (HERE / 'compuestas_discrepantes.json').write_text(
        json.dumps(salida, ensure_ascii=False, indent=1), encoding='utf-8')
    if salida:
        print(f'\n  discrepantes ({len(salida)}):')
        for x in salida:
            print(f"    {x['ref']:16} {x['pagina']:14} repo={x['repo']!r:16} "
                  f"impreso={x['impreso'][:26]!r}")
    return 0


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