#!/usr/bin/env python3
"""Audita mensagens que existem no Chatwoot mas não aparecem no ClientFlow.

Caso de uso: ClientFlow esteve em baixo e o Chatwoot não conseguiu entregar
webhooks. Nessa situação não existe raw_event para auditar; por isso este script
lê conversas/mensagens diretamente da API do Chatwoot e compara cada mensagem
inbound pública com raw_events/messages/communications no PostgreSQL.

Uso seguro:
  PYTHONPATH=. python scripts/audit_chatwoot_remote_missing_messages.py --hours 72
  PYTHONPATH=. python scripts/audit_chatwoot_remote_missing_messages.py --hours 72 --include-ok
  PYTHONPATH=. python scripts/audit_chatwoot_remote_missing_messages.py --hours 72 --post-missing --limit 25

Variáveis necessárias:
  CHATWOOT_BASE_URL
  CHATWOOT_ACCOUNT_ID
  CHATWOOT_API_TOKEN
  DATABASE_URL

Para --post-missing também:
  CLIENTFLOW_WEBHOOK_SECRET
  CLIENTFLOW_WEBHOOK_URL opcional; por defeito http://127.0.0.1:8020/webhooks/chatwoot
"""
from __future__ import annotations

import argparse
import csv
import hashlib
import hmac
import json
import os
import sys
import time
import urllib.error
import urllib.parse
import urllib.request
from dataclasses import dataclass
from datetime import datetime, timedelta, timezone
from pathlib import Path
from typing import Any, Iterable

PROJECT_ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(PROJECT_ROOT))
os.chdir(PROJECT_ROOT)

from sqlalchemy import text

from app.db import engine

OUT_CSV = Path("/tmp/clientflow_chatwoot_remote_missing_messages.csv")
OUT_MD = Path("/tmp/clientflow_chatwoot_remote_missing_messages.md")


def env(name: str, default: str = "") -> str:
    return os.getenv(name, default).strip()


CHATWOOT_BASE_URL = env("CHATWOOT_BASE_URL").rstrip("/")
CHATWOOT_ACCOUNT_ID = env("CHATWOOT_ACCOUNT_ID")
CHATWOOT_API_TOKEN = env("CHATWOOT_API_TOKEN")
CLIENTFLOW_WEBHOOK_SECRET = env("CLIENTFLOW_WEBHOOK_SECRET")
CLIENTFLOW_WEBHOOK_URL = env("CLIENTFLOW_WEBHOOK_URL", "http://127.0.0.1:8020/webhooks/chatwoot")


@dataclass
class RemoteMessage:
    conversation: dict[str, Any]
    message: dict[str, Any]
    recent_context: list[dict[str, Any]]


def clean(value: Any, limit: int = 240) -> str:
    txt = " ".join(str(value or "").replace("\r", " ").replace("\n", " ").split())
    return txt if len(txt) <= limit else txt[: limit - 1].rstrip() + "…"


def ts_to_datetime(value: Any) -> datetime | None:
    if value is None:
        return None
    try:
        if isinstance(value, (int, float)):
            return datetime.fromtimestamp(float(value), tz=timezone.utc)
        s = str(value).strip().replace("Z", "+00:00")
        if not s:
            return None
        return datetime.fromisoformat(s).astimezone(timezone.utc)
    except Exception:
        return None


def dt_to_display(value: Any) -> str:
    dt = ts_to_datetime(value)
    return dt.isoformat() if dt else str(value or "")


def message_created_at(message: dict[str, Any]) -> datetime:
    return ts_to_datetime(message.get("created_at")) or datetime.fromtimestamp(0, tz=timezone.utc)


def conversation_last_activity(conversation: dict[str, Any]) -> datetime | None:
    for key in ["last_activity_at", "updated_at", "created_at"]:
        dt = ts_to_datetime(conversation.get(key))
        if dt:
            return dt
    return None


