import type { AssistantAction, BoardVisibility, Prisma } from "@prisma/client";
import { HttpError } from "../../middleware/errorHandler";
import { requireWorkspaceMembership } from "../authz";
import {
  commitDrafts,
  loadExistingCards,
  loadImportContext,
  normalizeName,
  resolveTask,
  type Draft,
  type DraftAttachment,
  type ExistingCard,
  type ImportContext,
  type RawTask,
} from "../boardImport";
import { DEFAULT_STATUSES } from "../boardTemplates";
import { createCommentAndNotify } from "../commentService";
import { logActivity } from "../activity";
import { prisma } from "../prisma";
import { emitToBoard } from "../socketBus";
import { assertBoardWritable, loadScope, loadVisibleCard, type AssistantScope } from "./access";
import { loadOwnFiles, publishAsAttachment } from "./files";

// Proposals ("actions") are the ONLY way the assistant changes anything. A proposal
// stores the raw requested change plus a preview; nothing is written until the user
// presses Confirm, at which point permissions are checked again and the change is
// re-resolved against the CURRENT state of the board/card (so a proposal made a few
// minutes ago can't overwrite edits other people made in between). There is no
// delete/archive action at all.

const PROPOSAL_TTL_MS = 60 * 60 * 1000;
const MAX_TASKS_PER_PROPOSAL = 200;

export type ModelTask = {
  title: string;
  description?: string;
  list?: string;
  status?: string;
  startDate?: string;
  dueDate?: string;
  members?: string[];
  labels?: string[];
  fields?: Record<string, string>;
};

export type ModelUpdate = {
  cardId: string;
  title?: string;
  description?: string;
  list?: string;
  status?: string;
  startDate?: string;
  dueDate?: string;
  addMembers?: string[];
  removeMembers?: string[];
  addLabels?: string[];
  removeLabels?: string[];
  fields?: Record<string, string>;
  completed?: boolean;
  comment?: string;
};

type StoredRawTask = Omit<RawTask, "present"> & { present?: string[] };

function toStored(raw: RawTask): StoredRawTask {
  return { ...raw, present: raw.present ? [...raw.present] : undefined };
}
function fromStored(raw: StoredRawTask): RawTask {
  return { ...raw, present: raw.present ? new Set(raw.present) : undefined };
}

function modelTaskToRaw(task: ModelTask): RawTask {
  return {
    title: String(task.title ?? "").slice(0, 200),
    description: task.description ?? "",
    list: task.list ?? "",
    status: task.status ?? "",
    startDate: task.startDate ?? "",
    dueDate: task.dueDate ?? "",
    members: task.members ?? [],
    labels: task.labels ?? [],
    fields: task.fields ?? {},
  };
}

// ---------- Preview helpers ----------

function draftPreview(ctx: ImportContext, draft: Draft) {
  const fieldById = new Map(ctx.fields.map((f) => [f.id, f]));
  return {
    title: draft.title,
    description: draft.description.slice(0, 400),
    list: ctx.lists.find((l) => l.id === draft.listId)?.name ?? "",
    status: ctx.statuses.find((s) => s.id === draft.statusOptionId)?.label ?? null,
    startDate: draft.startDate,
    dueDate: draft.dueDate,
    members: draft.memberIds.map((id) => ctx.members.find((m) => m.id === id)?.name ?? "Unknown"),
    labels: draft.labelIds.map((id) => ctx.labels.find((l) => l.id === id)).filter(Boolean).map((l) => ({ name: l!.name, color: l!.color })),
    fields: Object.entries(draft.customFields).map(([id, value]) => {
      const f = fieldById.get(id);
      const shown = f?.type === "PERSON" ? ctx.members.find((m) => m.id === value)?.name ?? "" : typeof value === "object" ? (value as { number?: string })?.number ?? "" : String(value);
      return { name: f?.name ?? "", value: f?.type === "CHECKBOX" ? (value ? "Yes" : "No") : shown };
    }),
    warnings: draft.warnings,
  };
}

