"use server";

import { cookies } from "next/headers";
import { redirect } from "next/navigation";
import {
  clearSession,
  getMailAuthUrlForCurrentRequest,
  getMailEntryUrlForCurrentRequest,
  getSessionUser,
  saveSessionUser,
} from "@/lib/auth";
import {
  createMailboxFolderByEmail,
  createMailboxMessage,
  loginOrCreateUser,
  markMailboxMessagesAsReadByEmail,
  moveMailboxMessagesByEmail,
  provisionMailSetup,
  regenerateMailSetupDkim,
  requestPasswordResetLink,
  refreshMailboxByEmail,
  registerUserWithMailboxSetup,
  resetPasswordByToken,
  saveMailboxCredentialsByEmail,
  toggleMailboxMessageStarByEmail,
  updateMailboxSenderSpamRuleByEmail,
  updateMailboxDisplayNameByEmail,
  updateMailSetupDkimUsageByEmail,
  updateRepresentativePasswordByEmail,
  verifyMailSetup,
} from "@/lib/official-mail";
import {
  deleteManagedMemberByOwnerEmail,
  saveAiAssistSettingsByOwnerEmail,
  updateManagedMemberByOwnerEmail,
} from "@/lib/mail-automation";
import { saveAutoSendSettingsByOwnerEmail } from "@/lib/mail-auto-send";
import { createManagedMemberWithImmediateChargeByOwnerEmail } from "@/lib/mail-member-billing";
import { canManageMailBillingByEmail } from "@/lib/toss-pay";
import {
  MARKETING_VISITOR_COOKIE,
  recordMarketingLifecycleEvent,
} from "@/lib/marketing-analytics";

