"use server";

import { revalidatePath } from "next/cache";
import { redirect } from "next/navigation";
import { randomBytes } from "crypto";
import { db } from "@/lib/db";
import { hashPassword } from "@/lib/auth";
import { requireOrgModule } from "@/lib/org";
import { ORG_ROLES } from "@/lib/constants";
import { audit } from "@/lib/audit";
import { sendTeamInviteEmail } from "@/lib/email";

async function requireTeamAdmin() {
  const ctx = await requireOrgModule("team");
  if (!["OWNER", "ADMIN"].includes(ctx.role)) throw new Error("Only owners/admins manage the team.");
  return ctx;
}

export async function inviteTeamMember(formData: FormData) {
  const ctx = await requireTeamAdmin();
  const name = String(formData.get("name") ?? "").trim();
  const email = String(formData.get("email") ?? "").trim().toLowerCase();
  const role = String(formData.get("role") ?? "VIEWER");
  if (!name || !email) redirect("/dashboard/team?error=Name and email are required");
  if (!(ORG_ROLES as readonly string[]).includes(role) || role === "OWNER") redirect("/dashboard/team?error=Pick a valid role");

  let user = await db.user.findUnique({ where: { email } });
  let tempPassword: string | null = null;
  if (!user) {
    tempPassword = `cfx-${randomBytes(4).toString("hex")}`;
    user = await db.user.create({
      data: { email, name, passwordHash: await hashPassword(tempPassword), platformRole: "USER" },
    });
  }

  const existing = await db.orgMember.findFirst({ where: { orgId: ctx.org.id, userId: user.id } });
  if (existing) redirect("/dashboard/team?error=Already a team member");

  await db.orgMember.create({ data: { orgId: ctx.org.id, userId: user.id, role } });
  await audit({ userId: ctx.user.id, action: "team.invite", entity: "OrgMember", meta: { email, role } });
  try {
    const { ORG_ROLE_LABELS } = await import("@/lib/constants");
    await sendTeamInviteEmail({ email, name: user.name, orgName: ctx.org.name, roleLabel: ORG_ROLE_LABELS[role] ?? role, tempPassword });
  } catch {}

  const qs = new URLSearchParams({ saved: `${name} added as ${role}` });
  if (tempPassword) { qs.set("tempEmail", email); qs.set("tempPassword", tempPassword); }
  redirect(`/dashboard/team?${qs.toString()}`);
}

export async function updateTeamRole(memberId: string, formData: FormData) {
  const ctx = await requireTeamAdmin();
  const role = String(formData.get("role") ?? "");
  if (!(ORG_ROLES as readonly string[]).includes(role)) return;
  const member = await db.orgMember.findUnique({ where: { id: memberId } });
  if (!member || member.orgId !== ctx.org.id) return;
  if (member.role === "OWNER") return; // ownership transfer is out of scope
  if (role === "OWNER" && ctx.role !== "OWNER") return;
  await db.orgMember.update({ where: { id: memberId }, data: { role } });
  await audit({ userId: ctx.user.id, action: "team.role.update", entity: "OrgMember", entityId: memberId, meta: { role } });
  revalidatePath("/dashboard/team");
}

export async function removeTeamMember(memberId: string, _formData: FormData) {
  const ctx = await requireTeamAdmin();
  const member = await db.orgMember.findUnique({ where: { id: memberId }, include: { user: { select: { email: true } } } });
  if (!member || member.orgId !== ctx.org.id) return;
  if (member.role === "OWNER") return;
  if (member.userId === ctx.user.id) return; // can't remove yourself
  await db.orgMember.delete({ where: { id: memberId } });
  await audit({ userId: ctx.user.id, action: "team.remove", entity: "OrgMember", entityId: memberId, meta: { email: member.user.email } });
  revalidatePath("/dashboard/team");
}
