"""
enlace.py — Sincronizar dos Caudal: el de un servidor y otro que se enlaza con
él (el del USB). Mezcla, no sustituye: lo que se haya apuntado en cada lado
acaba en los dos.

Quién es quién. El SERVIDOR es el Caudal que atiende en la red y pide
contraseña. El otro se ENLAZA una vez (hace falta la contraseña del servidor,
que no se guarda: se cambia por una credencial propia de ese equipo, que se
puede retirar) y a partir de ahí sincroniza cuando se le pide.

Cómo se sincroniza, en un solo viaje:

  1. El enlazado envía TODO lo suyo: los registros (también los borrados, que
     son marcas) y los ajustes.
  2. El servidor lo comprueba entero antes de tocar nada, lo mezcla con lo
     suyo y responde con el resultado, que es lo que queda en los dos.
  3. El enlazado comprueba la respuesta y la pone en lugar de lo suyo.
  4. Después se intercambian los justificantes que le falten a cada uno.

Para que mezclar no pueda romper nada:

  · Nada se pierde: la mezcla es la unión de las dos copias; si un registro
    está en las dos con contenido distinto gana el más reciente, y un borrado
    es una marca, no una ausencia (datos.fusionar).
  · Dos inversiones distintas con el mismo identificador no se pisan: a la
    que llega se le da otro y sus operaciones la siguen (datos.choques_de_activos).
  · La misma línea de extracto apuntada en los dos sitios no queda duplicada
    (datos.unir_duplicadas).
  · Antes de aplicar, cada lado guarda una copia local de lo que tenía.
  · Si las dos copias son de versiones distintas del formato, no se mezclan.
  · Se puede simular: dice qué cambiaría en cada lado y no cambia nada. Si las
    dos copias no tienen nada en común, se avisa: serían dos carteras juntas.
  · El enlazado no aplica una respuesta en la que falte algo de lo que envió.

Si el viaje se corta a medias no pasa nada: repetirlo lleva al mismo sitio.
"""

from __future__ import annotations

import base64
import datetime as dt
import http.client
import json
import os
import socket
import ssl
import tempfile
from pathlib import Path
from urllib.parse import urlsplit

from . import adjuntos, almacen
from .datos import (FICHEROS, VERSION, Datos, ErrorDatos, choques_de_activos, clave, escribir, fusionar, huella_datos,
                    renombrar_activos, unir_duplicadas)
from .sincronizar import _canonico, elegir_ajustes, escribir_ajuste, leer_ajustes

AJUSTES = ("bitcoin.json", "extractos.json")        # los que viajan; el índice de la copia en git no es de aquí
FICHERO = "enlace.json"
FICHERO_CERTIFICADO = "enlace-certificado.crt"   # el certificado raíz del servidor, si se eligió como fichero
FICHERO_DIRECCIONES = "enlace-direcciones.json"  # en el servidor: las direcciones que lleva el QR de enlazar
VARIABLE_DIRECCIONES = "CAUDAL_DIRECCIONES"      # las que da el sistema (StartOS), como lista JSON de URLs
TIEMPO = 120
TIEMPO_CONECTAR = 8                                 # si en este rato no hay camino, se prueba el siguiente
TIEMPO_TOR = 60                                     # por Tor, abrir el camino tarda


class ErrorEnlace(Exception):
    """Lo que se le dice al usuario tal cual."""


class SinCamino(ErrorEnlace):
    """No se llega al servidor por esa dirección (quizá sí por la otra)."""


def es_onion(url: str) -> bool:
    return (urlsplit(url).hostname or "").endswith(".onion")


def normalizar_onion(url_tor: str) -> str:
    """La dirección .onion tal como se guarda («http://» delante si no lo lleva), o «» si viene vacía."""
    url_tor = (url_tor or "").strip().rstrip("/")
    if not url_tor:
        return ""
    if "://" not in url_tor:
        url_tor = "http://" + url_tor
    if not url_tor.startswith(("http://", "https://")) or not es_onion(url_tor):
        raise ErrorEnlace("Tiene que ser una dirección .onion (la que da tu servidor para Caudal).")
    return url_tor


