type EmailPayload = {
  to?: string;
  subject: string;
  text: string;
};

export type EmailResult =
  | { status: "skipped"; reason: string }
  | { status: "sent"; provider: string }
  | { status: "failed"; provider: string; reason: string };

function emailProvider() {
  return process.env.EMAIL_PROVIDER?.trim().toLowerCase() || "disabled";
}

function emailFrom() {
  return process.env.EMAIL_FROM?.trim() || "";
}

function notificationRecipient() {
  return process.env.EMAIL_ADMIN_RECIPIENT?.trim() || emailFrom();
}

function providerConfigured(provider: string) {
  if (provider === "disabled" || provider === "none") return false;
  if (provider === "smtp") {
    return Boolean(process.env.SMTP_HOST?.trim() && process.env.SMTP_USER?.trim() && process.env.SMTP_PASSWORD?.trim() && emailFrom());
  }
  if (provider === "resend") {
    return Boolean(process.env.RESEND_API_KEY?.trim() && emailFrom());
  }
  if (provider === "sendgrid") {
    return Boolean(process.env.SENDGRID_API_KEY?.trim() && emailFrom());
  }
  return false;
}

async function sendWithResend(payload: Required<EmailPayload>, from: string): Promise<EmailResult> {
  const response = await fetch("https://api.resend.com/emails", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.RESEND_API_KEY?.trim()}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      from,
      to: payload.to,
      subject: payload.subject,
      text: payload.text
    })
  });

  if (!response.ok) return { status: "failed", provider: "resend", reason: "Email provider request failed." };
  return { status: "sent", provider: "resend" };
}

async function sendWithSendGrid(payload: Required<EmailPayload>, from: string): Promise<EmailResult> {
  const response = await fetch("https://api.sendgrid.com/v3/mail/send", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.SENDGRID_API_KEY?.trim()}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      personalizations: [{ to: [{ email: payload.to }] }],
      from: { email: from },
      subject: payload.subject,
      content: [{ type: "text/plain", value: payload.text }]
    })
  });

  if (!response.ok) return { status: "failed", provider: "sendgrid", reason: "Email provider request failed." };
  return { status: "sent", provider: "sendgrid" };
}

export async function sendEmail(payload: EmailPayload): Promise<EmailResult> {
  const provider = emailProvider();
  const to = payload.to?.trim();
  const from = emailFrom();

  if (!to) return { status: "skipped", reason: "No recipient configured." };
  if (!providerConfigured(provider)) return { status: "skipped", reason: "Email provider is not configured." };

  const safePayload = { ...payload, to };
  try {
    if (provider === "resend") return await sendWithResend(safePayload, from);
    if (provider === "sendgrid") return await sendWithSendGrid(safePayload, from);
  } catch {
    return { status: "failed", provider, reason: "Email provider request failed." };
  }

  // SMTP is documented for future production use, but this project has no SMTP dependency yet.
  console.info(`Email notification skipped: provider "${provider}" adapter is not implemented yet.`);
  return { status: "skipped", reason: "Email provider adapter is not implemented yet." };
}

export async function notifyAdmin(event: string, details: string[]) {
  const recipient = notificationRecipient();
  try {
    return await sendEmail({
      to: recipient,
      subject: `ELIT admin notification: ${event}`,
      text: [`${event} requires admin review.`, "", ...details].join("\n")
    });
  } catch {
    console.warn(`Email notification failed safely for event "${event}".`);
    return { status: "failed", provider: emailProvider(), reason: "Email notification failed safely." } satisfies EmailResult;
  }
}