async function createAction(scope: AssistantScope, conversationId: string, kind: string, payload: unknown, preview: unknown) {
  return prisma.assistantAction.create({
    data: {
      userId: scope.userId,
      conversationId,
      kind,
      payload: payload as Prisma.InputJsonValue,
      preview: preview as Prisma.InputJsonValue,
      expiresAt: new Date(Date.now() + PROPOSAL_TTL_MS),
    },
  });
}

async function filesForAttaching(scope: AssistantScope, allowedFileIds: string[], requested: string[] | undefined) {
  const ids = (requested ?? []).filter((id) => allowedFileIds.includes(id));
  const files = await loadOwnFiles(scope.userId, ids);
  return files.map((f) => ({ id: f.id, filename: f.filename }));
}

// ---------- Propose ----------

export async function proposeCreateTasks(
  scope: AssistantScope,
  conversationId: string,
  args: { boardId: string; tasks: ModelTask[]; attachFileIds?: string[] },
  allowedFileIds: string[]
) {
  await assertBoardWritable(scope, args.boardId);
  if (!Array.isArray(args.tasks) || args.tasks.length === 0) throw new HttpError(400, "No tasks to create");
  if (args.tasks.length > MAX_TASKS_PER_PROPOSAL) throw new HttpError(400, `At most ${MAX_TASKS_PER_PROPOSAL} tasks per proposal`);
  const ctx = await loadImportContext(args.boardId);
  const raws = args.tasks.map(modelTaskToRaw);
  const drafts = raws.map((raw, i) => resolveTask(ctx, raw, { key: `t${i}`, source: `Task ${i + 1}` }));
  const attachments = await filesForAttaching(scope, allowedFileIds, args.attachFileIds);
  const workspace = await prisma.workspace.findUnique({ where: { id: ctx.board.workspaceId }, select: { name: true } });
  const preview = {
    board: { id: ctx.board.id, name: ctx.board.name, workspace: workspace?.name ?? "" },
    tasks: drafts.map((d) => draftPreview(ctx, d)),
    attachments: attachments.map((a) => a.filename),
  };
  return createAction(scope, conversationId, "create_tasks", { boardId: args.boardId, raws: raws.map(toStored), attachFileIds: attachments.map((a) => a.id) }, preview);
}

function memberTokens(ctx: ImportContext, userIds: string[]) {
  return userIds.map((id) => ctx.members.find((m) => m.id === id)?.email).filter((e): e is string => !!e);
}

/** Builds the RawTask for an update against the card's current state. */
function updateToRaw(ctx: ImportContext, card: ExistingCard, u: ModelUpdate): RawTask {
  const present = new Set<string>();
  const raw: RawTask = { present, fields: {} };
  if (u.title !== undefined && u.title.trim()) {
    raw.title = u.title.slice(0, 200);
    present.add("title");
  }
  if (u.description !== undefined) {
    raw.description = u.description;
    present.add("description");
  }
  if (u.list !== undefined && u.list.trim()) {
    raw.list = u.list;
    present.add("list");
  }
  if (u.status !== undefined) {
    raw.status = u.status;
    present.add("status");
  }
  if (u.startDate !== undefined) {
    raw.startDate = u.startDate;
    present.add("start date");
  }
  if (u.dueDate !== undefined) {
    raw.dueDate = u.dueDate;
    present.add("due date");
  }
  if (u.addMembers?.length || u.removeMembers?.length) {
    const current = memberTokens(ctx, card.members.map((m) => m.userId));
    const removeSet = new Set((u.removeMembers ?? []).map((token) => {
      const n = normalizeName(token);
      return ctx.members.find((m) => [m.email, m.username, m.name].some((v) => normalizeName(v) === n))?.email ?? token;
    }).map(normalizeName));
    raw.members = [...current.filter((e) => !removeSet.has(normalizeName(e))), ...(u.addMembers ?? [])];
    present.add("members");
  }
  if (u.addLabels?.length || u.removeLabels?.length) {
    const current = card.labels.map((l) => ctx.labels.find((x) => x.id === l.labelId)?.name).filter((n): n is string => !!n);
    const removeSet = new Set((u.removeLabels ?? []).map(normalizeName));
    raw.labels = [...current.filter((n) => !removeSet.has(normalizeName(n))), ...(u.addLabels ?? [])];
    present.add("labels");
  }
  for (const [name, value] of Object.entries(u.fields ?? {})) raw.fields![name] = value;
  return raw;
}