# ── las direcciones que lleva el QR de enlazar (en el servidor) ──
#
# El QR lleva la dirección de casa y, si la hay, la .onion para fuera de casa. La de casa
# no puede ser un nombre .local: el teléfono no sabe resolverlos. En StartOS las da el
# propio sistema (el paquete las pasa en CAUDAL_DIRECCIONES); en otros servidores se
# escriben una vez en la página. Lo escrito a mano manda sobre lo del sistema.

def _orden_casa(url: str) -> tuple | None:
    """Cuánto conviene una dirección como «la de casa» (menos es mejor), o None si no vale."""
    u = urlsplit(url)
    host = (u.hostname or "").lower()
    if u.scheme not in ("http", "https") or not host or host.endswith(".onion"):
        return None
    if host in ("localhost",) or host.startswith("127.") or ":" in host:        # ni el propio equipo ni IPv6
        return None
    partes = host.split(".")
    es_ip = len(partes) == 4 and all(p.isdigit() for p in partes)
    if es_ip:
        a, b = int(partes[0]), int(partes[1])
        if a == 192 and b == 168:
            grupo = 0                                   # la red de casa de casi todos los routers
        elif a == 172 and 16 <= b <= 31:
            grupo = 1
        elif a == 10:
            grupo = 2                                   # también la usan túneles y contenedores: después
        else:
            return None
    elif host.endswith(".local"):
        grupo = 4                                       # el teléfono no los resuelve: solo si no hay otra
    else:
        grupo = 3                                       # un nombre de dominio propio
    return (grupo, 0 if u.scheme == "https" else 1, url)


def elegir_direcciones(urls) -> dict:
    """De las direcciones que da el sistema, la mejor para casa y la .onion (sin cifrar si la hay:
    por Tor ya va cifrado y así no hace falta el certificado)."""
    urls = [str(u).strip().rstrip("/") for u in (urls or []) if isinstance(u, str) and u.strip()]
    casas = sorted(o for o in map(_orden_casa, urls) if o)
    tors = sorted((0 if u.startswith("http://") else 1, u) for u in urls if es_onion(u))
    return {"casa": casas[0][2] if casas else "", "tor": tors[0][1] if tors else ""}


def direcciones_del_sistema() -> dict:
    try:
        urls = json.loads(os.environ.get(VARIABLE_DIRECCIONES) or "[]")
    except ValueError:
        return {"casa": "", "tor": ""}
    return elegir_direcciones(urls if isinstance(urls, list) else [])


def direcciones_de_enlace(carpeta_datos: Path) -> dict:
    """Las del QR: lo escrito a mano y, para lo que no se haya escrito, lo que da el sistema."""
    sistema = direcciones_del_sistema()
    try:
        manual = json.loads(almacen.leer_texto(Path(carpeta_datos).resolve().parent / FICHERO_DIRECCIONES))
    except (OSError, ValueError):
        manual = {}
    manual = manual if isinstance(manual, dict) else {}
    return {"casa": manual.get("casa") or sistema["casa"], "tor": manual.get("tor") or sistema["tor"],
            "sistema": sistema, "manual": {k: manual.get(k) or "" for k in ("casa", "tor")}}


def poner_direcciones_de_enlace(carpeta_datos: Path, casa: str, tor: str) -> dict:
    """Guarda las direcciones escritas a mano (vacías: se usan las del sistema)."""
    casa = (casa or "").strip().rstrip("/")
    if casa:
        if "://" not in casa:
            casa = "http://" + casa
        if _orden_casa(casa) is None and not urlsplit(casa).hostname:
            raise ErrorEnlace("La dirección de casa tiene que ser como https://192.168.1.50:8080 o la de tu dominio.")
        if es_onion(casa):
            raise ErrorEnlace("La dirección de casa no puede ser una .onion: esa va en su sitio.")
        if (urlsplit(casa).hostname or "").endswith(".local"):
            raise ErrorEnlace("Un nombre .local no sirve en el teléfono: pon la IP del servidor en tu red (por ejemplo, 192.168.1.50).")
    tor = normalizar_onion(tor)
    ruta = Path(carpeta_datos).resolve().parent / FICHERO_DIRECCIONES
    if casa or tor:
        almacen.escribir(ruta, json.dumps({"casa": casa, "tor": tor}, ensure_ascii=False, indent=1).encode())
    else:
        ruta.unlink(missing_ok=True)
    return direcciones_de_enlace(carpeta_datos)


class _Respuesta:
    def __init__(self, estado: int, cuerpo: bytes):
        self.status_code, self._cuerpo = estado, cuerpo

    def json(self):
        return json.loads(self._cuerpo)