def request_json(method: str, url: str, *, body: dict[str, Any] | None = None, headers: dict[str, str] | None = None) -> dict[str, Any]:
    data = None
    final_headers = dict(headers or {})
    if body is not None:
        data = json.dumps(body, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
        final_headers["Content-Type"] = "application/json"

    req = urllib.request.Request(url, data=data, headers=final_headers, method=method)
    try:
        with urllib.request.urlopen(req, timeout=45) as resp:
            raw = resp.read().decode("utf-8", errors="replace")
            try:
                parsed: Any = json.loads(raw) if raw else {}
            except json.JSONDecodeError:
                parsed = {}
            return {"ok": 200 <= resp.status < 300, "status": resp.status, "json": parsed, "raw": raw}
    except urllib.error.HTTPError as e:
        raw = e.read().decode("utf-8", errors="replace")
        return {"ok": False, "status": e.code, "json": None, "raw": raw}
    except urllib.error.URLError as e:
        return {"ok": False, "status": 0, "json": None, "raw": str(e)}


def chatwoot_headers() -> dict[str, str]:
    return {"api_access_token": CHATWOOT_API_TOKEN, "Accept": "application/json"}


def payload_list(data: Any) -> list[dict[str, Any]]:
    if isinstance(data, list):
        return [item for item in data if isinstance(item, dict)]
    if not isinstance(data, dict):
        return []

    candidates = [
        data.get("payload"),
        data.get("data", {}).get("payload") if isinstance(data.get("data"), dict) else None,
        data.get("data"),
        data.get("messages"),
    ]
    for item in candidates:
        if isinstance(item, list):
            return [row for row in item if isinstance(row, dict)]
    return []


def fetch_conversations(status: str, *, max_pages: int) -> list[dict[str, Any]]:
    all_items: list[dict[str, Any]] = []
    for page in range(1, max_pages + 1):
        query = urllib.parse.urlencode({"status": status, "page": page})
        url = f"{CHATWOOT_BASE_URL}/api/v1/accounts/{CHATWOOT_ACCOUNT_ID}/conversations?{query}"
        result = request_json("GET", url, headers=chatwoot_headers())
        if not result["ok"]:
            print(f"ERRO Chatwoot conversations status={status} page={page}: {result['status']} {result['raw'][:300]}")
            break
        items = payload_list(result["json"])
        if not items:
            break
        all_items.extend(items)
        if len(items) < 10:
            break
    return all_items


def fetch_messages(conversation_id: str) -> list[dict[str, Any]]:
    url = f"{CHATWOOT_BASE_URL}/api/v1/accounts/{CHATWOOT_ACCOUNT_ID}/conversations/{conversation_id}/messages"
    result = request_json("GET", url, headers=chatwoot_headers())
    if not result["ok"]:
        print(f"ERRO Chatwoot messages conversation={conversation_id}: {result['status']} {result['raw'][:300]}")
        return []
    return payload_list(result["json"])


def is_incoming(message: dict[str, Any]) -> bool:
    mt = message.get("message_type")
    return mt == "incoming" or mt == 0 or str(mt).lower() == "incoming"


def message_content(message: dict[str, Any]) -> str:
    return str(message.get("content") or message.get("text") or message.get("body") or "").strip()


def message_id(message: dict[str, Any]) -> str:
    return str(message.get("id") or message.get("message_id") or "").strip()


def sender_from_conversation(conversation: dict[str, Any], message: dict[str, Any]) -> dict[str, Any]:
    sender: dict[str, Any] = {}
    meta = conversation.get("meta") or {}
    if isinstance(meta, dict) and isinstance(meta.get("sender"), dict):
        sender.update(meta.get("sender") or {})
    if isinstance(conversation.get("contact"), dict):
        sender.update({k: v for k, v in conversation["contact"].items() if v is not None})
    if isinstance(message.get("sender"), dict):
        sender.update({k: v for k, v in message["sender"].items() if v is not None})
    return sender


def iter_remote_messages(
    *,
    statuses: Iterable[str],
    cutoff: datetime,
    max_pages: int,
    max_context_messages: int,
) -> list[RemoteMessage]:
    seen_conversations: set[str] = set()
    selected: list[RemoteMessage] = []

    for status in statuses:
        conversations = fetch_conversations(status, max_pages=max_pages)
        print(f"--- status={status} conversations={len(conversations)}")
        for conv in conversations:
            conv_id = str(conv.get("id") or "").strip()
            if not conv_id or conv_id in seen_conversations:
                continue
            seen_conversations.add(conv_id)

            last_activity = conversation_last_activity(conv)
            if last_activity and last_activity < cutoff:
                continue

            messages = fetch_messages(conv_id)
            messages.sort(key=message_created_at)
            public_messages = [m for m in messages if not m.get("private") and message_content(m)]

            for index, msg in enumerate(public_messages):
                if not is_incoming(msg):
                    continue
                if message_created_at(msg) < cutoff:
                    continue
                mid = message_id(msg)
                if not mid:
                    continue
                start = max(0, index - max_context_messages)
                context = public_messages[start : index + 1]
                selected.append(RemoteMessage(conversation=conv, message=msg, recent_context=context))

    selected.sort(key=lambda item: message_created_at(item.message))
    return selected


def load_clientflow_status(source_event_ids: list[str]) -> dict[str, dict[str, Any]]:
    if not source_event_ids:
        return {}
    with engine.begin() as conn:
        rows = conn.execute(text("""
            WITH ids AS (
                SELECT unnest(CAST(:ids AS text[])) AS source_event_id
            )
            SELECT
                ids.source_event_id,
                re.id::text AS raw_event_id,
                re.created_at AS raw_event_created_at,
                re.processed,
                re.ignored,
                re.processing_error,
                re.message_id::text AS raw_event_message_id,
                re.action_run_id::text AS raw_event_action_run_id,
                m.id::text AS message_id,
                c.id::text AS communication_id,
                o.id::text AS opportunity_id
            FROM ids
            LEFT JOIN raw_events re
              ON re.source_system = 'chatwoot'
             AND re.source_event_id = ids.source_event_id
            LEFT JOIN messages m
              ON (
                    (re.message_id IS NOT NULL AND m.id = re.message_id)
                 OR (re.id IS NOT NULL AND m.raw_event_id = re.id)
                 OR (m.source_system = 'chatwoot' AND m.source_event_id = ids.source_event_id)
              )
            LEFT JOIN communications c
              ON c.source_system = 'chatwoot'
             AND c.source_message_id = ids.source_event_id
            LEFT JOIN opportunities o
              ON o.conversation_id = COALESCE(re.conversation_id, m.conversation_id)
        """), {"ids": source_event_ids}).mappings().all()
    return {str(row["source_event_id"]): dict(row) for row in rows}


def classify(row: dict[str, Any] | None) -> str:
    row = row or {}
    visible_message_id = row.get("message_id") or row.get("raw_event_message_id")
    if not row.get("raw_event_id") and not visible_message_id and not row.get("communication_id"):
        return "MISSING_IN_CLIENTFLOW"
    if row.get("processing_error"):
        return "RAW_PROCESSING_ERROR"
    if row.get("raw_event_id") and not row.get("processed") and not row.get("ignored"):
        return "RAW_PENDING"
    if row.get("ignored"):
        return "RAW_IGNORED"
    if row.get("processed") and not visible_message_id and not row.get("communication_id"):
        return "PROCESSED_BUT_NOT_VISIBLE"
    if not row.get("opportunity_id"):
        return "VISIBLE_BUT_UNLINKED_CONVERSATION"
    return "OK"


def build_webhook_payload(remote: RemoteMessage) -> dict[str, Any]:
    conv = remote.conversation
    msg = remote.message
    conv_id = str(conv.get("id") or msg.get("conversation_id") or "")
    sender = sender_from_conversation(conv, msg)
    contact_id = str(sender.get("id") or conv.get("contact_id") or conv.get("contact", {}).get("id") or msg.get("contact_id") or "")

    normalized_message = dict(msg)
    normalized_message["id"] = message_id(msg)
    normalized_message["content"] = message_content(msg)
    normalized_message["message_type"] = "incoming"
    normalized_message["conversation_id"] = conv_id
    normalized_message["sender"] = sender
    normalized_message["private"] = bool(msg.get("private"))

    conversation_payload = dict(conv)
    conversation_payload["id"] = conv_id
    conversation_payload["messages"] = remote.recent_context
    conversation_payload["contact"] = conv.get("contact") if isinstance(conv.get("contact"), dict) else sender
    meta = conversation_payload.get("meta") if isinstance(conversation_payload.get("meta"), dict) else {}
    meta = dict(meta)
    meta.setdefault("sender", sender)
    conversation_payload["meta"] = meta

    return {
        "event": "message_created",
        "id": normalized_message["id"],
        "message_id": normalized_message["id"],
        "conversation_id": conv_id,
        "contact_id": contact_id,
        "content": normalized_message["content"],
        "message_type": "incoming",
        "private": bool(msg.get("private")),
        "message": normalized_message,
        "conversation": conversation_payload,
        "sender": sender,
        "backfill": {
            "source": "chatwoot_remote_missing_messages",
            "reason": "clientflow_down_or_webhook_not_delivered",
            "audited_at": datetime.now(timezone.utc).isoformat(),
        },
    }


def sign_body(body_raw: str) -> dict[str, str]:
    ts = str(int(time.time()))
    msg = ts.encode("utf-8") + b"." + body_raw.encode("utf-8")
    sig = "sha256=" + hmac.new(CLIENTFLOW_WEBHOOK_SECRET.encode("utf-8"), msg, hashlib.sha256).hexdigest()
    return {"Content-Type": "application/json", "X-Chatwoot-Timestamp": ts, "X-Chatwoot-Signature": sig}


def post_to_clientflow(payload: dict[str, Any]) -> dict[str, Any]:
    body_raw = json.dumps(payload, ensure_ascii=False, separators=(",", ":"))
    headers = sign_body(body_raw)
    req = urllib.request.Request(CLIENTFLOW_WEBHOOK_URL, data=body_raw.encode("utf-8"), headers=headers, method="POST")
    try:
        with urllib.request.urlopen(req, timeout=60) as resp:
            raw = resp.read().decode("utf-8", errors="replace")
            return {"ok": 200 <= resp.status < 300, "status": resp.status, "raw": raw}
    except urllib.error.HTTPError as e:
        raw = e.read().decode("utf-8", errors="replace")
        return {"ok": False, "status": e.code, "raw": raw}
    except urllib.error.URLError as e:
        return {"ok": False, "status": 0, "raw": str(e)}


def write_reports(rows: list[dict[str, Any]], counts: dict[str, int], *, hours: int) -> None:
    fieldnames = list(rows[0].keys()) if rows else [
        "status", "chatwoot_created_at", "conversation_id", "source_event_id", "email", "content",
        "raw_event_id", "processed", "ignored", "processing_error", "message_id", "communication_id", "opportunity_id", "post_status",
    ]
    with OUT_CSV.open("w", encoding="utf-8", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=fieldnames)
        writer.writeheader()
        writer.writerows(rows)

    with OUT_MD.open("w", encoding="utf-8") as f:
        f.write("# Auditoria remota Chatwoot → ClientFlow\n\n")
        f.write(f"Janela: últimas {hours} horas\n\n")
        f.write("## Resumo\n\n")
        if not counts:
            f.write("- OK: sem gaps inbound encontrados\n")
        for status, total in sorted(counts.items(), key=lambda item: (-item[1], item[0])):
            f.write(f"- {status}: {total}\n")
        f.write("\n## Casos\n\n")
        for row in rows[:300]:
            f.write(f"### {row['status']} · conv #{row['conversation_id']} · msg {row['source_event_id']}\n\n")
            f.write(f"- Data Chatwoot: {row['chatwoot_created_at']}\n")
            f.write(f"- Email: {row['email'] or '-'}\n")
            f.write(f"- Raw event: {row['raw_event_id'] or '-'}\n")
            f.write(f"- Erro: {row['processing_error'] or '-'}\n")
            if row.get("post_status"):
                f.write(f"- Post recovery: {row['post_status']}\n")
            f.write(f"- Excerto: {row['content'] or '-'}\n\n")


def main() -> int:
    parser = argparse.ArgumentParser()
    parser.add_argument("--hours", type=int, default=int(env("CHATWOOT_AUDIT_HOURS", "168")))
    parser.add_argument("--statuses", default=env("CHATWOOT_AUDIT_STATUSES", "open,pending,resolved,snoozed"))
    parser.add_argument("--max-pages", type=int, default=int(env("CHATWOOT_AUDIT_MAX_PAGES", "50")))
    parser.add_argument("--include-ok", action="store_true")
    parser.add_argument("--post-missing", action="store_true", help="Reenvia para /webhooks/chatwoot apenas MISSING_IN_CLIENTFLOW")
    parser.add_argument("--limit", type=int, default=0, help="Limita mensagens a auditar/repostar; 0 = sem limite")
    parser.add_argument("--max-context-messages", type=int, default=5)
    args = parser.parse_args()

    required = {
        "CHATWOOT_BASE_URL": CHATWOOT_BASE_URL,
        "CHATWOOT_ACCOUNT_ID": CHATWOOT_ACCOUNT_ID,
        "CHATWOOT_API_TOKEN": CHATWOOT_API_TOKEN,
    }
    if args.post_missing:
        required["CLIENTFLOW_WEBHOOK_SECRET"] = CLIENTFLOW_WEBHOOK_SECRET
    missing = [k for k, v in required.items() if not v]
    if missing:
        raise SystemExit(f"Faltam variáveis: {', '.join(missing)}")

    statuses = [s.strip() for s in str(args.statuses or "").split(",") if s.strip()]
    cutoff = datetime.now(timezone.utc) - timedelta(hours=int(args.hours))

    print(f"CHATWOOT_AUDIT_HOURS={args.hours}")
    print(f"CHATWOOT_AUDIT_STATUSES={statuses}")
    print(f"CHATWOOT_AUDIT_MAX_PAGES={args.max_pages}")
    print(f"CUTOFF={cutoff.isoformat()}")

    remote_messages = iter_remote_messages(
        statuses=statuses,
        cutoff=cutoff,
        max_pages=int(args.max_pages),
        max_context_messages=max(1, int(args.max_context_messages)),
    )
    if args.limit and args.limit > 0:
        remote_messages = remote_messages[: int(args.limit)]

    ids = [message_id(item.message) for item in remote_messages]
    status_map = load_clientflow_status(ids)

    rows: list[dict[str, Any]] = []
    counts: dict[str, int] = {}
    posted = 0
    failed = 0

    for item in remote_messages:
        msg = item.message
        conv = item.conversation
        mid = message_id(msg)
        cf = status_map.get(mid, {})
        status = classify(cf)

        if status == "OK" and not args.include_ok:
            continue

        post_status = ""
        if args.post_missing and status == "MISSING_IN_CLIENTFLOW":
            result = post_to_clientflow(build_webhook_payload(item))
            if result["ok"]:
                post_status = f"POSTED {result['status']}"
                posted += 1
            else:
                post_status = f"FAILED {result['status']}: {clean(result['raw'], 300)}"
                failed += 1

        counts[status] = counts.get(status, 0) + 1
        sender = sender_from_conversation(conv, msg)
        rows.append({
            "status": status,
            "chatwoot_created_at": dt_to_display(msg.get("created_at")),
            "conversation_id": str(conv.get("id") or msg.get("conversation_id") or ""),
            "source_event_id": mid,
            "email": str(sender.get("email") or ""),
            "content": clean(message_content(msg)),
            "raw_event_id": cf.get("raw_event_id") or "",
            "processed": cf.get("processed") if cf.get("raw_event_id") else "",
            "ignored": cf.get("ignored") if cf.get("raw_event_id") else "",
            "processing_error": cf.get("processing_error") or "",
            "message_id": cf.get("message_id") or cf.get("raw_event_message_id") or "",
            "communication_id": cf.get("communication_id") or "",
            "opportunity_id": cf.get("opportunity_id") or "",
            "post_status": post_status,
        })

    write_reports(rows, counts, hours=int(args.hours))

    print("Auditoria remota Chatwoot inbound concluída.")
    print(f"Mensagens inbound públicas lidas do Chatwoot: {len(remote_messages)}")
    print(f"CSV: {OUT_CSV}")
    print(f"Markdown: {OUT_MD}")
    print("Resumo:")
    if not counts:
        print("OK: sem gaps inbound encontrados")
    for status, total in sorted(counts.items(), key=lambda item: (-item[1], item[0])):
        print(f"{status}: {total}")
    if args.post_missing:
        print(f"posted={posted}")
        print(f"failed={failed}")
    return 0 if failed == 0 else 1


if __name__ == "__main__":
    raise SystemExit(main())