import { NextResponse } from "next/server";

import { requireSuperAdmin } from "@/lib/authorization";
import { prisma } from "@/lib/prisma";
import { userEmailSignatureSchema } from "@/validators/user-email-signature";

type RouteContext = { params: Promise<{ id: string }> };

const signatureSelect = {
  id: true,
  username: true,
  email: true,
  signature_enabled: true,
  signature_display_name: true,
  signature_job_title: true,
  signature_phone: true,
  signature_company: true,
  signature_address: true,
  signature_website: true,
  signature_logo: true,
} as const;

function parseId(value: string) {
  const id = Number(value);
  return Number.isInteger(id) && id > 0 ? id : null;
}

function responseItem(user: {
  id: number;
  username: string;
  email: string | null;
  signature_enabled: boolean;
  signature_display_name: string | null;
  signature_job_title: string | null;
  signature_phone: string | null;
  signature_company: string | null;
  signature_address: string | null;
  signature_website: string | null;
  signature_logo: string;
}) {
  return {
    userId: user.id,
    username: user.username,
    email: user.email,
    enabled: user.signature_enabled,
    displayName: user.signature_display_name ?? "",
    jobTitle: user.signature_job_title ?? "",
    phone: user.signature_phone ?? "",
    company: user.signature_company ?? "",
    address: user.signature_address ?? "",
    website: user.signature_website ?? "",
    logo: ["ENVIE_2E", "ENVIE_MAGASINS", "NONE"].includes(user.signature_logo)
      ? user.signature_logo
      : "ENVIE_2E",
  };
}

export async function GET(request: Request, { params }: RouteContext) {
  const auth = await requireSuperAdmin(request);
  if (!auth.ok) return auth.response;

  const id = parseId((await params).id);
  if (id === null) {
    return NextResponse.json({ message: "Utilisateur invalide" }, { status: 400 });
  }

  const user = await prisma.auth_users.findUnique({
    where: { id },
    select: signatureSelect,
  });
  if (!user) {
    return NextResponse.json({ message: "Utilisateur introuvable" }, { status: 404 });
  }

  return NextResponse.json({ item: responseItem(user) });
}

export async function PUT(request: Request, { params }: RouteContext) {
  const auth = await requireSuperAdmin(request);
  if (!auth.ok) return auth.response;

  const id = parseId((await params).id);
  if (id === null) {
    return NextResponse.json({ message: "Utilisateur invalide" }, { status: 400 });
  }

  const parsed = userEmailSignatureSchema.safeParse(
    await request.json().catch(() => null),
  );
  if (!parsed.success) {
    return NextResponse.json(
      { message: "Signature invalide", issues: parsed.error.issues },
      { status: 400 },
    );
  }

  const exists = await prisma.auth_users.findUnique({
    where: { id },
    select: { id: true },
  });
  if (!exists) {
    return NextResponse.json({ message: "Utilisateur introuvable" }, { status: 404 });
  }

  const user = await prisma.auth_users.update({
    where: { id },
    data: {
      signature_enabled: parsed.data.enabled,
      signature_display_name: parsed.data.displayName || null,
      signature_job_title: parsed.data.jobTitle || null,
      signature_phone: parsed.data.phone || null,
      signature_company: parsed.data.company || null,
      signature_address: parsed.data.address || null,
      signature_website: parsed.data.website || null,
      signature_logo: parsed.data.logo,
    },
    select: signatureSelect,
  });

  return NextResponse.json({
    message: "La signature e-mail a été enregistrée.",
    item: responseItem(user),
  });
}