function describeValue(value: unknown) {
  if (value === null || value === undefined || value === "") return "—";
  if (Array.isArray(value)) return value.length ? value.join(", ") : "—";
  return String(value);
}

export async function proposeUpdateTasks(scope: AssistantScope, conversationId: string, args: { updates: ModelUpdate[] }) {
  if (!Array.isArray(args.updates) || args.updates.length === 0) throw new HttpError(400, "No updates given");
  if (args.updates.length > 100) throw new HttpError(400, "At most 100 cards per proposal");

  const items: { cardId: string; boardId: string; raw: StoredRawTask; completed?: boolean; comment?: string }[] = [];
  const previewItems: unknown[] = [];
  const contexts = new Map<string, ImportContext>();

  for (const u of args.updates) {
    const visible = await loadVisibleCard(scope, u.cardId, { list: { select: { board: { select: { name: true } } } } });
    await assertBoardWritable(scope, visible.boardId);
    if (!contexts.has(visible.boardId)) contexts.set(visible.boardId, await loadImportContext(visible.boardId));
    const ctx = contexts.get(visible.boardId)!;
    const existing = (await loadExistingCards(visible.boardId, [visible.id])).get(visible.id)!;
    const raw = updateToRaw(ctx, existing, u);
    const before = resolveTask(ctx, { present: new Set() }, { key: "b", source: "", existing });
    const after = resolveTask(ctx, raw, { key: "a", source: "", existing });

    const pb = draftPreview(ctx, before);
    const pa = draftPreview(ctx, after);
    const changes: { field: string; from: string; to: string }[] = [];
    const compare = (field: string, from: unknown, to: unknown) => {
      const f = describeValue(from);
      const t = describeValue(to);
      if (f !== t) changes.push({ field, from: f, to: t });
    };
    compare("Title", pb.title, pa.title);
    compare("Description", pb.description, pa.description);
    compare("List", pb.list, pa.list);
    compare("Status", pb.status, pa.status);
    compare("Start date", pb.startDate, pa.startDate);
    compare("Due date", pb.dueDate, pa.dueDate);
    compare("Members", pb.members, pa.members);
    compare("Labels", pb.labels.map((l) => l.name), pa.labels.map((l) => l.name));
    const fieldNames = new Set([...pb.fields.map((f) => f.name), ...pa.fields.map((f) => f.name)]);
    for (const name of fieldNames) {
      compare(name, pb.fields.find((f) => f.name === name)?.value, pa.fields.find((f) => f.name === name)?.value);
    }
    if (u.completed !== undefined && u.completed !== existing.isCompleted) {
      changes.push({ field: "Completed", from: existing.isCompleted ? "Yes" : "No", to: u.completed ? "Yes" : "No" });
    }
    const comment = u.comment?.trim() ? u.comment.trim().slice(0, 5000) : undefined;
    if (changes.length === 0 && !comment) continue;

    items.push({ cardId: visible.id, boardId: visible.boardId, raw: toStored(raw), completed: u.completed, comment });
    previewItems.push({ cardId: visible.id, title: existing.title, board: visible.list.board.name, boardId: visible.boardId, changes, comment: comment ?? null, warnings: after.warnings });
  }
  if (items.length === 0) throw new HttpError(400, "Those updates wouldn't change anything");
  return createAction(scope, conversationId, "update_tasks", { items }, { items: previewItems });
}

const VISIBILITIES: BoardVisibility[] = ["PRIVATE", "WORKSPACE", "PUBLIC"];