class _SesionTor:
    """Lo justo de «requests.Session» para llegar a una dirección .onion por el
    Tor de este equipo, sin instalar nada más (el SOCKS5 es el de electrum.py)."""

    def __init__(self, proxy: tuple[str, int], certificado: str = ""):
        self.proxy, self.certificado = proxy, certificado
        self.cookies: dict[str, str] = {}

    def post(self, url: str, json=None, headers=None, timeout=TIEMPO):
        from .electrum import ErrorElectrum, _socks5
        import json as _json
        u = urlsplit(url)
        puerto = u.port or (443 if u.scheme == "https" else 80)
        try:
            sock = _socks5(u.hostname, puerto, self.proxy[0], self.proxy[1], TIEMPO_TOR)
        except ErrorElectrum as e:
            raise SinCamino(f"No llego al servidor por Tor: {e}.") from None
        try:
            if u.scheme == "https":
                # Por .onion es Tor quien garantiza con quién se habla; si además se ha dado el
                # certificado raíz del servidor, se comprueba también la firma (no el nombre)
                contexto = ssl.create_default_context(cafile=self.certificado) if self.certificado \
                    else ssl._create_unverified_context()
                contexto.check_hostname = False
                try:
                    # El nombre va en el saludo (SNI) aunque no se compruebe: un servidor que reparte
                    # varios servicios por el mismo puerto, como StartOS, lo necesita para saber cuál es
                    sock = contexto.wrap_socket(sock, server_hostname=u.hostname)
                except ssl.SSLError:
                    raise ErrorEnlace("El certificado que presenta el servidor por Tor no es de la autoridad que indicaste.") from None
            sock.settimeout(timeout if isinstance(timeout, (int, float)) else TIEMPO)
            conexion = http.client.HTTPConnection(u.hostname, puerto)
            conexion.sock = sock
            cabeceras = {"Host": u.netloc, "Content-Type": "application/json", "Connection": "close", **(headers or {})}
            if self.cookies:
                cabeceras["Cookie"] = "; ".join(f"{k}={v}" for k, v in self.cookies.items())
            conexion.request("POST", u.path or "/", _json.dumps(json or {}).encode(), cabeceras)
            r = conexion.getresponse()
            for galleta in r.headers.get_all("Set-Cookie") or []:
                nombre, _, valor = galleta.split(";")[0].partition("=")
                self.cookies[nombre.strip()] = valor.strip()
            return _Respuesta(r.status, r.read())
        except (OSError, http.client.HTTPException) as e:
            raise SinCamino(f"Se ha cortado la conexión por Tor ({e}).") from None
        finally:
            sock.close()


NO_ENTIENDO = "No entiendo esa petición."


