import type { AgentReply } from "./crmAgent";
import { prisma } from "../utils/prisma";
import { ensureDataset } from "../dataset/exporter";
import { createReactAgent } from "@langchain/langgraph/prebuilt";
import { ChatOpenAI } from "@langchain/openai";
import { tool } from "@langchain/core/tools";
import { z } from "zod";

function iso(d: Date) {
  return d.toISOString();
}

async function buildCrmSnapshot(input: { teamId: string }) {
  const now = new Date();
  const in7 = new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000);

  const [contacts, upcoming, deals] = await Promise.all([
    prisma.contact.findMany({
      where: { teamId: input.teamId },
      orderBy: { updatedAt: "desc" },
      take: 25,
      include: {
        messages: { select: { occurredAt: true, channel: true, direction: true }, orderBy: { occurredAt: "desc" }, take: 1 },
        deals: { select: { stage: true, amount: true, updatedAt: true }, orderBy: { updatedAt: "desc" }, take: 1 },
      },
    }),
    prisma.calendarEvent.findMany({
      where: { teamId: input.teamId, startsAt: { gte: now, lte: in7 } },
      orderBy: { startsAt: "asc" },
      take: 20,
      include: { contact: { select: { name: true } } },
    }),
    prisma.deal.findMany({
      where: { teamId: input.teamId },
      orderBy: { updatedAt: "desc" },
      take: 20,
      include: { contact: { select: { name: true, company: true } } },
    }),
  ]);

  const byStage = new Map<string, number>();
  for (const d of deals) byStage.set(d.stage, (byStage.get(d.stage) ?? 0) + 1);

  const lines: string[] = [];
  lines.push(`Snapshot time: ${iso(now)}`);
  lines.push(`Contacts: ${await prisma.contact.count({ where: { teamId: input.teamId } })}`);
  lines.push(`Deals: ${await prisma.deal.count({ where: { teamId: input.teamId } })}`);
  lines.push(`Upcoming events (7d): ${upcoming.length}`);
  lines.push("");

  if (upcoming.length) {
    lines.push("Upcoming events:");
    for (const e of upcoming) {
      lines.push(`- ${e.startsAt.toISOString()} · ${e.title} · ${e.contact?.name ?? "No contact"}`);
    }
    lines.push("");
  }

  if (byStage.size) {
    lines.push("Deals by stage:");
    for (const [stage, n] of [...byStage.entries()].sort((a, b) => b[1] - a[1])) {
      lines.push(`- ${stage}: ${n}`);
    }
    lines.push("");
  }

  if (contacts.length) {
    lines.push("Recently updated contacts:");
    for (const c of contacts.slice(0, 12)) {
      const last = c.messages[0]?.occurredAt ? c.messages[0].occurredAt.toISOString() : c.updatedAt.toISOString();
      const deal = c.deals[0] ? `${c.deals[0].stage}${c.deals[0].amount ? ` $${c.deals[0].amount}` : ""}` : "no deal";
      lines.push(`- ${c.name}${c.company ? ` (${c.company})` : ""} · last touch ${last} · ${deal}`);
    }
  }

  return lines.join("\n");
}

