#!/usr/bin/env python3
"""Enseña una glosa dudosa con el impreso al lado, para adjudicarla a mano.

Que quedaba. Despues de `cerrar_glosas.py` sobran 578 candidatos sin prueba
mecanica. De esos, 64 tienen las DOS glosas en ingles corriente, y ahi es donde
aparecen los errores de verdad: los tres del 17-ago —«perspiring» por
«lamenting», «was overwhelmed» por «became overwhelmed», «wherever» por
«whichever»— eran justo de esa clase. La transliteracion se equivoca por
tipografia; el ingles se equivoca por copia.

Que enseña. Para cada caso, la linea de sinonimos del repo alrededor del
termino y el pasaje del escaneo donde cae, con la pareja «clave—glosa» que trae
el impreso. Con las dos delante se decide en un vistazo si el repo dice otra
cosa o si es el alineador partiendo una glosa larga por la mitad.

Uso:
    python3 ver_glosa.py                       # los 64 en ingles
    python3 ver_glosa.py sb-1.14.19            # solo ese verso
"""
import json
import pathlib
import re
import sys

HERE = pathlib.Path(__file__).resolve().parent
sys.path.insert(0, str(HERE))
from arbitrar_deriva import texto_escaneo, LIBRO, REPO  # noqa: E402
from cerrar_glosas import sd  # noqa: E402

_t = {}


def pasaje(libro, aguja, ancho=200):
    """El pasaje del impreso donde cae ESTE verso.

    Buscar la glosa suelta no vale: «fearful» aparece en sb/1/6 hablando de
    bosques temibles, y ahi no se decide nada sobre sb/1/14/19. Hay que anclar
    en el verso —su transliteracion es unica en todo el libro— y leer sus
    glosas, que van justo detras.
    """
    if libro not in _t:
        _t[libro] = sd(texto_escaneo(libro) or '')
    m = re.search(r'(?<![\w])' + re.escape(sd(aguja)) + r'(?![\w])', _t[libro])
    if not m:
        return None
    # Hacia ADELANTE, no centrado: el ancla es la transliteracion y las glosas
    # van justo detras. Centrando, la ventana se gastaba en el purport del
    # verso anterior y cortaba antes de llegar a lo que se quiere leer.
    return _t[libro][m.start():m.end() + ancho]


def ancla(f):
    """Un trozo de la transliteracion del verso, para localizarlo en el impreso."""
    for l in f.read_text(encoding='utf-8').splitlines():
        l = l.strip()
        if l.startswith('>') and not re.search(r'[ऀ-ॿঀ-৿]', l):
            t = sd(re.sub(r'[^\w\s]', ' ', l.lstrip('> ')))
            piezas = t.split()
            if len(piezas) >= 4:
                return ' '.join(piezas[:5])
    return None


def main():
    filtro = next((a for a in sys.argv[1:] if not a.startswith('--')), None)
    casos = json.loads((HERE / 'glosas_ingles.json').read_text(encoding='utf-8'))
    CARP = {v: k for k, v in LIBRO.items()}
    for x in casos:
        nombre = x['file'].split('/')[-1]
        if filtro and filtro not in nombre:
            continue
        libro = CARP.get(x.get('libro'))
        f = REPO / (x['file'] if x['file'].endswith('.md') else x['file'] + '.md')
        print(f"\n{'=' * 78}\n{nombre}   repo={x['repo']!r}   escaneo={x['scan']!r}")
        if f.is_file():
            # la linea de sinonimos es la que lleva las parejas «*clave*—glosa»
            linea = next((l for l in f.read_text(encoding='utf-8').splitlines()
                          if l.count('—') > 2), '')
            # el fragmento del repo que contiene el termino, con sus vecinos
            trozos = [t.strip() for t in linea.split(';')]
            i = next((k for k, t in enumerate(trozos)
                      if re.search(re.escape(sd(x['repo'])), sd(t))), None)
            if i is not None:
                print('  REPO   ...' + ' ; '.join(trozos[max(0, i - 1):i + 2])[:230])
        p = None
        if libro and f.is_file():
            a = ancla(f)
            if a:
                p = pasaje(libro, a, ancho=900)
        print('  IMPRESO ...' + p[:940] if p else '  IMPRESO  (verso no localizado en el escaneo)')
    return 0


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