import { Router } from "express";
import { z } from "zod";
import { requireAuth, requireCapability } from "../../middleware/auth";
import {
  isWhatsappConfigured,
  getState,
  getQrCode,
  logout,
  findChats,
  findMessages,
  sendText,
} from "../../lib/evolution";

export const whatsappRouter = Router();
whatsappRouter.use(requireAuth);

function jidName(jid: string): string {
  if (!jid) return "";
  return jid.replace(/@.*/, "");
}

function normalizeChat(c: Record<string, unknown>) {
  const jid = (c.remoteJid ?? c.id ?? c.jid ?? "") as string;
  const name = (c.pushName ?? c.name ?? c.subject ?? "") as string;
  return {
    jid,
    name: name || jidName(jid),
    isGroup: jid.endsWith("@g.us"),
    unread: Number(c.unreadCount ?? 0) || 0,
    updatedAt: (c.updatedAt ?? c.lastMessageTimestamp ?? null) as string | number | null,
  };
}

function extractText(message: Record<string, unknown> | undefined): string {
  if (!message) return "";
  if (typeof message.conversation === "string") return message.conversation;
  const ext = message.extendedTextMessage as { text?: string } | undefined;
  if (ext?.text) return ext.text;
  const img = message.imageMessage as { caption?: string } | undefined;
  if (img) return img.caption ? `🖼️ ${img.caption}` : "🖼️ Image";
  if (message.videoMessage) return "🎬 Vidéo";
  if (message.audioMessage) return "🎵 Audio";
  if (message.documentMessage) return "📎 Document";
  if (message.stickerMessage) return "🇸 Sticker";
  return "";
}

function normalizeMessage(m: Record<string, unknown>) {
  const key = (m.key ?? {}) as { id?: string; fromMe?: boolean; remoteJid?: string };
  const ts = (m.messageTimestamp ?? m.createdAt ?? 0) as number | string;
  const tsNum = typeof ts === "string" ? Date.parse(ts) / 1000 : Number(ts);
  return {
    id: key.id ?? "",
    fromMe: Boolean(key.fromMe),
    text: extractText(m.message as Record<string, unknown> | undefined),
    timestamp: Number.isFinite(tsNum) ? tsNum : 0,
  };
}

// État de la connexion WhatsApp.
whatsappRouter.get("/status", async (_req, res) => {
  if (!isWhatsappConfigured()) return res.json({ configured: false, connected: false, state: "off" });
  const st = await getState();
  res.json({ configured: true, ...st });
});

// QR pour lier le numéro (Super Admin uniquement).
whatsappRouter.post("/connect", requireCapability("config:manage"), async (_req, res) => {
  if (!isWhatsappConfigured()) return res.status(503).json({ error: "WhatsApp non configuré" });
  try {
    const qr = await getQrCode();
    res.json(qr);
  } catch (e) {
    console.error("WhatsApp connect:", e);
    res.status(502).json({ error: "Erreur lors de la génération du QR" });
  }
});

whatsappRouter.delete("/logout", requireCapability("config:manage"), async (_req, res) => {
  await logout();
  res.json({ ok: true });
});

// Liste des conversations.
whatsappRouter.get("/chats", requireCapability("whatsapp:read"), async (_req, res) => {
  try {
    const chats = await findChats();
    const normalized = (chats as Record<string, unknown>[]).map(normalizeChat).filter((c) => c.jid);
    res.json({ chats: normalized });
  } catch (e) {
    console.error("WhatsApp chats:", e);
    res.status(502).json({ error: "Impossible de charger les conversations" });
  }
});

// Messages d'une conversation.
whatsappRouter.get("/messages", requireCapability("whatsapp:read"), async (req, res) => {
  const jid = String(req.query.jid ?? "");
  if (!jid) return res.status(400).json({ error: "jid requis" });
  try {
    const msgs = await findMessages(jid);
    const normalized = (msgs as Record<string, unknown>[])
      .map(normalizeMessage)
      .filter((m) => m.text || m.id)
      .sort((a, b) => a.timestamp - b.timestamp);
    res.json({ messages: normalized });
  } catch (e) {
    console.error("WhatsApp messages:", e);
    res.status(502).json({ error: "Impossible de charger les messages" });
  }
});

// Envoi d'un message (admin/super_admin).
const sendSchema = z.object({ number: z.string().min(1), text: z.string().min(1) });
whatsappRouter.post("/send", requireCapability("whatsapp:write"), async (req, res) => {
  const parsed = sendSchema.safeParse(req.body);
  if (!parsed.success) return res.status(400).json({ error: "Numéro et texte requis" });
  try {
    await sendText(parsed.data.number, parsed.data.text);
    res.json({ ok: true });
  } catch (e) {
    console.error("WhatsApp send:", e);
    res.status(502).json({ error: "Échec de l'envoi" });
  }
});