export async function runLangGraphCrmAgentFor(input: {
  teamId: string;
  userId: string;
  userText: string;
}): Promise<AgentReply> {
  if (!process.env.OPENAI_API_KEY) {
    return {
      text: "OPENAI_API_KEY не задан. Сейчас включен fallback-агент без LLM.",
      plan: ["Проверить .env", "Добавить OPENAI_API_KEY", "Перезапустить dev-сервер"],
      tools: [],
    };
  }

  // Keep the dataset fresh so the "CRM filesystem" stays in sync with DB.
  await ensureDataset({ teamId: input.teamId, userId: input.userId });

  const toolsUsed: string[] = [];
  const dbWrites: Array<{ kind: string; detail: string }> = [];

  const CrmToolSchema = z.object({
    action: z.enum([
      "query_contacts",
      "query_deals",
      "query_events",
      "update_contact_note",
      "create_event",
      "create_message",
      "update_deal_stage",
    ]),
    // queries
    query: z.string().optional(),
    stage: z.string().optional(),
    from: z.string().optional(),
    to: z.string().optional(),
    limit: z.number().int().optional(),
    // writes
    contact: z.string().optional(),
    content: z.string().optional(),
    title: z.string().optional(),
    start: z.string().optional(),
    end: z.string().optional(),
    note: z.string().optional(),
    status: z.string().optional(),
    channel: z.enum(["Telegram", "WhatsApp", "Instagram", "Phone", "Email"]).optional(),
    kind: z.enum(["message", "call"]).optional(),
    direction: z.enum(["in", "out"]).optional(),
    text: z.string().optional(),
    at: z.string().optional(),
    durationSec: z.number().int().optional(),
    transcript: z.array(z.string()).optional(),
    dealId: z.string().optional(),
  });

  const crmTool = tool(
    async (raw: z.infer<typeof CrmToolSchema>) => {
      toolsUsed.push(`crm:${raw.action}`);

      if (raw.action === "query_contacts") {
        const q = (raw.query ?? "").trim();
        const items = await prisma.contact.findMany({
          where: {
            teamId: input.teamId,
            ...(q
              ? {
                  OR: [
                    { name: { contains: q } },
                    { company: { contains: q } },
                    { email: { contains: q } },
                    { phone: { contains: q } },
                  ],
                }
              : {}),
          },
          orderBy: { updatedAt: "desc" },
          take: Math.max(1, Math.min(raw.limit ?? 20, 100)),
          include: { note: { select: { content: true, updatedAt: true } } },
        });
        return JSON.stringify(
          items.map((c) => ({
            id: c.id,
            name: c.name,
            company: c.company,
            country: c.country,
            location: c.location,
            email: c.email,
            phone: c.phone,
            note: c.note?.content ?? null,
          })),
          null,
          2,
        );
      }

      if (raw.action === "query_deals") {
        const items = await prisma.deal.findMany({
          where: { teamId: input.teamId, ...(raw.stage ? { stage: raw.stage } : {}) },
          orderBy: { updatedAt: "desc" },
          take: Math.max(1, Math.min(raw.limit ?? 20, 100)),
          include: { contact: { select: { name: true, company: true } } },
        });
        return JSON.stringify(
          items.map((d) => ({
            id: d.id,
            title: d.title,
            stage: d.stage,
            amount: d.amount,
            nextStep: d.nextStep,
            summary: d.summary,
            contact: d.contact.name,
            company: d.contact.company,
          })),
          null,
          2,
        );
      }

      if (raw.action === "query_events") {
        const from = raw.from ? new Date(raw.from) : new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
        const to = raw.to ? new Date(raw.to) : new Date(Date.now() + 60 * 24 * 60 * 60 * 1000);
        const items = await prisma.calendarEvent.findMany({
          where: { teamId: input.teamId, startsAt: { gte: from, lte: to } },
          orderBy: { startsAt: "asc" },
          take: Math.max(1, Math.min(raw.limit ?? 100, 500)),
          include: { contact: { select: { name: true } } },
        });
        return JSON.stringify(
          items.map((e) => ({
            id: e.id,
            title: e.title,
            startsAt: e.startsAt.toISOString(),
            endsAt: (e.endsAt ?? e.startsAt).toISOString(),
            note: e.note,
            contact: e.contact?.name ?? null,
          })),
          null,
          2,
        );
      }

      if (raw.action === "update_contact_note") {
        const contactName = (raw.contact ?? "").trim();
        const content = (raw.content ?? "").trim();
        if (!contactName) throw new Error("contact is required");
        if (!content) throw new Error("content is required");

        const contact = await prisma.contact.findFirst({
          where: { teamId: input.teamId, name: contactName },
          select: { id: true },
        });
        if (!contact) throw new Error("contact not found");

        await prisma.contactNote.upsert({
          where: { contactId: contact.id },
          update: { content },
          create: { contactId: contact.id, content },
        });
        dbWrites.push({ kind: "contact_note", detail: `${contactName}: updated` });
        return JSON.stringify({ ok: true });
      }

      if (raw.action === "create_event") {
        const title = (raw.title ?? "").trim();
        const start = raw.start ? new Date(raw.start) : null;
        if (!title) throw new Error("title is required");
        if (!start || Number.isNaN(start.getTime())) throw new Error("start is invalid");

        const end = raw.end ? new Date(raw.end) : null;
        const contactName = (raw.contact ?? "").trim();
        const contact = contactName
          ? await prisma.contact.findFirst({ where: { teamId: input.teamId, name: contactName }, select: { id: true } })
          : null;

        const created = await prisma.calendarEvent.create({
          data: {
            teamId: input.teamId,
            contactId: contact?.id ?? null,
            title,
            startsAt: start,
            endsAt: end && !Number.isNaN(end.getTime()) ? end : null,
            note: (raw.note ?? "").trim() || null,
            status: (raw.status ?? "").trim() || null,
          },
        });
        dbWrites.push({ kind: "calendar_event", detail: `created ${created.id}` });
        return JSON.stringify({ ok: true, id: created.id });
      }

      if (raw.action === "create_message") {
        const contactName = (raw.contact ?? "").trim();
        const text = (raw.text ?? "").trim();
        if (!contactName) throw new Error("contact is required");
        if (!text) throw new Error("text is required");

        const contact = await prisma.contact.findFirst({
          where: { teamId: input.teamId, name: contactName },
          select: { id: true },
        });
        if (!contact) throw new Error("contact not found");

        const occurredAt = raw.at ? new Date(raw.at) : new Date();
        if (Number.isNaN(occurredAt.getTime())) throw new Error("at is invalid");

        const created = await prisma.contactMessage.create({
          data: {
            contactId: contact.id,
            kind: raw.kind === "call" ? "CALL" : "MESSAGE",
            direction: raw.direction === "in" ? "IN" : "OUT",
            channel:
              raw.channel === "Telegram"
                ? "TELEGRAM"
                : raw.channel === "WhatsApp"
                  ? "WHATSAPP"
                  : raw.channel === "Instagram"
                    ? "INSTAGRAM"
                    : raw.channel === "Email"
                      ? "EMAIL"
                      : "PHONE",
            content: text,
            durationSec: typeof raw.durationSec === "number" ? raw.durationSec : null,
            transcriptJson: Array.isArray(raw.transcript) ? raw.transcript : null,
            occurredAt,
          },
        });
        dbWrites.push({ kind: "contact_message", detail: `created ${created.id}` });
        return JSON.stringify({ ok: true, id: created.id });
      }

      if (raw.action === "update_deal_stage") {
        const dealId = (raw.dealId ?? "").trim();
        const stage = (raw.stage ?? "").trim();
        if (!dealId) throw new Error("dealId is required");
        if (!stage) throw new Error("stage is required");

        const updated = await prisma.deal.updateMany({
          where: { id: dealId, teamId: input.teamId },
          data: { stage },
        });
        if (updated.count === 0) throw new Error("deal not found");
        dbWrites.push({ kind: "deal", detail: `updated stage for ${dealId}` });
        return JSON.stringify({ ok: true });
      }

      return JSON.stringify({ ok: false, error: "unknown action" });
    },
    {
      name: "crm",
      description:
        "Query and update CRM data (contacts, deals, events, communications). Use this tool for any data you need beyond the snapshot.",
      schema: CrmToolSchema,
    },
  );

  const snapshot = await buildCrmSnapshot({ teamId: input.teamId });

  const model = new ChatOpenAI({
    apiKey: process.env.OPENAI_API_KEY,
    model: process.env.OPENAI_MODEL || "gpt-4o-mini",
    temperature: 0.2,
  });

  const agent = createReactAgent({
    llm: model,
    tools: [crmTool],
    responseFormat: z.object({
      answer: z.string().describe("Final assistant answer for the user."),
      plan: z.array(z.string()).min(1).max(10).describe("Short plan (3-8 steps)."),
    }),
  });

  const system = [
    "You are Pilot, a CRM assistant.",
    "Rules:",
    "- Be concrete and concise.",
    "- If you need data beyond the snapshot, call the crm tool.",
    "- If user asks to change CRM, you may do it via the crm tool and then report what changed.",
    "- Do not claim you sent an external message; you can only create draft messages/events/notes in CRM.",
    "",
    "CRM Snapshot:",
    snapshot,
  ].join("\n");

  const res: any = await agent.invoke(
    {
      messages: [
        { role: "system", content: system },
        { role: "user", content: input.userText },
      ],
    },
    { recursionLimit: 30 },
  );

  const structured = res?.structuredResponse as { answer?: string; plan?: string[] } | undefined;
  const text = structured?.answer?.trim() || "Готово.";
  const plan = Array.isArray(structured?.plan) ? structured!.plan : ["Собрать данные", "Сформировать ответ"];

  return { text, plan, tools: toolsUsed, dbWrites: dbWrites.length ? dbWrites : undefined };
}