#!/usr/bin/env python3
"""Coteja el campo `synonyms` de D1 contra el repo, palabra clave a palabra clave.

Por que hacia falta. Todos los cotejos anteriores —el diff de Surya, la paridad
repo/D1, el arbitraje por pagina— miran el cuerpo: traduccion y significado. El
campo `synonyms` no lo miraba ninguno. Y ahi es donde los reemplazos masivos
hicieron mas dano, porque un significado es una lista de pares
`palabra—glosa` y un reemplazo a ciegas parte la glosa sin que se note:

    bg/3/14    D1 dice «parjanyāt—from rain» y el impreso «from rains»
    sb/3/8/30  D1 dice «śṛṅgam—peas» donde el impreso dice «peaks»
    cc/adi/7/64 D1 dice «prabhu kahe—the Lnnord replied»

Como compara. Trocea el `synonyms` de D1 por `;` y comprueba que cada trozo
aparece en el .md del repo. Dos cuidados que costaron una pasada en falso:

  - no se puede comparar por conjuntos: el .md entero partido por `;` no tiene
    los mismos limites que el campo de D1, y salian 40.000 falsos positivos
  - la subcadena sola tampoco vale: «from rain» ES subcadena de «from rains»,
    asi que la divergencia de bg/3/14 se colaba. Hace falta limite de palabra
    detras del trozo

Uso:
    python3 verificar_synonyms.py                 # todos los libros
    python3 verificar_synonyms.py --libro bg
"""
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 sincronizar_diff import d1  # noqa: E402
from verificar_paridad import ref_de  # noqa: E402

CARPETA = {'bg': 'bhagavad-gita-as-it-is', 'sb': 'srimad-bhagavatam',
           'cc': 'sri-caitanya-caritamrta', 'iso': 'isopanisad',
           'nod': 'nectar-of-devotion'}
# detras del trozo no puede seguir letra: si no, «from rain» casa en «from rains»
LIMITE = r'(?![\wĀ-ỿ])'


def limpia(s):
    s = re.sub(r'</?(em|i|strong|b)>', '', s).replace('*', '').replace('_', '')
    return ' '.join(s.split())


def clave_de(frag):
    """La palabra sanscrita del par `palabra—glosa`.

    Se parte SOLO por raya y semirraya. Incluir el guion normal truncaba las
    claves compuestas —«mokṣa-vāñchā» quedaba en «mokṣa»— y luego no habia
    manera de encontrar la contraparte en el repo: 16 casos en falso.
    """
    return re.split(r'[—–]', frag, maxsplit=1)[0].strip()


def contraparte(clave, texto):
    """El par del repo que empieza por esa misma palabra clave."""
    m = re.search(re.escape(clave) + r'\s*[—–]\s*[^;]{0,80}', texto)
    return m.group(0).strip() if m else None


def main():
    libros = ([sys.argv[sys.argv.index('--libro') + 1]] if '--libro' in sys.argv
              else list(CARPETA))
    salida = []
    for libro in libros:
        carp = CARPETA[libro]
        filas = d1(f"SELECT ref, synonyms FROM verses WHERE lang='en' AND book='{libro}' "
                   f"AND synonyms IS NOT NULL AND synonyms <> ''", js=True)
        mapa = {}
        for f in (REPO / carp).rglob('*.md'):
            r = ref_de(str(f.relative_to(REPO)))
            if r:
                mapa[r] = f
        n = 0
        for row in filas:
            f = mapa.get(row['ref'])
            if not f:
                continue
            t = limpia(f.read_text(encoding='utf-8'))
            for frag in limpia(row['synonyms']).split(';'):
                frag = frag.strip().rstrip('.')
                if len(frag) < 8:
                    continue
                if re.search(re.escape(frag) + LIMITE, t):
                    continue
                salida.append({'ref': row['ref'],
                               'file': str(f.relative_to(REPO)),
                               'clave': clave_de(frag),
                               'd1': frag,
                               'repo': contraparte(clave_de(frag), t)})
                n += 1
        print(f'  {libro:4} filas={len(filas):5}  divergencias en synonyms: {n}')
    (HERE / 'synonyms_divergentes.json').write_text(
        json.dumps(salida, ensure_ascii=False, indent=1), encoding='utf-8')
    print(f'\n  total: {len(salida)}   -> synonyms_divergentes.json')
    for x in salida:
        print(f"    {x['ref']:16} D1={x['d1'][:44]!r}")
        print(f"    {'':16} repo={(x['repo'] or '(sin contraparte)')[:44]!r}")
    return 0


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