"""Envia una imagen (con caption opcional) a un chat de WhatsApp Web via Chrome DevTools Protocol.

Compone `whatsapp_open_chat` (abrir + verificar destinatario) con primitivas CDP del
registry (`cdp_eval`, `cdp_click_xy`, `cdp_set_file_input`, `cdp_type_chars`) para adjuntar
y enviar una imagen a un contacto/grupo SIN abrir ventana nueva ni darle foco al sistema.

Flujo (modelo de bandeja de medios INLINE de la WhatsApp Web actual), con salvaguarda
anti-envio-al-contacto-equivocado:

  1. Abre el chat por su nombre exacto (`open_first=True`). Si no abre, aborta. Con
     `open_first=False`, asume el chat abierto pero VERIFICA que el aria-label del composer
     contiene el nombre; si no, aborta por seguridad.
  2. Hace click de raton real en el boton "Adjuntar" del footer: esto expone el
     `<input type=file>` "vivo" que escucha la SPA (antes de pulsarlo el input persistente
     no dispara el preview).
  3. Asigna la imagen al input via `cdp_set_file_input` (`DOM.setFileInputFiles`): la
     imagen aparece como miniatura en la bandeja inline sobre el composer.
  4. Espera a que el preview aparezca (boton "Quitar archivo adjunto" presente).
  5. Si `caption` no esta vacio, enfoca el composer del footer y teclea el texto con
     teclado CDP real (`cdp_type_chars`); verifica el `innerText` antes de enviar.
  6. Click de raton real en el boton enviar (icono `wds-ic-send-filled`) y verifica que la
     bandeja se cerro (sin adjuntos) para confirmar el envio.

Validado contra WhatsApp Web real. Accion CON EFECTO REAL E IRREVERSIBLE: envia la imagen
de verdad.
"""

import json
import os
import sys
import time

sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))

from browser.cdp_eval import cdp_eval
from browser.cdp_click_xy import cdp_click_xy
from browser.cdp_type_chars import cdp_type_chars
from browser.cdp_set_file_input import cdp_set_file_input
from browser.whatsapp_open_chat import whatsapp_open_chat


def _center(expr: str, port: int, substr: str):
    """Evalua una expresion que devuelve JSON {x,y} (o null) y la parsea a dict/None."""
    r = cdp_eval(expr, port=port, target_url_substr=substr)
    val = r.get("value")
    if not val:
        return None
    try:
        return json.loads(val)
    except Exception:  # noqa: BLE001 — value no-JSON
        return None


def _attachment_count(port: int, substr: str) -> int:
    """Numero de adjuntos en la bandeja inline (botones 'Quitar archivo adjunto')."""
    r = cdp_eval(
        '/*PREVIEW*/document.querySelectorAll(\'[aria-label="Quitar archivo adjunto"]\').length',
        port=port, target_url_substr=substr,
    )
    v = r.get("value")
    return v if isinstance(v, int) else 0


