"""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`) y `whatsapp_send_message` 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.
  4. Espera a que la bandeja aparezca (boton "Quitar archivo adjunto" presente) y hace click
     real en el boton de enviar la bandeja (icono `wds-ic-send-filled`); verifica que la
     bandeja se cerro (sin adjuntos) para confirmar el envio de la imagen.
  5. Si `caption` no esta vacio, lo envia como un MENSAJE DE TEXTO de seguimiento via
     `whatsapp_send_message` (con `open_first=False`, el chat ya esta abierto). En la
     WhatsApp Web compacta actual el caption embebido en la imagen no es automatizable de
     forma fiable, asi que la descripcion viaja como una segunda burbuja: [imagen][caption].

Validado contra WhatsApp Web real. Accion CON EFECTO REAL E IRREVERSIBLE: envia la imagen
(y el caption) 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_set_file_input import cdp_set_file_input
from browser.whatsapp_open_chat import whatsapp_open_chat
from browser.whatsapp_send_message import whatsapp_send_message


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 de seguimiento) a un chat de WhatsApp Web.

    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 descriptivo. Se envia como un MENSAJE DE TEXTO de seguimiento
            (segunda burbuja [imagen][caption]) via `whatsapp_send_message`; "" (default)
            envia solo la imagen.
        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 — True si la imagen se envio y (si habia caption) el caption tambien.
            sent: bool — True si la IMAGEN se envio.
            caption_sent: bool — True si el caption de seguimiento se envio (False si no
                habia caption o si fallo).
            recipient: str — el nombre solicitado.
            image: str — ruta absoluta de la imagen.
            caption: str — caption solicitado.
            error: str — motivo del fallo (vacio si todo ok).

        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, "caption_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 la bandeja aparezca (adjunto presente). El composer queda VACIO,
    #    asi que el unico boton wds-ic-send-filled es el de enviar la bandeja.
    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. Click real en el boton de enviar la bandeja (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)

    # 6. Verificar que la bandeja se cerro (sin adjuntos) -> imagen enviada.
    image_sent = False
    for _ in range(15):
        time.sleep(0.2)
        if _attachment_count(port, S) == 0:
            image_sent = True
            break
    if not image_sent:
        return fail("la bandeja no se cerro tras pulsar enviar; envio incierto")

    # 7. Caption opcional como mensaje de texto de seguimiento (segunda burbuja).
    caption_sent = False
    if caption:
        m = whatsapp_send_message(name, caption, port=port, target_url_substr=S,
                                  open_first=False)
        caption_sent = bool(m.get("sent"))
        if not caption_sent:
            return {"ok": False, "sent": True, "caption_sent": False, "recipient": name,
                    "image": abs_img, "caption": caption,
                    "error": "imagen enviada pero el caption fallo: " + m.get("reason", "")}

    return {"ok": True, "sent": True, "caption_sent": caption_sent, "recipient": name,
            "image": abs_img, "caption": caption, "error": ""}


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))