function normalizeDomain(input: string) {
  return input
    .trim()
    .toLowerCase()
    .replace(/^https?:\/\//, "")
    .replace(/\/$/, "");
}

function normalizeLocalPart(input: string, domain: string) {
  const normalizedValue = input.trim().replace(/\s+/g, "").toLowerCase();

  if (!normalizedValue) {
    return "";
  }

  if (!normalizedValue.includes("@")) {
    return normalizedValue;
  }

  const [candidateLocalPart, candidateDomain] = normalizedValue.split("@");

  if (
    !candidateLocalPart ||
    !candidateDomain ||
    candidateDomain !== normalizeDomain(domain)
  ) {
    throw new Error("invalid-local-part");
  }

  return candidateLocalPart;
}

function extractMailcowDetail(message: string) {
  const [prefix, ...rest] = message.split(":");

  if (!prefix.startsWith("mailcow-") || rest.length === 0) {
    return "";
  }

  return rest.join(":").trim().slice(0, 240);
}

function extractErrorDetail(message: string, prefix: string) {
  if (!message.startsWith(prefix)) {
    return "";
  }

  return message.slice(prefix.length).trim().slice(0, 240);
}

export type RepresentativePasswordActionState = {
  status: "idle" | "success" | "error";
  message: string;
};

export type MailboxDisplayNameActionState = {
  status: "idle" | "success" | "error";
  message: string;
};

function parseUploadIdList(value: FormDataEntryValue | null) {
  return String(value ?? "")
    .split(",")
    .map((item) => Number(item.trim()))
    .filter((item) => Number.isInteger(item) && item > 0);
}

function parseMessageIds(formData: FormData) {
  const rawValue = String(formData.get("messageIds") ?? "").trim();
  const fallbackMessageId = String(
    formData.get("activeMessageId") ?? "",
  ).trim();
  const values = rawValue
    ? rawValue.split(",")
    : fallbackMessageId
      ? [fallbackMessageId]
      : [];

  return [
    ...new Set(
      values
        .map((value) => Number(value))
        .filter((value) => Number.isInteger(value) && value > 0),
    ),
  ];
}

function mailSetupRedirectUrl(query: string, section = "domain") {
  return `/mail?panel=setup&section=${section}${query}`;
}

function mailAutoSendRedirectUrl(query: string) {
  return `/mail?panel=auto-send${query}`;
}

function appendMailboxListContext(params: URLSearchParams, formData: FormData) {
  const page = String(formData.get("page") ?? "").trim();
  const pageSize = String(formData.get("pageSize") ?? "").trim();
  const tab = String(formData.get("tab") ?? "").trim();
  const field = String(formData.get("field") ?? "").trim();
  const query = String(formData.get("q") ?? "").trim();

  if (page) {
    params.set("page", page);
  }

  if (pageSize) {
    params.set("pageSize", pageSize);
  }

  if (tab && tab !== "all") {
    params.set("tab", tab);
  }

  if (query) {
    params.set("q", query);
  }

  if (query && field && field !== "all") {
    params.set("field", field);
  }
}

function appendActiveMessageContext(
  params: URLSearchParams,
  formData: FormData,
) {
  const activeMessageId = String(formData.get("activeMessageId") ?? "").trim();

  if (activeMessageId) {
    params.set("message", activeMessageId);
  }
}

export async function loginAction(formData: FormData) {
  const email = String(formData.get("email") ?? "")
    .trim()
    .toLowerCase();
  const password = String(formData.get("password") ?? "").trim();
  let user;

  if (!email || !password) {
    redirect(await getMailAuthUrlForCurrentRequest("/login?error=required"));
  }

  try {
    user = await loginOrCreateUser({ email, password });
    await saveSessionUser(user);
  } catch (error) {
    if (error instanceof Error && error.message === "invalid-password") {
      redirect(await getMailAuthUrlForCurrentRequest("/login?error=invalid"));
    }

    redirect(await getMailAuthUrlForCurrentRequest("/login?error=system"));
  }

  redirect(await getMailEntryUrlForCurrentRequest(user));
}

export async function signupAction(formData: FormData) {
  const companyName = String(formData.get("companyName") ?? "").trim();
  const domain = normalizeDomain(String(formData.get("domain") ?? ""));
  let localPart = "";
  let user;

  try {
    localPart = normalizeLocalPart(
      String(formData.get("localPart") ?? "owner"),
      domain,
    );
  } catch (error) {
    if (error instanceof Error && error.message === "invalid-local-part") {
      redirect(
        await getMailAuthUrlForCurrentRequest(
          "/signup?error=invalid-local-part",
        ),
      );
    }

    throw error;
  }

  const password = String(formData.get("password") ?? "").trim();
  const passwordConfirm = String(formData.get("passwordConfirm") ?? "").trim();
  const recoveryEmail = String(formData.get("recoveryEmail") ?? "")
    .trim()
    .toLowerCase();
  const recoveryVerificationId = Number(
    formData.get("recoveryVerificationId") ?? 0,
  );
  const recoveryVerificationToken = String(
    formData.get("recoveryVerificationToken") ?? "",
  ).trim();
  const visitorId = (await cookies()).get(MARKETING_VISITOR_COOKIE)?.value ?? null;

  if (!companyName || !domain || !localPart || !password || !passwordConfirm) {
    redirect(await getMailAuthUrlForCurrentRequest("/signup?error=required"));
  }

  if (!recoveryEmail) {
    redirect(
      await getMailAuthUrlForCurrentRequest(
        "/signup?error=recovery-email-required",
      ),
    );
  }

  if (!recoveryVerificationId || !recoveryVerificationToken) {
    redirect(
      await getMailAuthUrlForCurrentRequest(
        "/signup?error=recovery-email-unverified",
      ),
    );
  }

  if (password !== passwordConfirm) {
    redirect(
      await getMailAuthUrlForCurrentRequest("/signup?error=password-mismatch"),
    );
  }

  try {
    user = await registerUserWithMailboxSetup({
      companyName,
      domain,
      localPart,
      password,
      recoveryEmail,
      recoveryVerificationId,
      recoveryVerificationToken,
    });
    await saveSessionUser(user);
    await recordMarketingLifecycleEvent({
      eventType: "signup_completed",
      ownerEmail: user.email,
      visitorId,
    });
  } catch (error) {
    if (error instanceof Error && error.message === "recovery-email-required") {
      redirect(
        await getMailAuthUrlForCurrentRequest(
          "/signup?error=recovery-email-required",
        ),
      );
    }

    if (error instanceof Error && error.message === "recovery-email-invalid") {
      redirect(
        await getMailAuthUrlForCurrentRequest(
          "/signup?error=recovery-email-invalid",
        ),
      );
    }

    if (
      error instanceof Error &&
      error.message === "recovery-email-unverified"
    ) {
      redirect(
        await getMailAuthUrlForCurrentRequest(
          "/signup?error=recovery-email-unverified",
        ),
      );
    }

    if (error instanceof Error && error.message === "recovery-email-expired") {
      redirect(
        await getMailAuthUrlForCurrentRequest(
          "/signup?error=recovery-email-expired",
        ),
      );
    }

    if (error instanceof Error && error.message === "email-exists") {
      redirect(
        await getMailAuthUrlForCurrentRequest("/signup?error=email-exists"),
      );
    }

    if (error instanceof Error && error.message === "domain-taken") {
      redirect(
        await getMailAuthUrlForCurrentRequest("/signup?error=domain-taken"),
      );
    }

    if (error instanceof Error && error.message === "invalid-local-part") {
      redirect(
        await getMailAuthUrlForCurrentRequest(
          "/signup?error=invalid-local-part",
        ),
      );
    }

    if (error instanceof Error && error.message === "mailcow-config-missing") {
      redirect(
        await getMailAuthUrlForCurrentRequest("/signup?error=mail-config"),
      );
    }

    if (error instanceof Error && error.message === "mailcow-config-invalid") {
      redirect(
        await getMailAuthUrlForCurrentRequest("/signup?error=mail-config"),
      );
    }

    if (error instanceof Error && error.message === "mailcow-auth-failed") {
      redirect(
        await getMailAuthUrlForCurrentRequest("/signup?error=mail-auth"),
      );
    }

    if (error instanceof Error && error.message === "mailcow-domain-exists") {
      redirect(
        await getMailAuthUrlForCurrentRequest(
          "/signup?error=mail-domain-exists",
        ),
      );
    }

    if (
      error instanceof Error &&
      (error.message.startsWith("mailcow-provisioning-failed:") ||
        error.message.startsWith("mailcow-request-failed:"))
    ) {
      console.error("Mailcow signup provisioning failed", error);
      const detail = extractMailcowDetail(error.message);
      redirect(
        await getMailAuthUrlForCurrentRequest(
          `/signup?error=mail-setup${detail ? `&details=${encodeURIComponent(detail)}` : ""}`,
        ),
      );
    }

    redirect(await getMailAuthUrlForCurrentRequest("/signup?error=system"));
  }

  redirect(await getMailEntryUrlForCurrentRequest(user));
}

export async function requestPasswordResetAction(formData: FormData) {
  const email = String(formData.get("email") ?? "")
    .trim()
    .toLowerCase();
  const companyName = String(formData.get("companyName") ?? "").trim();

  if (!email || !companyName) {
    redirect(
      await getMailAuthUrlForCurrentRequest("/reset-password?error=required"),
    );
  }

  try {
    const mailAppUrl = new URL(await getMailAuthUrlForCurrentRequest("/login"))
      .origin;
    const result = await requestPasswordResetLink({
      companyName,
      email,
      mailAppUrl,
    });
    redirect(
      await getMailAuthUrlForCurrentRequest(
        `/reset-password?success=link-sent&masked=${encodeURIComponent(result.maskedRecoveryEmail)}`,
      ),
    );
  } catch (error) {
    if (error instanceof Error && error.message === "not-found") {
      redirect(
        await getMailAuthUrlForCurrentRequest(
          "/reset-password?error=not-found",
        ),
      );
    }

    if (error instanceof Error && error.message === "recovery-email-missing") {
      redirect(
        await getMailAuthUrlForCurrentRequest(
          "/reset-password?error=recovery-email-missing",
        ),
      );
    }

    redirect(
      await getMailAuthUrlForCurrentRequest("/reset-password?error=system"),
    );
  }
}

export async function completePasswordResetAction(formData: FormData) {
  const token = String(formData.get("token") ?? "").trim();
  const password = String(formData.get("password") ?? "").trim();
  const passwordConfirm = String(formData.get("passwordConfirm") ?? "").trim();
  const encodedToken = encodeURIComponent(token);

  if (!token || !password || !passwordConfirm) {
    redirect(
      await getMailAuthUrlForCurrentRequest(
        `/reset-password/${encodedToken}?error=required`,
      ),
    );
  }

  if (password !== passwordConfirm) {
    redirect(
      await getMailAuthUrlForCurrentRequest(
        `/reset-password/${encodedToken}?error=password-mismatch`,
      ),
    );
  }

  try {
    await resetPasswordByToken({ token, password });
  } catch (error) {
    if (error instanceof Error && error.message === "invalid-token") {
      redirect(
        await getMailAuthUrlForCurrentRequest(
          `/reset-password/${encodedToken}?error=invalid-token`,
        ),
      );
    }

    if (error instanceof Error && error.message === "used-token") {
      redirect(
        await getMailAuthUrlForCurrentRequest(
          `/reset-password/${encodedToken}?error=used-token`,
        ),
      );
    }

    if (error instanceof Error && error.message === "expired-token") {
      redirect(
        await getMailAuthUrlForCurrentRequest(
          `/reset-password/${encodedToken}?error=expired-token`,
        ),
      );
    }

    redirect(
      await getMailAuthUrlForCurrentRequest(
        `/reset-password/${encodedToken}?error=system`,
      ),
    );
  }

  redirect(
    await getMailAuthUrlForCurrentRequest("/login?success=password-reset"),
  );
}

export async function logoutAction() {
  await clearSession();
  redirect("https://mail.officialsite.kr/login");
}

export async function completeMailSetupAction(formData: FormData) {
  const user = await getSessionUser();

  if (!user) {
    redirect(await getMailAuthUrlForCurrentRequest("/login"));
  }

  const domain = normalizeDomain(String(formData.get("domain") ?? ""));
  const dkimKeySize = formData.get("dkimKeySize") === "1024" ? 1024 : 2048;
  let localPart = "";

  try {
    localPart = normalizeLocalPart(
      String(formData.get("localPart") ?? "owner"),
      domain,
    );
  } catch (error) {
    if (error instanceof Error && error.message === "invalid-local-part") {
      redirect(mailSetupRedirectUrl("&error=invalid-local-part"));
    }

    throw error;
  }

  if (!domain || !localPart) {
    redirect(mailSetupRedirectUrl("&error=domain-required"));
  }

  try {
    const snapshot = await provisionMailSetup(
      user.email,
      domain,
      localPart,
      undefined,
      dkimKeySize,
    );
    await saveSessionUser(snapshot);
  } catch (error) {
    if (error instanceof Error && error.message === "email-exists") {
      redirect(mailSetupRedirectUrl("&error=mailbox-taken"));
    }

    if (error instanceof Error && error.message === "domain-taken") {
      redirect(mailSetupRedirectUrl("&error=domain-taken"));
    }

    if (error instanceof Error && error.message === "invalid-local-part") {
      redirect(mailSetupRedirectUrl("&error=invalid-local-part"));
    }

    if (error instanceof Error && error.message === "mailbox-auth-missing") {
      redirect(
        mailSetupRedirectUrl("&error=security-password-required", "account"),
      );
    }

    if (error instanceof Error && error.message === "mailcow-config-missing") {
      redirect(mailSetupRedirectUrl("&error=mail-config"));
    }

    if (error instanceof Error && error.message === "mailcow-config-invalid") {
      redirect(mailSetupRedirectUrl("&error=mail-config"));
    }

    if (error instanceof Error && error.message === "mailcow-auth-failed") {
      redirect(mailSetupRedirectUrl("&error=mail-auth"));
    }

    if (error instanceof Error && error.message === "mailcow-domain-exists") {
      redirect(mailSetupRedirectUrl("&error=mail-domain-exists"));
    }

    if (
      error instanceof Error &&
      (error.message.startsWith("mailcow-provisioning-failed:") ||
        error.message.startsWith("mailcow-request-failed:"))
    ) {
      console.error("Mailcow provisioning failed", error);
      const detail = extractMailcowDetail(error.message);
      redirect(
        mailSetupRedirectUrl(
          `&error=mail-setup${detail ? `&details=${encodeURIComponent(detail)}` : ""}`,
        ),
      );
    }

    console.error("Mail setup failed", error);
    redirect(mailSetupRedirectUrl("&error=system"));
  }

  redirect(mailSetupRedirectUrl("&success=provisioned"));
}

export async function regenerateMailSetupDkimAction(formData: FormData) {
  const user = await getSessionUser();

  if (!user) {
    redirect(await getMailAuthUrlForCurrentRequest("/login"));
  }

  const dkimKeySize = formData.get("dkimKeySize") === "1024" ? 1024 : 2048;

  try {
    const snapshot = await regenerateMailSetupDkim(user.email, dkimKeySize);
    await saveSessionUser(snapshot);
  } catch (error) {
    if (
      error instanceof Error &&
      (error.message === "mailcow-config-missing" ||
        error.message === "mailcow-config-invalid")
    ) {
      redirect(mailSetupRedirectUrl("&error=mail-config"));
    }

    if (error instanceof Error && error.message === "mailcow-auth-failed") {
      redirect(mailSetupRedirectUrl("&error=mail-auth"));
    }

    if (
      error instanceof Error &&
      (error.message.startsWith("mailcow-provisioning-failed:") ||
        error.message.startsWith("mailcow-request-failed:"))
    ) {
      console.error("Mailcow DKIM regeneration failed", error);
      const detail = extractMailcowDetail(error.message);
      redirect(
        mailSetupRedirectUrl(
          `&error=dkim-regeneration${detail ? `&details=${encodeURIComponent(detail)}` : ""}`,
        ),
      );
    }

    console.error("Mail DKIM regeneration failed", error);
    redirect(mailSetupRedirectUrl("&error=dkim-regeneration"));
  }

  redirect(mailSetupRedirectUrl("&success=dkim-regenerated"));
}

export async function updateMailSetupDkimUsageAction(formData: FormData) {
  const user = await getSessionUser();

  if (!user) {
    redirect(await getMailAuthUrlForCurrentRequest("/login"));
  }

  const dkimEnabled = String(formData.get("dkimEnabled") ?? "") === "1";

  try {
    const snapshot = await updateMailSetupDkimUsageByEmail(
      user.email,
      dkimEnabled,
    );
    await saveSessionUser(snapshot);
  } catch (error) {
    console.error("Mail DKIM usage update failed", error);
    redirect(mailSetupRedirectUrl("&error=dkim-usage"));
  }

  redirect(
    mailSetupRedirectUrl(
      `&success=${dkimEnabled ? "dkim-enabled" : "dkim-disabled"}`,
    ),
  );
}

export async function updateRepresentativePasswordAction(
  _previousState: RepresentativePasswordActionState,
  formData: FormData,
): Promise<RepresentativePasswordActionState> {
  const user = await getSessionUser();

  if (!user) {
    redirect(await getMailAuthUrlForCurrentRequest("/login"));
  }

  const currentPassword = String(formData.get("currentPassword") ?? "").trim();
  const password = String(formData.get("password") ?? "").trim();
  const passwordConfirm = String(formData.get("passwordConfirm") ?? "").trim();

  if (!currentPassword) {
    return {
      status: "error",
      message: "현재 비밀번호를 입력해주세요.",
    };
  }

  if (!password || !passwordConfirm) {
    return {
      status: "error",
      message: "새 비밀번호와 확인 값을 모두 입력해주세요.",
    };
  }

  if (password !== passwordConfirm) {
    return {
      status: "error",
      message: "비밀번호와 확인 값이 서로 다릅니다.",
    };
  }

  try {
    const snapshot = await updateRepresentativePasswordByEmail(
      user.email,
      currentPassword,
      password,
    );
    await saveSessionUser(snapshot);
  } catch (error) {
    if (
      error instanceof Error &&
      error.message === "current-password-invalid"
    ) {
      return {
        status: "error",
        message: "현재 비밀번호가 올바르지 않습니다.",
      };
    }

    if (error instanceof Error && error.message === "mailcow-config-missing") {
      return {
        status: "error",
        message:
          "메일 서버 연결 설정이 누락되어 있습니다. 관리자에게 문의해주세요.",
      };
    }

    if (error instanceof Error && error.message === "mailcow-config-invalid") {
      return {
        status: "error",
        message:
          "메일 서버 연결 설정이 누락되어 있습니다. 관리자에게 문의해주세요.",
      };
    }

    if (error instanceof Error && error.message === "mailcow-auth-failed") {
      return {
        status: "error",
        message: "메일 서버 인증에 실패했습니다. 잠시 후 다시 시도해주세요.",
      };
    }

    if (
      error instanceof Error &&
      (error.message.startsWith("mailcow-provisioning-failed:") ||
        error.message.startsWith("mailcow-request-failed:"))
    ) {
      console.error("Mailcow representative password update failed", error);
      const detail = extractMailcowDetail(error.message);
      return {
        status: "error",
        message: detail
          ? `메일함 설정 반영 중 오류가 발생했습니다. ${detail}`
          : "메일함 설정 반영 중 오류가 발생했습니다. 잠시 후 다시 시도해주세요.",
      };
    }

    return {
      status: "error",
      message:
        "비밀번호 변경 중 오류가 발생했습니다. 잠시 후 다시 시도해주세요.",
    };
  }

  return {
    status: "success",
    message: "대표 메일 비밀번호를 변경했습니다.",
  };
}

export async function verifyMailSetupAction() {
  const user = await getSessionUser();

  if (!user) {
    redirect(await getMailAuthUrlForCurrentRequest("/login"));
  }

  let snapshot;

  try {
    snapshot = await verifyMailSetup(user.email);
    await saveSessionUser(snapshot);
  } catch (error) {
    if (error instanceof Error && error.message === "mailcow-config-missing") {
      redirect(mailSetupRedirectUrl("&error=mail-config"));
    }

    if (error instanceof Error && error.message === "mailcow-config-invalid") {
      redirect(mailSetupRedirectUrl("&error=mail-config"));
    }

    if (error instanceof Error && error.message === "mailcow-auth-failed") {
      redirect(mailSetupRedirectUrl("&error=mail-auth"));
    }

    redirect(mailSetupRedirectUrl("&error=verify-pending"));
  }

  if (!snapshot.mailConfigured) {
    redirect(mailSetupRedirectUrl("&error=verify-pending"));
  }

  redirect(mailSetupRedirectUrl("&success=verified"));
}

export async function saveAiAssistSettingsAction(formData: FormData) {
  const user = await getSessionUser();

  if (!user) {
    redirect(await getMailAuthUrlForCurrentRequest("/login"));
  }

  const enabled = String(formData.get("enabled") ?? "").trim() === "1";
  const notificationEmail = String(formData.get("notificationEmail") ?? "");

  try {
    await saveAiAssistSettingsByOwnerEmail(user.email, {
      enabled,
      notificationEmail,
    });
  } catch (error) {
    if (
      error instanceof Error &&
      error.message === "ai-assist-notification-required"
    ) {
      redirect(
        mailSetupRedirectUrl(
          "&error=ai-assist-notification-required",
          "assistant",
        ),
      );
    }

    if (error instanceof Error && error.message === "ai-assist-invalid-email") {
      redirect(
        mailSetupRedirectUrl("&error=ai-assist-invalid-email", "assistant"),
      );
    }

    if (error instanceof Error && error.message === "ai-assist-plan-required") {
      redirect(
        mailSetupRedirectUrl("&error=ai-assist-plan-required", "assistant"),
      );
    }

    if (
      error instanceof Error &&
      (error.message === "ai-assist-config-missing" ||
        error.message === "mailcow-config-missing" ||
        error.message === "mailcow-config-invalid")
    ) {
      redirect(
        mailSetupRedirectUrl("&error=ai-assist-config-missing", "assistant"),
      );
    }

    if (error instanceof Error && error.message === "mailcow-auth-failed") {
      redirect(mailSetupRedirectUrl("&error=mail-auth", "assistant"));
    }

    if (
      error instanceof Error &&
      (error.message.startsWith("mailcow-provisioning-failed:") ||
        error.message.startsWith("mailcow-request-failed:"))
    ) {
      const detail = extractMailcowDetail(error.message);
      redirect(
        mailSetupRedirectUrl(
          `&error=mail-setup${detail ? `&details=${encodeURIComponent(detail)}` : ""}`,
          "assistant",
        ),
      );
    }

    redirect(mailSetupRedirectUrl("&error=system", "assistant"));
  }

  redirect(
    mailSetupRedirectUrl(
      enabled ? "&success=ai-assist-saved" : "&success=ai-assist-disabled",
      "assistant",
    ),
  );
}

function parseAutoSendPayload(value: FormDataEntryValue | null) {
  const raw = String(value ?? "").trim();

  if (!raw) {
    return [];
  }

  const parsed: unknown = JSON.parse(raw);

  if (!Array.isArray(parsed)) {
    throw new Error("auto-send-invalid-payload");
  }

  return parsed;
}

export async function saveAutoSendSettingsAction(formData: FormData) {
  const user = await getSessionUser();

  if (!user) {
    redirect(await getMailAuthUrlForCurrentRequest("/login"));
  }

  const enabled = String(formData.get("enabled") ?? "").trim() === "1";
  const randomEnabled =
    String(formData.get("randomEnabled") ?? "").trim() === "1";
  const subject = String(formData.get("subject") ?? "");
  const sendIntervalPreset = String(formData.get("sendIntervalPreset") ?? "");
  const sendIntervalMinutes = Number(formData.get("sendIntervalMinutes") ?? "");
  const dailySendLimit = Number(
    formData.get("dailySendLimit") ?? formData.get("maxSendCount") ?? "",
  );
  const sendBatchSize = Number(formData.get("sendBatchSize") ?? "");
  const recipientDuplicateScope = String(
    formData.get("recipientDuplicateScope") ?? "",
  );

  try {
    const recipientsPayload = parseAutoSendPayload(formData.get("recipientsJson"));
    const phrasesPayload = parseAutoSendPayload(formData.get("phrasesJson"));

    await saveAutoSendSettingsByOwnerEmail(user.email, {
      enabled,
      phrases: phrasesPayload.map((item) => {
        const row = item as {
          active?: unknown;
          bodyText?: unknown;
          selected?: unknown;
          subjectText?: unknown;
        };

        return {
          active: row.active !== false,
          bodyText: String(row.bodyText ?? ""),
          selected: row.selected !== false,
          subjectText: String(row.subjectText ?? ""),
        };
      }),
      randomEnabled,
      recipientDuplicateScope,
      recipients: recipientsPayload.map((item) => {
        const row = item as {
          active?: unknown;
          displayName?: unknown;
          email?: unknown;
        };

        return {
          active: row.active !== false,
          displayName: String(row.displayName ?? ""),
          email: String(row.email ?? ""),
        };
      }),
      sendIntervalMinutes,
      sendIntervalPreset,
      dailySendLimit,
      sendBatchSize,
      subject,
    });
  } catch (error) {
    if (error instanceof Error) {
      if (
        error.message === "auto-send-invalid-payload" ||
        error.message === "auto-send-invalid-date"
      ) {
        redirect(mailAutoSendRedirectUrl("&error=auto-send-invalid"));
      }

      if (error.message === "auto-send-invalid-email") {
        redirect(mailAutoSendRedirectUrl("&error=auto-send-invalid-email"));
      }

      if (
        error.message === "auto-send-subject-required" ||
        error.message === "auto-send-recipient-required" ||
        error.message === "auto-send-phrase-required" ||
        error.message === "auto-send-random-phrase-required"
      ) {
        redirect(mailAutoSendRedirectUrl("&error=auto-send-required"));
      }

      if (error.message === "auto-send-plan-required") {
        redirect(mailAutoSendRedirectUrl("&error=auto-send-plan-required"));
      }
    }

    redirect(mailAutoSendRedirectUrl("&error=system"));
  }

  redirect(
    mailAutoSendRedirectUrl(
      enabled ? "&success=auto-send-saved" : "&success=auto-send-disabled",
    ),
  );
}

export async function createManagedMemberAction(formData: FormData) {
  const user = await getSessionUser();

  if (!user) {
    redirect(await getMailAuthUrlForCurrentRequest("/login"));
  }

  if (!(await canManageMailBillingByEmail(user.email))) {
    redirect(
      mailSetupRedirectUrl("&error=member-management-forbidden", "account"),
    );
  }

  const displayName = String(formData.get("displayName") ?? "");
  const localPart = String(formData.get("localPart") ?? "");
  const password = String(formData.get("password") ?? "");
  const passwordConfirm = String(formData.get("passwordConfirm") ?? "");

  if (password.trim() !== passwordConfirm.trim()) {
    redirect(
      mailSetupRedirectUrl("&error=member-password-mismatch", "members"),
    );
  }

  try {
    await createManagedMemberWithImmediateChargeByOwnerEmail(user.email, {
      displayName,
      localPart,
      password,
    });
  } catch (error) {
    if (error instanceof Error && error.message === "member-required") {
      redirect(mailSetupRedirectUrl("&error=member-required", "members"));
    }

    if (error instanceof Error && error.message === "invalid-local-part") {
      redirect(mailSetupRedirectUrl("&error=invalid-local-part", "members"));
    }

    if (error instanceof Error && error.message === "member-mailbox-taken") {
      redirect(mailSetupRedirectUrl("&error=member-mailbox-taken", "members"));
    }

    if (error instanceof Error && error.message === "growth-plan-required") {
      redirect(mailSetupRedirectUrl("&error=member-plan-required", "members"));
    }

    if (
      error instanceof Error &&
      error.message === "billing-profile-inactive"
    ) {
      redirect(
        mailSetupRedirectUrl("&error=member-billing-inactive", "members"),
      );
    }

    if (error instanceof Error && error.message === "member-charge-failed") {
      redirect(mailSetupRedirectUrl("&error=member-charge-failed", "members"));
    }

    if (error instanceof Error && error.message === "member-create-refunded") {
      redirect(
        mailSetupRedirectUrl("&error=member-create-refunded", "members"),
      );
    }

    if (
      error instanceof Error &&
      error.message === "member-charge-refund-failed"
    ) {
      redirect(
        mailSetupRedirectUrl("&error=member-charge-refund-failed", "members"),
      );
    }

    if (error instanceof Error && error.message === "mailcow-auth-failed") {
      redirect(mailSetupRedirectUrl("&error=mail-auth", "members"));
    }

    if (
      error instanceof Error &&
      (error.message.startsWith("mailcow-provisioning-failed:") ||
        error.message.startsWith("mailcow-request-failed:"))
    ) {
      const detail = extractMailcowDetail(error.message);
      redirect(
        mailSetupRedirectUrl(
          `&error=mail-setup${detail ? `&details=${encodeURIComponent(detail)}` : ""}`,
          "members",
        ),
      );
    }

    redirect(mailSetupRedirectUrl("&error=system", "members"));
  }

  redirect(mailSetupRedirectUrl("&success=member-created", "members"));
}

export async function updateManagedMemberAction(formData: FormData) {
  const user = await getSessionUser();

  if (!user) {
    redirect(await getMailAuthUrlForCurrentRequest("/login"));
  }

  if (!(await canManageMailBillingByEmail(user.email))) {
    redirect(
      mailSetupRedirectUrl("&error=member-management-forbidden", "account"),
    );
  }

  const memberId = Number(String(formData.get("memberId") ?? "").trim());
  const displayName = String(formData.get("displayName") ?? "");
  const password = String(formData.get("password") ?? "");
  const passwordConfirm = String(formData.get("passwordConfirm") ?? "");

  if (password.trim() && password.trim() !== passwordConfirm.trim()) {
    redirect(
      mailSetupRedirectUrl("&error=member-password-mismatch", "members"),
    );
  }

  try {
    await updateManagedMemberByOwnerEmail(user.email, {
      displayName,
      memberId,
      password,
    });
  } catch (error) {
    if (error instanceof Error && error.message === "member-required") {
      redirect(mailSetupRedirectUrl("&error=member-required", "members"));
    }

    if (error instanceof Error && error.message === "member-not-found") {
      redirect(mailSetupRedirectUrl("&error=member-not-found", "members"));
    }

    if (error instanceof Error && error.message === "mailbox-auth-missing") {
      redirect(
        mailSetupRedirectUrl("&error=security-password-required", "members"),
      );
    }

    if (error instanceof Error && error.message === "mailcow-auth-failed") {
      redirect(mailSetupRedirectUrl("&error=mail-auth", "members"));
    }

    if (
      error instanceof Error &&
      (error.message.startsWith("mailcow-provisioning-failed:") ||
        error.message.startsWith("mailcow-request-failed:"))
    ) {
      const detail = extractMailcowDetail(error.message);
      redirect(
        mailSetupRedirectUrl(
          `&error=mail-setup${detail ? `&details=${encodeURIComponent(detail)}` : ""}`,
          "members",
        ),
      );
    }

    redirect(mailSetupRedirectUrl("&error=system", "members"));
  }

  redirect(mailSetupRedirectUrl("&success=member-updated", "members"));
}

export async function deleteManagedMemberAction(formData: FormData) {
  const user = await getSessionUser();

  if (!user) {
    redirect(await getMailAuthUrlForCurrentRequest("/login"));
  }

  if (!(await canManageMailBillingByEmail(user.email))) {
    redirect(
      mailSetupRedirectUrl("&error=member-management-forbidden", "account"),
    );
  }

  const memberId = Number(String(formData.get("memberId") ?? "").trim());

  try {
    await deleteManagedMemberByOwnerEmail(user.email, memberId);
  } catch (error) {
    if (error instanceof Error && error.message === "member-not-found") {
      redirect(mailSetupRedirectUrl("&error=member-not-found", "members"));
    }

    if (error instanceof Error && error.message === "mailcow-auth-failed") {
      redirect(mailSetupRedirectUrl("&error=mail-auth", "members"));
    }

    if (
      error instanceof Error &&
      (error.message.startsWith("mailcow-provisioning-failed:") ||
        error.message.startsWith("mailcow-request-failed:"))
    ) {
      const detail = extractMailcowDetail(error.message);
      redirect(
        mailSetupRedirectUrl(
          `&error=mail-setup${detail ? `&details=${encodeURIComponent(detail)}` : ""}`,
          "members",
        ),
      );
    }

    redirect(mailSetupRedirectUrl("&error=system", "members"));
  }

  redirect(mailSetupRedirectUrl("&success=member-deleted", "members"));
}

export async function submitMailboxMessageAction(formData: FormData) {
  const user = await getSessionUser();

  if (!user) {
    redirect(await getMailAuthUrlForCurrentRequest("/login"));
  }

  const to = String(formData.get("to") ?? "");
  const cc = String(formData.get("cc") ?? "");
  const bcc = String(formData.get("bcc") ?? "");
  const subject = String(formData.get("subject") ?? "");
  const body = String(formData.get("body") ?? "");
  const bodyHtml = String(formData.get("bodyHtml") ?? "");
  const sendIndividually =
    String(formData.get("sendIndividually") ?? "") === "1";
  const attachmentUploadIds = parseUploadIdList(
    formData.get("attachmentUploadIds"),
  );
  const attachmentFiles = formData
    .getAll("attachmentFiles")
    .filter((entry): entry is File => entry instanceof File);
  const inlineImageUploadIds = parseUploadIdList(
    formData.get("inlineImageUploadIds"),
  );
  const intent =
    String(formData.get("intent") ?? "send") === "draft" ? "draft" : "send";
  let result;

  try {
    result = await createMailboxMessage(user.email, {
      attachmentUploadIds,
      bcc,
      body,
      bodyHtml,
      cc,
      inlineImageUploadIds,
      intent,
      rawAttachmentFiles: await Promise.all(
        attachmentFiles.map(async (file) => ({
          buffer: Buffer.from(await file.arrayBuffer()),
          contentType: file.type || "application/octet-stream",
          filename: file.name || "attachment",
          sizeBytes: file.size,
        })),
      ),
      sendIndividually,
      subject,
      to,
    });
  } catch (error) {
    if (error instanceof Error && error.message === "compose-required") {
      redirect("/mail?view=compose&error=compose-required");
    }

    if (error instanceof Error && error.message === "invalid-recipient") {
      redirect("/mail?view=compose&error=invalid-recipient");
    }

    if (
      error instanceof Error &&
      (error.message === "mailbox-auth-missing" ||
        error.message === "mailbox-auth-invalid")
    ) {
      redirect("/mail?view=compose&error=mailbox-auth");
    }

    if (error instanceof Error && error.message === "free-send-limit-daily") {
      redirect("/mail?view=compose&error=free-send-limit-daily");
    }

    if (
      error instanceof Error &&
      error.message.startsWith("send-cooldown-active:")
    ) {
      const detail = extractErrorDetail(error.message, "send-cooldown-active:");
      redirect(
        `/mail?view=compose&error=send-cooldown-active${detail ? `&details=${encodeURIComponent(detail)}` : ""}`,
      );
    }

    if (
      error instanceof Error &&
      error.message.startsWith("mailbox-smtp-failed:")
    ) {
      const detail = extractErrorDetail(error.message, "mailbox-smtp-failed:");
      redirect(
        `/mail?view=compose&error=smtp-failed${detail ? `&details=${encodeURIComponent(detail)}` : ""}`,
      );
    }

    if (
      error instanceof Error &&
      error.message.startsWith("mailbox-imap-failed:")
    ) {
      const detail = extractErrorDetail(error.message, "mailbox-imap-failed:");
      redirect(
        `/mail?view=compose&error=imap-failed${detail ? `&details=${encodeURIComponent(detail)}` : ""}`,
      );
    }

    redirect("/mail?view=compose&error=compose-failed");
  }

  const params = new URLSearchParams();
  params.set("folder", result.folder);
  params.set("success", result.success);

  if (result.messageId) {
    params.set("message", String(result.messageId));
  }

  redirect(`/mail?${params.toString()}`);
}

export async function refreshMailboxAction(formData: FormData) {
  const user = await getSessionUser();

  if (!user) {
    redirect(await getMailAuthUrlForCurrentRequest("/login"));
  }

  const folder = String(formData.get("folder") ?? "inbox").trim() || "inbox";
  const message = String(formData.get("message") ?? "").trim();
  const detail = String(formData.get("detail") ?? "").trim();
  const view = String(formData.get("view") ?? "").trim();
  const params = new URLSearchParams();

  params.set("folder", folder);

  if (message) {
    params.set("message", message);
  }

  if (detail) {
    params.set("detail", detail);
  }

  if (view === "compose") {
    params.set("view", "compose");
  }

  appendMailboxListContext(params, formData);

  try {
    await refreshMailboxByEmail(user.email, { folder });
    params.set("success", "refresh");
  } catch (error) {
    if (
      error instanceof Error &&
      (error.message === "mailbox-auth-missing" ||
        error.message === "mailbox-auth-invalid")
    ) {
      params.set("error", "mailbox-auth");
      redirect(`/mail?${params.toString()}`);
    }

    if (
      error instanceof Error &&
      error.message.startsWith("mailbox-imap-failed:")
    ) {
      params.set("error", "refresh-failed");
      const detailMessage = extractErrorDetail(
        error.message,
        "mailbox-imap-failed:",
      );

      if (detailMessage) {
        params.set("details", detailMessage);
      }

      redirect(`/mail?${params.toString()}`);
    }

    params.set("error", "refresh-failed");
  }

  redirect(`/mail?${params.toString()}`);
}

export async function saveMailboxCredentialsAction(formData: FormData) {
  const user = await getSessionUser();

  if (!user) {
    redirect(await getMailAuthUrlForCurrentRequest("/login"));
  }

  const folder = String(formData.get("folder") ?? "inbox").trim() || "inbox";
  const message = String(formData.get("message") ?? "").trim();
  const detail = String(formData.get("detail") ?? "").trim();
  const view = String(formData.get("view") ?? "").trim();
  const mailboxPassword = String(formData.get("mailboxPassword") ?? "");
  const params = new URLSearchParams();

  params.set("folder", folder);

  if (message) {
    params.set("message", message);
  }

  if (detail) {
    params.set("detail", detail);
  }

  if (view === "compose") {
    params.set("view", "compose");
  }

  appendMailboxListContext(params, formData);

  try {
    await saveMailboxCredentialsByEmail(user.email, mailboxPassword, {
      folder,
    });
    params.set("success", "mailbox-connected");
  } catch (error) {
    if (
      error instanceof Error &&
      error.message === "mailbox-password-required"
    ) {
      params.set("error", "mailbox-password-required");
      redirect(`/mail?${params.toString()}`);
    }

    if (
      error instanceof Error &&
      (error.message === "mailbox-auth-missing" ||
        error.message === "mailbox-auth-invalid")
    ) {
      params.set("error", "mailbox-auth");
      redirect(`/mail?${params.toString()}`);
    }

    if (
      error instanceof Error &&
      error.message.startsWith("mailbox-imap-failed:")
    ) {
      params.set("error", "mailbox-connection-failed");
      const detailMessage = extractErrorDetail(
        error.message,
        "mailbox-imap-failed:",
      );

      if (detailMessage) {
        params.set("details", detailMessage);
      }

      redirect(`/mail?${params.toString()}`);
    }

    params.set("error", "mailbox-connection-failed");
  }

  redirect(`/mail?${params.toString()}`);
}

export async function updateMailboxDisplayNameAction(
  _previousState: MailboxDisplayNameActionState,
  formData: FormData,
): Promise<MailboxDisplayNameActionState> {
  const user = await getSessionUser();

  if (!user) {
    redirect(await getMailAuthUrlForCurrentRequest("/login"));
  }

  const displayName = String(formData.get("displayName") ?? "")
    .replace(/\s+/g, " ")
    .trim();

  if (!displayName) {
    return {
      status: "error",
      message: "표시 이름을 입력해주세요.",
    };
  }

  if (displayName.length > 191) {
    return {
      status: "error",
      message: "표시 이름은 191자 이내로 입력해주세요.",
    };
  }

  try {
    const snapshot = await updateMailboxDisplayNameByEmail(user.email, displayName);
    await saveSessionUser(snapshot);
  } catch (error) {
    if (error instanceof Error && error.message === "user-not-found") {
      return {
        status: "error",
        message: "계정 정보를 찾지 못했습니다. 다시 로그인한 뒤 시도해주세요.",
      };
    }

    if (
      error instanceof Error &&
      (error.message === "mailcow-config-missing" ||
        error.message === "mailcow-config-invalid" ||
        error.message === "mailcow-auth-failed")
    ) {
      return {
        status: "error",
        message: "메일 서버 설정을 반영하지 못했습니다. 잠시 후 다시 시도해주세요.",
      };
    }

    if (
      error instanceof Error &&
      (error.message.startsWith("mailcow-provisioning-failed:") ||
        error.message.startsWith("mailcow-request-failed:"))
    ) {
      const detail = extractMailcowDetail(error.message);
      return {
        status: "error",
        message: detail
          ? `메일함 표시 이름을 반영하지 못했습니다. ${detail}`
          : "메일함 표시 이름을 반영하지 못했습니다. 잠시 후 다시 시도해주세요.",
      };
    }

    console.error("Mailbox display name update failed", error);
    return {
      status: "error",
      message: "표시 이름을 변경하지 못했습니다. 잠시 후 다시 시도해주세요.",
    };
  }

  return {
    status: "success",
    message: "표시 이름을 저장했습니다. 이후 보내는 메일부터 적용됩니다.",
  };
}

export async function markMailboxMessagesReadAction(formData: FormData) {
  const user = await getSessionUser();

  if (!user) {
    redirect(await getMailAuthUrlForCurrentRequest("/login"));
  }

  const folder = String(formData.get("folder") ?? "inbox").trim() || "inbox";
  const detail = String(formData.get("detail") ?? "").trim();
  const message = String(formData.get("message") ?? "").trim();
  const readState = String(formData.get("readState") ?? "read")
    .trim()
    .toLowerCase();
  const nextReadState = readState !== "unread";
  const params = new URLSearchParams();
  const messageIds = parseMessageIds(formData);

  params.set("folder", folder);

  if (detail) {
    params.set("detail", detail);
  }

  if (message) {
    params.set("message", message);
  }

  appendMailboxListContext(params, formData);

  if (messageIds.length === 0) {
    redirect(`/mail?${params.toString()}`);
  }

  try {
    await markMailboxMessagesAsReadByEmail(
      user.email,
      messageIds,
      nextReadState,
    );
    params.set("success", nextReadState ? "mark-read" : "mark-unread");
  } catch (error) {
    const detailMessage =
      error instanceof Error ? error.message : "mailbox read action failed";
    params.set("error", "read-failed");
    params.set("details", detailMessage.slice(0, 180));
  }

  redirect(`/mail?${params.toString()}`);
}

export async function toggleMailboxMessageStarAction(formData: FormData) {
  const user = await getSessionUser();

  if (!user) {
    redirect(await getMailAuthUrlForCurrentRequest("/login"));
  }

  const folder = String(formData.get("folder") ?? "inbox").trim() || "inbox";
  const detail = String(formData.get("detail") ?? "").trim();
  const message = String(formData.get("message") ?? "").trim();
  const messageId = Number(String(formData.get("messageId") ?? "").trim());
  const params = new URLSearchParams();

  params.set("folder", folder);

  if (detail) {
    params.set("detail", detail);
  }

  if (message) {
    params.set("message", message);
  }

  appendMailboxListContext(params, formData);

  if (!Number.isInteger(messageId) || messageId <= 0) {
    params.set("error", "star-failed");
    redirect(`/mail?${params.toString()}`);
  }

  try {
    await toggleMailboxMessageStarByEmail(user.email, messageId);
  } catch (error) {
    const detailMessage =
      error instanceof Error ? error.message : "mailbox star action failed";
    params.set("error", "star-failed");
    params.set("details", detailMessage.slice(0, 180));
  }

  redirect(`/mail?${params.toString()}`);
}

export async function moveMailboxMessagesAction(formData: FormData) {
  const user = await getSessionUser();

  if (!user) {
    redirect(await getMailAuthUrlForCurrentRequest("/login"));
  }

  const sourceFolder =
    String(formData.get("folder") ?? "inbox").trim() || "inbox";
  const detail = String(formData.get("detail") ?? "").trim();
  const messageIds = parseMessageIds(formData);
  const requestedTargetFolder = String(
    formData.get("targetFolder") ?? "",
  ).trim();
  const newFolderName = String(formData.get("newFolderName") ?? "").trim();
  const continueMove =
    String(formData.get("continueMove") ?? "").trim() === "1";
  const params = new URLSearchParams();

  if (detail) {
    params.set("detail", detail);
  }

  appendMailboxListContext(params, formData);

  if (messageIds.length === 0) {
    params.set("folder", sourceFolder);
    redirect(`/mail?${params.toString()}`);
  }

  try {
    let targetFolder = requestedTargetFolder;

    if ((!targetFolder || targetFolder === "__new__") && newFolderName) {
      const createdFolder = await createMailboxFolderByEmail(
        user.email,
        newFolderName,
      );
      targetFolder = createdFolder.systemName;
    }

    if (!targetFolder) {
      targetFolder = "trash";
    }

    const moveResult = await moveMailboxMessagesByEmail(
      user.email,
      messageIds,
      targetFolder,
    );
    params.set("folder", continueMove ? sourceFolder : targetFolder);
    params.set(
      "success",
      targetFolder === "spam"
        ? "move-spam"
        : targetFolder === "trash"
          ? moveResult.deletedCount > 0 && moveResult.movedCount > 0
            ? "move-trash-delete"
            : moveResult.deletedCount > 0
              ? "delete-permanent"
              : "move-trash"
          : "move-folder",
    );
  } catch (error) {
    const detailMessage =
      error instanceof Error ? error.message : "mailbox move action failed";
    params.set("folder", sourceFolder);
    if (detailMessage === "sent-folder-only-outbound") {
      params.set("error", "move-sent-only");
    } else if (
      detailMessage === "mailbox-move-failed" ||
      detailMessage === "mailbox-delete-failed" ||
      detailMessage.includes("Duplicate entry")
    ) {
      params.set("error", "move-conflict");
    } else if (detailMessage === "folder-name-required") {
      params.set("error", "folder-name-required");
    } else if (detailMessage === "folder-name-exists") {
      params.set("error", "folder-name-exists");
    } else {
      params.set("error", "move-failed");
    }
  }

  redirect(`/mail?${params.toString()}`);
}

export async function updateMailboxSenderSpamRuleAction(formData: FormData) {
  const user = await getSessionUser();

  if (!user) {
    redirect(await getMailAuthUrlForCurrentRequest("/login"));
  }

  const senderAddress = String(formData.get("senderAddress") ?? "")
    .trim()
    .toLowerCase();
  const sourceFolder =
    String(formData.get("folder") ?? "inbox").trim() || "inbox";
  const detail = String(formData.get("detail") ?? "").trim();
  const mode = String(formData.get("mode") ?? "spam").trim();
  const moveExistingMessages =
    String(formData.get("moveExistingMessages") ?? "").trim() === "1";
  const requestedTargetFolder = String(
    formData.get("targetFolder") ?? "",
  ).trim();
  const newFolderName = String(formData.get("newFolderName") ?? "").trim();
  const params = new URLSearchParams();

  if (detail) {
    params.set("detail", detail);
  }

  appendMailboxListContext(params, formData);
  appendActiveMessageContext(params, formData);

  if (!senderAddress) {
    params.set("folder", sourceFolder);
    params.set("error", "sender-spam-failed");
    redirect(`/mail?${params.toString()}`);
  }

  try {
    let targetFolder = requestedTargetFolder;

    if (
      mode === "unspam" &&
      moveExistingMessages &&
      (!targetFolder || targetFolder === "__new__") &&
      newFolderName
    ) {
      const createdFolder = await createMailboxFolderByEmail(
        user.email,
        newFolderName,
      );
      targetFolder = createdFolder.systemName;
    }

    if (mode === "unspam") {
      await updateMailboxSenderSpamRuleByEmail(user.email, senderAddress, {
        enabled: false,
        moveExistingMessages,
        targetFolder: moveExistingMessages
          ? targetFolder || "inbox"
          : undefined,
      });
      params.set(
        "folder",
        moveExistingMessages ? targetFolder || "inbox" : sourceFolder,
      );
      params.set(
        "success",
        moveExistingMessages ? "sender-unspam-moved" : "sender-unspam",
      );
    } else {
      await updateMailboxSenderSpamRuleByEmail(user.email, senderAddress, {
        enabled: true,
      });
      params.set("folder", "spam");
      params.set("success", "sender-spam");
    }
  } catch (error) {
    const detailMessage =
      error instanceof Error ? error.message : "sender-spam-rule-failed";
    params.set("folder", sourceFolder);

    if (detailMessage === "folder-name-required") {
      params.set("error", "folder-name-required");
    } else if (detailMessage === "sent-folder-only-outbound") {
      params.set("error", "move-sent-only");
    } else {
      params.set("error", "sender-spam-failed");
      params.set("details", detailMessage.slice(0, 180));
    }
  }

  redirect(`/mail?${params.toString()}`);
}