def whatsapp_send_image(
    name: str,
    image_path: str,
    *,
    caption: str = "",
    port: int = 9222,
    target_url_substr: str = "whatsapp",
    open_first: bool = True,
) -> dict:
    """Envia una imagen (con caption opcional) a un chat de WhatsApp Web ya logueado.

    Accion CON EFECTO: envia la imagen DE VERDAD (no reversible). Verifica `name`.

    Args:
        name: Nombre EXACTO del chat/grupo destinatario, tal y como aparece en la lista
            lateral. Se usa para abrir el chat y como salvaguarda de que el composer apunta
            al destinatario correcto antes de adjuntar.
        image_path: Ruta de la imagen a enviar. Se expande (`~`) y se convierte a ruta
            ABSOLUTA; debe existir en disco.
        caption: Texto opcional que acompana la imagen. Se teclea en el composer con teclado
            CDP real; "" (default) envia la imagen sin caption.
        port: Puerto de remote debugging de Chrome. Default 9222.
        target_url_substr: Substring que debe contener la URL del target (pestana). Default
            "whatsapp".
        open_first: Si True (default), abre el chat por su nombre antes de adjuntar. Si
            False, asume el chat ya abierto pero verifica el aria-label del composer contra
            `name` (aborta si no coincide).

    Returns:
        dict con claves:
            ok: bool — alias de sent (True si la imagen se envio).
            sent: bool — True si la imagen se adjunto, (caption escrito) y se envio.
            recipient: str — el nombre solicitado.
            image: str — ruta absoluta de la imagen.
            caption: str — caption solicitado.
            error: str — motivo del fallo (vacio si sent=True).

        Nunca lanza: los fallos se reportan en "sent"/"ok" + "error".
    """
    S = target_url_substr
    abs_img = os.path.abspath(os.path.expanduser(image_path))

    def fail(error: str) -> dict:
        return {"ok": False, "sent": False, "recipient": name,
                "image": abs_img, "caption": caption, "error": error}

    # 0. La imagen debe existir.
    if not os.path.isfile(abs_img):
        return fail(f"imagen no encontrada: {abs_img}")

    # 1. Abrir + verificar destinatario correcto (salvaguarda anti-equivocacion).
    if open_first:
        o = whatsapp_open_chat(name, port=port, target_url_substr=S)
        if not o.get("opened"):
            return fail(o.get("reason", "no se pudo abrir el chat"))
    else:
        chk = cdp_eval(
            '/*LABEL*/var b=document.querySelector(\'footer div[contenteditable="true"]\'); '
            "b?b.getAttribute('aria-label'):null",
            port=port, target_url_substr=S,
        )
        if name not in (chk.get("value") or ""):
            return fail("el chat abierto no coincide con el destinatario; abortado por seguridad")

    # 2. Click real en "Adjuntar" para exponer el <input type=file> vivo.
    adj = _center(
        '/*ADJUNTAR*/(() => {const e=document.querySelector(\'button[aria-label="Adjuntar"]\');'
        "if(!e)return null;const b=e.getBoundingClientRect();"
        "return JSON.stringify({x:Math.round(b.x+b.width/2),y:Math.round(b.y+b.height/2)});})()",
        port, S,
    )
    if not adj:
        return fail("boton 'Adjuntar' no encontrado en el footer")
    cdp_click_xy(adj["x"], adj["y"], port=port, target_url_substr=S)
    time.sleep(0.8)

    # 3. Asignar la imagen al input multiple (el que se activa tras Adjuntar);
    #    fallback al primer input file si el selector con [multiple] no resuelve.
    r = cdp_set_file_input('input[type="file"][multiple]', abs_img,
                           port=port, target_url_substr=S)
    if not r.get("ok"):
        r = cdp_set_file_input('input[type="file"]', abs_img,
                               port=port, target_url_substr=S)
    if not r.get("ok"):
        return fail("no se pudo adjuntar la imagen: " + r.get("error", ""))

    # 4. Esperar a que el preview/bandeja aparezca (adjunto presente).
    attached = False
    for _ in range(15):
        time.sleep(0.2)
        if _attachment_count(port, S) > 0:
            attached = True
            break
    if not attached:
        return fail("el preview no aparecio tras adjuntar la imagen")

    # 5. Caption opcional: enfocar el composer y teclear con teclado real.
    if caption:
        cdp_eval(
            '/*FOCUS*/var b=document.querySelector(\'div[contenteditable="true"]\'); '
            "if(b){b.focus();}",
            port=port, target_url_substr=S,
        )
        time.sleep(0.25)
        cdp_type_chars(caption, port=port, target_url_substr=S, delay_ms=15)
        time.sleep(0.3)
        chk = cdp_eval(
            '/*COMPOSER*/var b=document.querySelector(\'div[contenteditable="true"]\'); '
            "b?b.innerText.replace(/\\n/g,''):''",
            port=port, target_url_substr=S,
        )
        composer = chk.get("value") or ""
        if composer != caption:
            return fail("el composer no contiene el caption esperado (no enviado): "
                        + repr(composer))

    # 6. Click real en el boton enviar (icono wds-ic-send-filled).
    snd = _center(
        '/*SEND*/(() => {const e=document.querySelector(\'span[data-icon="wds-ic-send-filled"]\');'
        "if(!e)return null;const b=e.getBoundingClientRect();"
        "if(b.width===0)return null;"
        "return JSON.stringify({x:Math.round(b.x+b.width/2),y:Math.round(b.y+b.height/2)});})()",
        port, S,
    )
    if not snd:
        return fail("boton de enviar (wds-ic-send-filled) no encontrado")
    cdp_click_xy(snd["x"], snd["y"], port=port, target_url_substr=S)

    # 7. Verificar que la bandeja se cerro (sin adjuntos) -> envio confirmado.
    for _ in range(15):
        time.sleep(0.2)
        if _attachment_count(port, S) == 0:
            return {"ok": True, "sent": True, "recipient": name,
                    "image": abs_img, "caption": caption, "error": ""}

    return fail("la bandeja no se cerro tras pulsar enviar; envio incierto")


if __name__ == "__main__":
    chat = sys.argv[1] if len(sys.argv) > 1 else "NOTAS WASAP"
    img = sys.argv[2] if len(sys.argv) > 2 else ""
    cap = sys.argv[3] if len(sys.argv) > 3 else ""
    out = whatsapp_send_image(chat, img, caption=cap,
                              port=9222, target_url_substr="whatsapp")
    print(json.dumps(out, ensure_ascii=False, indent=2))