export async function proposeCreateBoard(
  scope: AssistantScope,
  conversationId: string,
  args: { workspaceId: string; name: string; lists?: string[]; visibility?: string; tasks?: ModelTask[] }
) {
  await requireWorkspaceMembership(scope.userId, args.workspaceId);
  const workspace = await prisma.workspace.findUnique({
    where: { id: args.workspaceId },
    select: { name: true, organization: { select: { name: true } } },
  });
  if (!workspace) throw new HttpError(404, "Workspace not found");
  const name = String(args.name ?? "").trim().slice(0, 100);
  if (!name) throw new HttpError(400, "The board needs a name");
  const lists = (args.lists?.length ? args.lists : ["To Do", "In Progress", "Done"]).map((l) => String(l).trim().slice(0, 100)).filter(Boolean).slice(0, 15);
  const visibility = VISIBILITIES.includes(args.visibility as BoardVisibility) ? (args.visibility as BoardVisibility) : "WORKSPACE";
  const tasks = (args.tasks ?? []).slice(0, MAX_TASKS_PER_PROPOSAL).map(modelTaskToRaw);
  const preview = {
    workspace: workspace.name,
    organization: workspace.organization.name,
    name,
    lists,
    visibility,
    tasks: tasks.map((t) => ({ title: t.title, list: t.list || lists[0], dueDate: t.dueDate || null })),
  };
  return createAction(scope, conversationId, "create_board", { workspaceId: args.workspaceId, name, lists, visibility, raws: tasks.map(toStored) }, preview);
}

// ---------- Confirm ----------

async function attachmentsFor(userId: string, fileIds: string[]): Promise<DraftAttachment[]> {
  const files = await loadOwnFiles(userId, fileIds);
  const out: DraftAttachment[] = [];
  for (const f of files) out.push(await publishAsAttachment(f));
  return out;
}

async function confirmCreateTasks(scope: AssistantScope, payload: { boardId: string; raws: StoredRawTask[]; attachFileIds: string[] }) {
  await assertBoardWritable(scope, payload.boardId);
  const ctx = await loadImportContext(payload.boardId);
  const attachments = await attachmentsFor(scope.userId, payload.attachFileIds ?? []);
  const drafts = payload.raws.map((r, i) => {
    const d = resolveTask(ctx, fromStored(r), { key: `t${i}`, source: "" });
    return { ...d, attachments };
  });
  const result = await commitDrafts(scope.userId, payload.boardId, drafts, "assistant");
  return { ...result, boardId: payload.boardId, href: `/boards/${payload.boardId}` };
}

async function confirmUpdateTasks(
  scope: AssistantScope,
  payload: { items: { cardId: string; boardId: string; raw: StoredRawTask; completed?: boolean; comment?: string }[] }
) {
  const byBoard = new Map<string, typeof payload.items>();
  for (const item of payload.items) byBoard.set(item.boardId, [...(byBoard.get(item.boardId) ?? []), item]);
  let updated = 0;
  const skipped: string[] = [];
  for (const [boardId, items] of byBoard) {
    await assertBoardWritable(scope, boardId);
    const ctx = await loadImportContext(boardId);
    const existing = await loadExistingCards(boardId, items.map((i) => i.cardId));
    const drafts: Draft[] = [];
    for (const item of items) {
      const card = existing.get(item.cardId);
      if (!card || card.isArchived) {
        skipped.push(`A card in this proposal no longer exists`);
        continue;
      }
      await loadVisibleCard(scope, item.cardId, {});
      drafts.push(resolveTask(ctx, fromStored(item.raw), { key: item.cardId, source: "", existing: card }));
    }
    if (drafts.length) {
      const r = await commitDrafts(scope.userId, boardId, drafts, "assistant");
      updated += r.updated;
      skipped.push(...r.skipped);
    }
    for (const item of items) {
      const card = existing.get(item.cardId);
      if (!card || card.isArchived) continue;
      if (item.completed !== undefined && item.completed !== card.isCompleted) {
        await prisma.card.update({ where: { id: card.id }, data: { isCompleted: item.completed } });
        await logActivity({ boardId, cardId: card.id, actorId: scope.userId, action: "card.assistant_updated", metadata: { isCompleted: item.completed } });
      }
      if (item.comment) {
        await createCommentAndNotify({ card: { id: card.id, boardId, title: card.title }, authorId: scope.userId, bodyHtml: item.comment });
      }
    }
    emitToBoard(boardId, "board:changed", {});
  }
  return { updated, skipped };
}