def _ahora() -> str:
    return dt.datetime.now(dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")


# ── lo que viaja ──

def empaquetar(datos: Datos, ajustes: dict) -> dict:
    return {"version": VERSION, "datos": {n: getattr(datos, n) for n in FICHEROS},
            "ajustes": {n: ajustes[n] for n in AJUSTES if isinstance(ajustes.get(n), dict)}}


def desempaquetar(paquete: dict) -> tuple[Datos, dict]:
    """(datos, ajustes) de lo recibido, comprobado entero: si algo no vale, no vale nada."""
    if not isinstance(paquete, dict) or not isinstance(paquete.get("datos"), dict):
        raise ErrorEnlace("Lo recibido no es una copia de Caudal.")
    if paquete.get("version") != VERSION:
        raise ErrorEnlace("Los dos Caudal no son de la misma versión: actualiza el más antiguo y vuelve a sincronizar.")
    tablas = {}
    for nombre in FICHEROS:
        registros = paquete["datos"].get(nombre, [])
        if not isinstance(registros, list) or not all(isinstance(r, dict) for r in registros):
            raise ErrorEnlace("Lo recibido no es una copia de Caudal.")
        claves = [clave(nombre, r) for r in registros if (r.get("id") or r.get("activo"))]
        if len(claves) != len(registros) or len(set(claves)) != len(claves):
            raise ErrorEnlace("Lo recibido trae registros repetidos o sin identificar: no se mezcla.")
        tablas[nombre] = registros
    datos = Datos(**tablas)
    with tempfile.TemporaryDirectory() as tmp:           # la misma comprobación que al guardar
        try:
            escribir(Path(tmp), datos)
        except ErrorDatos as e:
            raise ErrorEnlace(f"Lo recibido tiene un dato que no vale ({e}): no se mezcla.") from None
    ajustes = paquete.get("ajustes") if isinstance(paquete.get("ajustes"), dict) else {}
    return datos, {n: ajustes[n] for n in AJUSTES if isinstance(ajustes.get(n), dict)}


def _ajustes_renombrados(ajustes: dict, mapa: dict[str, str]) -> dict:
    """Los ajustes que nombran inversiones (monederos, cuentas recordadas), con los identificadores nuevos."""
    if not mapa:
        return ajustes
    salida = json.loads(json.dumps(ajustes))
    for m in (salida.get("bitcoin.json") or {}).get("monederos") or []:
        if m.get("activo") in mapa:
            m["activo"] = mapa[m["activo"]]
    ex = salida.get("extractos.json") or {}
    for campo in ("cuenta_intereses", "destinos_exchange"):
        if isinstance(ex.get(campo), dict):
            ex[campo] = {k: mapa.get(v, v) for k, v in ex[campo].items()}
    return salida


def mezclar(mios: Datos, mis_ajustes: dict, suyos: Datos, sus_ajustes: dict, prefijos: dict) -> dict:
    """La mezcla de dos copias, sin tocar ninguna. Devuelve los datos y ajustes
    que deben quedar en las dos y el recuento de lo que cambia en cada lado."""
    mapa = choques_de_activos(mios, suyos, prefijos)
    suyos = renombrar_activos(suyos, mapa)
    sus_ajustes = _ajustes_renombrados(sus_ajustes, mapa)
    en_comun = sum(len({clave(n, r) for r in getattr(mios, n)} & {clave(n, r) for r in getattr(suyos, n)})
                   for n in ("activos", "movimientos", "recurrentes"))
    fusionado, recuento = fusionar(mios, suyos)
    fusionado = json.loads(json.dumps({n: getattr(fusionado, n) for n in FICHEROS}))     # copia: no tocar los originales
    fusionado = Datos(**fusionado)
    retiradas = unir_duplicadas(fusionado, _ahora())
    locales = {n: mis_ajustes.get(n) for n in AJUSTES if mis_ajustes.get(n) is not None}
    ajustes = {n: v for n, v in elegir_ajustes(locales, sus_ajustes).items() if n in AJUSTES}
    vivos = lambda d: len(d.vivos("activos")) + len(d.vivos("movimientos"))   # noqa: E731
    return {
        "datos": fusionado, "ajustes": ajustes,
        "resumen": {
            # «aquí» es quien mezcla (el servidor); «alli», quien ha enviado lo suyo
            "llegan_aqui": recuento["de_remoto"], "cambian_aqui": recuento["actualizados_desde_remoto"],
            "llegan_alli": recuento["de_local"], "cambian_alli": recuento["actualizados_desde_local"],
            "ajustes_aqui": [n for n in AJUSTES if _canonico(ajustes.get(n)) != _canonico(mis_ajustes.get(n))],
            "ajustes_alli": [n for n in AJUSTES if _canonico(ajustes.get(n)) != _canonico(sus_ajustes.get(n))],
            "renombradas": [{"de": k, "a": v, "nombre": next((a.get("nombre", "") for a in suyos.activos if a["id"] == v), "")}
                            for k, v in mapa.items()],
            "duplicadas": len(retiradas), "en_comun": en_comun,
            "carteras_distintas": en_comun == 0 and vivos(mios) > 0 and vivos(suyos) > 0,
        },
    }


def justificantes(carpeta: Path, datos: Datos) -> tuple[list[str], list[str]]:
    """(los que hay en este equipo, los que nombran los datos y faltan aquí)."""
    nombrados = sorted(adjuntos.referenciados(datos.movimientos))
    tengo = [h for h in nombrados if adjuntos.tiene(carpeta, h)]
    return tengo, [h for h in nombrados if h not in tengo]


# ── el lado que se enlaza (el del USB) ──

class Enlace:
    """La dirección del servidor y la credencial de este equipo, junto a los datos."""

    def __init__(self, carpeta_datos: Path):
        self.ruta = Path(carpeta_datos).resolve().parent / FICHERO

    def config(self) -> dict:
        try:
            return json.loads(almacen.leer_texto(self.ruta))
        except (OSError, ValueError):
            return {}

    def guardar(self, config: dict) -> None:
        almacen.escribir(self.ruta, json.dumps(config, ensure_ascii=False, indent=1).encode())

    def olvidar(self) -> None:
        self.ruta.unlink(missing_ok=True)
        (self.ruta.parent / FICHERO_CERTIFICADO).unlink(missing_ok=True)

    def guardar_certificado(self, pem: str) -> str:
        """Guarda junto a los datos el certificado raíz que se ha elegido como fichero (en el
        teléfono no hay una ruta que escribir) y devuelve dónde ha quedado."""
        pem = (pem or "").strip()
        if len(pem) > 50_000 or "-----BEGIN CERTIFICATE-----" not in pem:
            raise ErrorEnlace("Ese fichero no es un certificado (se espera un .crt o .pem, el que descargaste del servidor).")
        try:
            ssl.create_default_context(cadata=pem)
        except (ssl.SSLError, ValueError):
            raise ErrorEnlace("No puedo leer ese certificado: ¿es el certificado raíz que descargaste del servidor?") from None
        destino = self.ruta.parent / FICHERO_CERTIFICADO
        tmp = destino.with_name(destino.name + ".tmp")
        tmp.write_text(pem + "\n", encoding="ascii", errors="replace")
        os.chmod(tmp, 0o600)
        os.replace(tmp, destino)
        return str(destino)

    def _proxy(self) -> tuple[str, int]:
        """El Tor de este equipo: el mismo que se usa para llegar al nodo de bitcoin."""
        from . import btc
        return btc.proxy_de(btc.cargar(self.ruta.parent / "datos"))

    def _sesion(self, url: str):
        c = self.config()
        if es_onion(url):
            return _SesionTor(self._proxy(), c.get("certificado") or "")
        import requests
        s = requests.Session()
        s.verify = c.get("certificado") or True
        return s

    def caminos(self) -> list[str]:
        """Las direcciones del servidor, en el orden en que se prueban: la de
        casa y, si la hay, la .onion para cuando no se está en casa."""
        c = self.config()
        return [u.rstrip("/") for u in (c.get("url"), c.get("url_tor")) if u]

    def _pedir(self, sesion, url: str, cuerpo: dict, cabeceras: dict):
        import requests
        try:
            r = sesion.post(url, json=cuerpo, headers=cabeceras, timeout=(TIEMPO_CONECTAR, TIEMPO))
        except requests.exceptions.SSLError:
            raise ErrorEnlace("No puedo comprobar el certificado del servidor. Si tu servidor usa su propia autoridad "
                              "(como StartOS), descarga su certificado raíz e indica aquí dónde está.") from None
        except requests.exceptions.RequestException:
            raise SinCamino("No llego al servidor: comprueba la dirección y que haya red hasta él.") from None
        try:
            datos = r.json()
        except ValueError:
            raise ErrorEnlace("Esa dirección contesta, pero no parece un Caudal.") from None
        if r.status_code != 200:
            raise ErrorEnlace(datos.get("error") or f"El servidor ha contestado con un error ({r.status_code}).")
        return datos

    def enlazar(self, url: str, clave_servidor: str, certificado: str = "", nombre: str = "", codigo: str = "",
                certificado_pem: str = "", url_tor: str = "") -> dict:
        """Entra una vez con la contraseña del servidor y la cambia por una credencial de este equipo.
        Con un código de enlace (el que enseña el servidor) no hace falta la contraseña. El certificado
        raíz llega como ruta a un fichero o, elegido en la página, con su contenido. Si llega también la
        .onion (la trae el QR), queda como camino de reserva y, si la dirección de casa no responde
        (enlazando fuera de casa), se enlaza por ella."""
        url = (url or "").strip().rstrip("/")
        if not url.startswith(("http://", "https://")):
            raise ErrorEnlace("La dirección tiene que empezar por https:// (o http:// si es dentro de tu casa o una .onion).")
        url_tor = normalizar_onion(url_tor) if url_tor and url_tor.strip().rstrip("/") != url else ""
        if certificado_pem:
            certificado = self.guardar_certificado(certificado_pem)
        if certificado and not Path(certificado).is_file():
            raise ErrorEnlace("No encuentro ese fichero de certificado.")
        self.guardar({"url": url, "certificado": certificado or ""})
        caminos = [url] + ([url_tor] if url_tor else [])
        credencial, fallo = None, None
        try:
            for base in caminos:
                try:
                    credencial = self._credencial_nueva(base, clave_servidor, nombre, codigo)
                    break
                except SinCamino as e:          # por aquí no se llega (el código sigue valiendo): el siguiente
                    fallo = e
            if credencial is None:
                if len(caminos) > 1:
                    raise SinCamino(f"No llego al servidor ni por la dirección de casa ni por la .onion. {fallo}")
                raise fallo
        except ErrorEnlace:
            self.olvidar()
            raise
        self.guardar({"url": url, **({"url_tor": url_tor} if url_tor else {}), "certificado": certificado or "",
                      "credencial": credencial, "enlazado": _ahora()})
        return {"url": url, "url_tor": url_tor}

    def _credencial_nueva(self, base: str, clave_servidor: str, nombre: str, codigo: str) -> str:
        sesion = self._sesion(base)
        if codigo.strip():
            return self._pedir(sesion, f"{base}/api/enlace/canje", {"codigo": codigo, "nombre": nombre or "Otro Caudal"},
                               {"X-Caudal": "1"})["credencial"]
        entrada = self._pedir(sesion, f"{base}/api/acceso/entrar", {"clave": clave_servidor}, {"X-Caudal": "1"})
        alta = self._pedir(sesion, f"{base}/api/enlace/alta", {"nombre": nombre or "Otro Caudal"}, {"X-Token": entrada["token"]})
        self._pedir(sesion, f"{base}/api/acceso/salir", {}, {"X-Caudal": "1"})
        return alta["resultado"]["credencial"]

    def llamar(self, orden: str, cuerpo: dict) -> dict:
        c = self.config()
        if not c.get("credencial"):
            raise ErrorEnlace("Este Caudal no está enlazado con ningún servidor.")
        return self._por_algun_camino(self.caminos(), orden, cuerpo, c["credencial"])

    def _por_algun_camino(self, caminos: list[str], orden: str, cuerpo: dict, credencial: str) -> dict:
        fallo = None
        for base in caminos:
            try:
                return self._pedir(self._sesion(base), f"{base}/api/enlace", {"orden": orden, **cuerpo},
                                   {"X-Enlace": credencial})
            except SinCamino as e:
                fallo = e
        if len(caminos) > 1:
            raise SinCamino(f"No llego al servidor ni por la dirección de casa ni por la .onion. {fallo}")
        raise fallo or ErrorEnlace("Este Caudal no está enlazado con ningún servidor.")

    def poner_onion(self, url_tor: str) -> dict:
        """Añade (o quita, con «») la dirección .onion del servidor, para sincronizar
        fuera de casa. Antes de guardarla comprueba que por ella se llega al mismo
        servidor y que acepta la credencial de este equipo."""
        c = self.config()
        if not c.get("credencial"):
            raise ErrorEnlace("Este Caudal no está enlazado con ningún servidor.")
        url_tor = normalizar_onion(url_tor)
        if not url_tor:
            self.guardar({k: v for k, v in c.items() if k != "url_tor"})
            return {"url_tor": ""}
        try:
            self._por_algun_camino([url_tor], "hola", {}, c["credencial"])
        except SinCamino:
            raise
        except ErrorEnlace as e:
            # Un Caudal anterior a esta orden contesta que no la entiende: vale igual,
            # porque para contestar eso ya ha dado por buena la credencial
            if str(e) != NO_ENTIENDO:
                raise
        self.guardar({**c, "url_tor": url_tor})
        return {"url_tor": url_tor}


def sincronizar(app, simular: bool) -> dict:
    """Desde el Caudal enlazado: envía lo suyo, recibe la mezcla y la aplica (salvo que sea un simulacro)."""
    enlace = Enlace(app.carpeta)
    carpeta = app.cartera.carpeta
    with app.cartera._lock:
        mios = app.cartera.datos
        mis_ajustes = leer_ajustes(carpeta.parent)
        tengo, _ = justificantes(carpeta, mios)
        respuesta = enlace.llamar("simular" if simular else "mezclar", {**empaquetar(mios, mis_ajustes), "justificantes": tengo})
        resumen = respuesta["resumen"]
        if simular:
            return {"simulacro": True, "resumen": resumen}
        fusionado, ajustes = desempaquetar(respuesta)
        # Lo que vuelve tiene que contener todo lo que se envió (salvo lo que el servidor renombró)
        renombradas = {x["de"] for x in resumen["renombradas"]}
        for nombre in FICHEROS:
            vuelven = {clave(nombre, r) for r in getattr(fusionado, nombre)}
            faltan = [k for k in (clave(nombre, r) for r in getattr(mios, nombre))
                      if k not in vuelven and k.split("|")[0] not in renombradas]
            if nombre in ("movimientos", "recurrentes") and faltan:
                raise ErrorEnlace("El servidor ha devuelto menos de lo que le envié: no aplico nada. Vuelve a intentarlo.")
        cambia = huella_datos(fusionado) != huella_datos(mios)
        cambian_ajustes = [n for n in AJUSTES if _canonico(ajustes.get(n)) != _canonico(mis_ajustes.get(n))]
        if cambia or cambian_ajustes:
            app._copia_datos()                       # lo que había, a la carpeta de copias locales
        if cambia:
            app.cartera.reemplazar(fusionado)
        for nombre in cambian_ajustes:
            escribir_ajuste(carpeta.parent / nombre, ajustes[nombre])
    # Los justificantes, después y de uno en uno: si alguno falla, el siguiente sincronizar lo reintenta
    subidos = bajados = 0
    for h in respuesta.get("le_faltan") or []:
        if adjuntos.tiene(carpeta, h):
            enlace.llamar("subir", {"contenido": base64.b64encode(adjuntos.leer(carpeta, h)).decode()})
            subidos += 1
    for h in justificantes(carpeta, app.cartera.datos)[1]:
        if h in (respuesta.get("tiene") or []):
            contenido = base64.b64decode(enlace.llamar("bajar", {"huella": h})["contenido"])
            if adjuntos.guardar(carpeta, contenido) == h:
                bajados += 1
    config = enlace.config()
    enlace.guardar({**config, "ultima": _ahora()})
    return {"simulacro": False, "resumen": resumen, "justificantes": {"subidos": subidos, "bajados": bajados}}


# ── el lado del servidor ──

def atender(app, orden: str, cuerpo: dict, prefijos: dict) -> dict:
    """Lo que pide un Caudal enlazado. Quien llama ya ha comprobado su credencial."""
    carpeta = app.cartera.carpeta
    if orden == "subir":
        try:
            return {"huella": adjuntos.guardar(carpeta, base64.b64decode(str(cuerpo.get("contenido") or ""), validate=True))}
        except (ValueError, adjuntos.ErrorAdjunto) as e:
            raise ErrorEnlace(f"Ese justificante no se puede guardar: {e}") from None
    if orden == "bajar":
        try:
            return {"contenido": base64.b64encode(adjuntos.leer(carpeta, str(cuerpo.get("huella") or ""))).decode()}
        except adjuntos.ErrorAdjunto as e:
            raise ErrorEnlace(str(e)) from None
    if orden == "hola":                              # para probar un camino sin mover nada
        return {"hola": True}
    if orden not in ("simular", "mezclar"):
        raise ErrorEnlace(NO_ENTIENDO)
    suyos, sus_ajustes = desempaquetar(cuerpo)
    with app.cartera._lock:
        mios = app.cartera.datos
        mis_ajustes = leer_ajustes(carpeta.parent)
        m = mezclar(mios, mis_ajustes, suyos, sus_ajustes, prefijos)
        if orden == "simular":
            return {"resumen": m["resumen"]}
        r = m["resumen"]
        # Se compara el resultado entero con lo que había, no los recuentos: una inversión puede «ganar»
        # y aun así salir distinta de la mezcla (con los lugares que se añadieron en el otro lado)
        cambia = huella_datos(m["datos"]) != huella_datos(mios)
        if cambia or r["ajustes_aqui"]:
            app._copia_datos()
        if cambia:
            app.cartera.reemplazar(m["datos"])
        for nombre in r["ajustes_aqui"]:
            escribir_ajuste(carpeta.parent / nombre, m["ajustes"][nombre])
        tengo, me_faltan = justificantes(carpeta, m["datos"])
        return {**empaquetar(m["datos"], m["ajustes"]), "resumen": r, "tiene": tengo,
                "le_faltan": [h for h in me_faltan if h in (cuerpo.get("justificantes") or [])]}