async function confirmCreateBoard(
  scope: AssistantScope,
  payload: { workspaceId: string; name: string; lists: string[]; visibility: BoardVisibility; raws: StoredRawTask[] }
) {
  await requireWorkspaceMembership(scope.userId, payload.workspaceId);
  const board = await prisma.board.create({
    data: {
      workspaceId: payload.workspaceId,
      name: payload.name,
      visibility: payload.visibility,
      backgroundType: "GRADIENT",
      backgroundValue: "gradient-ocean",
      members: { create: { userId: scope.userId, role: "ADMIN" } },
      statusOptions: { create: DEFAULT_STATUSES.map((s, i) => ({ ...s, position: (i + 1) * 1000 })) },
      lists: { create: payload.lists.map((name, i) => ({ name, position: (i + 1) * 1000 })) },
    },
  });
  let created = 0;
  let skipped: string[] = [];
  if (payload.raws.length) {
    const fresh = await loadScope(scope.userId);
    await assertBoardWritable(fresh, board.id);
    const ctx = await loadImportContext(board.id);
    const drafts = payload.raws.map((r, i) => resolveTask(ctx, fromStored(r), { key: `t${i}`, source: "" }));
    const r = await commitDrafts(scope.userId, board.id, drafts, "assistant");
    created = r.created;
    skipped = r.skipped;
  }
  return { boardId: board.id, href: `/boards/${board.id}`, created, skipped };
}

export async function confirmAction(scope: AssistantScope, actionId: string) {
  // Atomically claim the proposal so a double click can't run it twice.
  const claimed = await prisma.assistantAction.updateMany({
    where: { id: actionId, userId: scope.userId, status: "PENDING", expiresAt: { gt: new Date() } },
    data: { status: "CONFIRMED", resolvedAt: new Date() },
  });
  const action = await prisma.assistantAction.findFirst({ where: { id: actionId, userId: scope.userId } });
  if (!action) throw new HttpError(404, "Proposal not found");
  if (claimed.count === 0) {
    if (action.status === "PENDING") throw new HttpError(410, "This proposal has expired. Ask again to get a fresh one.");
    throw new HttpError(409, `This proposal was already ${action.status.toLowerCase()}`);
  }
  try {
    const payload = action.payload as never;
    const result =
      action.kind === "create_tasks"
        ? await confirmCreateTasks(scope, payload)
        : action.kind === "update_tasks"
          ? await confirmUpdateTasks(scope, payload)
          : action.kind === "create_board"
            ? await confirmCreateBoard(scope, payload)
            : (() => {
                throw new HttpError(400, "Unknown proposal");
              })();
    return prisma.assistantAction.update({ where: { id: action.id }, data: { result: result as Prisma.InputJsonValue } });
  } catch (err) {
    const message = err instanceof HttpError ? err.message : "Something went wrong while applying the change";
    if (!(err instanceof HttpError)) console.error("assistant action failed", err);
    await prisma.assistantAction.update({ where: { id: action.id }, data: { status: "FAILED", result: { error: message } } });
    throw err instanceof HttpError ? err : new HttpError(500, message);
  }
}

export async function cancelAction(userId: string, actionId: string): Promise<AssistantAction> {
  const updated = await prisma.assistantAction.updateMany({
    where: { id: actionId, userId, status: "PENDING" },
    data: { status: "CANCELLED", resolvedAt: new Date() },
  });
  const action = await prisma.assistantAction.findFirst({ where: { id: actionId, userId } });
  if (!action) throw new HttpError(404, "Proposal not found");
  if (updated.count === 0 && action.status !== "CANCELLED") throw new HttpError(409, `This proposal was already ${action.status.toLowerCase()}`);
  return action;
}
