دليل الاستخدام الشامل

import "jsr:@supabase/functions-js/edge-runtime.d.ts";
import { createClient } from "npm:@supabase/supabase-js@2";
import nodemailer from "npm:nodemailer@6";

const corsHeaders = {
  "Access-Control-Allow-Origin": "*",
  "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
  "Access-Control-Allow-Headers":
    "Content-Type, Authorization, X-Client-Info, Apikey",
};

function getSupabaseAdmin() {
  return createClient(
    Deno.env.get("SUPABASE_URL")!,
    Deno.env.get("SUPABASE_SERVICE_ROLE_KEY")!
  );
}

function getRecipientName(email: string): string {
  return email.split("@")[0];
}

function personalizeSubjectText(subject: string, email: string): string {
  return subject + " -" + getRecipientName(email) + "-";
}

function personalizeBodyText(body: string, email: string, prefix: string): string {
  return prefix + " " + email + "\n\n" + body;
}

function personalizeHtmlText(html: string, email: string, prefix: string): string {
  const greeting = '<p style="margin:0 0 12px 0;">' + prefix + " " + email + "</p>";
  if (html.toLowerCase().includes("<body")) {
    return html.replace(/(<body[^>]*>)/i, "$1" + greeting);
  }
  return greeting + html;
}

function addUnsubscribeLink(html: string | undefined, text: string | undefined, url: string): { html?: string; text?: string } {
  const result: { html?: string; text?: string } = {};
  if (html) {
    const unsubHtml = '<div style="margin-top:20px;padding-top:12px;border-top:1px solid #ddd;font-size:12px;color:#888;text-align:center;"><a href="' + url + '" style="color:#888;text-decoration:underline;">Unsubscribe</a></div>';
    if (html.toLowerCase().includes("</body>")) {
      result.html = html.replace(/(<\/body>)/i, unsubHtml + "$1");
    } else {
      result.html = html + unsubHtml;
    }
  }
  if (text) {
    result.text = text + "\n\n---\nUnsubscribe: " + url;
  }
  return result;
}

function sleep(ms: number): Promise<void> {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

function buildAntispamHeaders(unsubscribeUrl?: string): Record<string, string> {
  const headers: Record<string, string> = {
    "Precedence": "bulk",
    "X-Auto-Response-Suppress": "All",
    "Auto-Submitted": "auto-generated",
    "X-Priority": "3",
  };
  if (unsubscribeUrl) {
    headers["List-Unsubscribe"] = "<" + unsubscribeUrl + ">";
    headers["List-Unsubscribe-Post"] = "List-Unsubscribe=One-Click";
  }
  return headers;
}

interface SmtpConfig {
  host: string;
  port: string | number;
  user: string;
  pass: string;
  senderName?: string;
  senderEmail?: string;
}

interface PersonalizeConfig {
  subject?: boolean;
  body?: boolean;
  greetingPrefix?: string;
  randomDelay?: boolean;
  unsubscribe?: boolean;
  unsubscribeUrl?: string;
}

interface EnqueuePayload {
  recipients: string[];
  subject: string;
  body?: string;
  html?: string;
  sendType?: string;
  smtpConfig: SmtpConfig;
  clientToken: string;
  batchSize?: number;
  personalize?: PersonalizeConfig;
}

interface ProcessPayload {
  jobId: string;
  clientToken: string;
}

interface StatusPayload {
  jobId: string;
  clientToken: string;
}

interface CancelPayload {
  jobId: string;
  clientToken: string;
}

async function handleEnqueue(data: EnqueuePayload) {
  const {
    recipients,
    subject,
    body,
    html,
    sendType,
    smtpConfig,
    clientToken,
    batchSize = 50,
    personalize,
  } = data;

  if (
    !smtpConfig ||
    !smtpConfig.host ||
    !smtpConfig.port ||
    !smtpConfig.user ||
    !smtpConfig.pass
  ) {
    return jsonResponse(
      { success: false, error: "SMTP settings missing" },
      400
    );
  }

  if (!recipients || !recipients.length || !subject) {
    return jsonResponse(
      { success: false, error: "Missing recipients or subject" },
      400
    );
  }

  if (!clientToken) {
    return jsonResponse(
      { success: false, error: "Missing client token" },
      400
    );
  }

  const supabase = getSupabaseAdmin();
  const jobId = crypto.randomUUID();

  const batches: string[][] = [];
  for (let i = 0; i < recipients.length; i += batchSize) {
    batches.push(recipients.slice(i, i + batchSize));
  }

  const rows = batches.map((batch, index) => ({
    job_id: jobId,
    client_token: clientToken,
    recipients: batch,
    subject,
    body: body || null,
    html: html || null,
    send_type: sendType || "bcc",
    smtp_config: smtpConfig,
    personalize: personalize || {},
    status: "pending",
    batch_index: index,
    total_batches: batches.length,
  }));

  const { error } = await supabase.from("email_queue").insert(rows);

  if (error) {
    return jsonResponse({ success: false, error: error.message }, 500);
  }

  return jsonResponse({
    success: true,
    jobId,
    totalBatches: batches.length,
    totalRecipients: recipients.length,
    batchSize,
  });
}

async function handleProcess(data: ProcessPayload) {
  const { jobId, clientToken } = data;

  if (!jobId || !clientToken) {
    return jsonResponse(
      { success: false, error: "Missing jobId or clientToken" },
      400
    );
  }

  const supabase = getSupabaseAdmin();

  const { data: batch, error: fetchError } = await supabase
    .from("email_queue")
    .select("*")
    .eq("job_id", jobId)
    .eq("client_token", clientToken)
    .eq("status", "pending")
    .order("batch_index", { ascending: true })
    .limit(1)
    .maybeSingle();

  if (fetchError) {
    return jsonResponse({ success: false, error: fetchError.message }, 500);
  }

  if (!batch) {
    const { data: allBatches } = await supabase
      .from("email_queue")
      .select("status")
      .eq("job_id", jobId)
      .eq("client_token", clientToken);

    const completed =
      allBatches?.filter((b) => b.status === "completed").length || 0;
    const failed =
      allBatches?.filter((b) => b.status === "failed").length || 0;
    const total = allBatches?.length || 0;

    await supabase
      .from("email_queue")
      .update({ smtp_config: {} })
      .eq("job_id", jobId)
      .eq("client_token", clientToken)
      .in("status", ["completed", "failed"]);

    return jsonResponse({
      success: true,
      done: true,
      completed,
      failed,
      total,
    });
  }

  await supabase
    .from("email_queue")
    .update({ status: "processing", updated_at: new Date().toISOString() })
    .eq("id", batch.id);

  try {
    const smtp: SmtpConfig = batch.smtp_config;
    const transporter = nodemailer.createTransport({
      host: smtp.host,
      port: Number(smtp.port),
      secure: Number(smtp.port) === 465,
      auth: { user: smtp.user, pass: smtp.pass },
    });

    const senderName = smtp.senderName || smtp.user;
    const senderEmail = smtp.senderEmail || smtp.user;
    const sender = `"${senderName}" <${senderEmail}>`;

    const p: PersonalizeConfig | undefined = batch.personalize && Object.keys(batch.personalize).length > 0 ? batch.personalize : undefined;
    const needsIndividual = p && (p.subject || p.body || p.unsubscribe);

    if (needsIndividual) {
      let sentCount = 0;
      const errors: string[] = [];

      for (let i = 0; i < batch.recipients.length; i++) {
        const email = batch.recipients[i];
        let mailSubject = batch.subject;
        let mailText = batch.body;
        let mailHtml = batch.html;

        if (p.subject) {
          mailSubject = personalizeSubjectText(mailSubject, email);
        }

        if (p.body && p.greetingPrefix) {
          if (mailHtml) {
            mailHtml = personalizeHtmlText(mailHtml, email, p.greetingPrefix);
          }
          if (mailText) {
            mailText = personalizeBodyText(mailText, email, p.greetingPrefix);
          }
        }

        if (p.unsubscribe && p.unsubscribeUrl) {
          const unsub = addUnsubscribeLink(mailHtml, mailText, p.unsubscribeUrl);
          if (unsub.html) mailHtml = unsub.html;
          if (unsub.text) mailText = unsub.text;
        }

        const unsubUrl = p.unsubscribe && p.unsubscribeUrl ? p.unsubscribeUrl : undefined;
        const mailOptions: Record<string, unknown> = {
          from: sender,
          to: email,
          subject: mailSubject,
          replyTo: senderEmail,
          headers: buildAntispamHeaders(unsubUrl),
        };

        if (mailHtml) {
          mailOptions.html = mailHtml;
          mailOptions.text = mailText || mailHtml.replace(/<[^>]*>/g, "").trim();
        } else {
          mailOptions.text = mailText;
        }

        try {
          await transporter.sendMail(mailOptions);
          sentCount++;
        } catch (err) {
          errors.push(email + ": " + (err as Error).message);
        }

        if (p.randomDelay && i < batch.recipients.length - 1) {
          await sleep(1000 + Math.random() * 2000);
        }
      }

      await supabase
        .from("email_queue")
        .update({
          status: errors.length === 0 ? "completed" : (sentCount > 0 ? "completed" : "failed"),
          error_message: errors.length > 0 ? errors.join("; ") : null,
          smtp_config: {},
          personalize: {},
          processed_at: new Date().toISOString(),
          updated_at: new Date().toISOString(),
        })
        .eq("id", batch.id);

      return jsonResponse({
        success: true,
        done: false,
        batchIndex: batch.batch_index,
        totalBatches: batch.total_batches,
        sentCount: sentCount,
        personalized: true,
      });
    } else {
      const mailOptions: Record<string, unknown> = {
        from: sender,
        subject: batch.subject,
        replyTo: senderEmail,
        headers: buildAntispamHeaders(),
      };

      if (batch.html) {
        mailOptions.html = batch.html;
        mailOptions.text = batch.body || batch.html.replace(/<[^>]*>/g, "").trim();
      } else {
        mailOptions.text = batch.body;
      }

      if (batch.send_type === "bcc") {
        mailOptions.bcc = batch.recipients.join(", ");
      } else {
        mailOptions.to = batch.recipients.join(", ");
      }

      await transporter.sendMail(mailOptions);

      await supabase
        .from("email_queue")
        .update({
          status: "completed",
          smtp_config: {},
          personalize: {},
          processed_at: new Date().toISOString(),
          updated_at: new Date().toISOString(),
        })
        .eq("id", batch.id);

      return jsonResponse({
        success: true,
        done: false,
        batchIndex: batch.batch_index,
        totalBatches: batch.total_batches,
        sentCount: batch.recipients.length,
      });
    }
  } catch (error) {
    await supabase
      .from("email_queue")
      .update({
        status: "failed",
        error_message: (error as Error).message,
        smtp_config: {},
        personalize: {},
        updated_at: new Date().toISOString(),
      })
      .eq("id", batch.id);

    return jsonResponse({
      success: false,
      done: false,
      batchIndex: batch.batch_index,
      error: (error as Error).message,
    });
  }
}

async function handleStatus(data: StatusPayload) {
  const { jobId, clientToken } = data;

  if (!jobId || !clientToken) {
    return jsonResponse(
      { success: false, error: "Missing jobId or clientToken" },
      400
    );
  }

  const supabase = getSupabaseAdmin();

  const { data: batches, error } = await supabase
    .from("email_queue")
    .select(
      "status, batch_index, total_batches, recipients, error_message, processed_at"
    )
    .eq("job_id", jobId)
    .eq("client_token", clientToken)
    .order("batch_index", { ascending: true });

  if (error) {
    return jsonResponse({ success: false, error: error.message }, 500);
  }

  if (!batches || batches.length === 0) {
    return jsonResponse({ success: false, error: "Job not found" }, 404);
  }

  const total = batches.length;
  const completed = batches.filter((b) => b.status === "completed").length;
  const failed = batches.filter((b) => b.status === "failed").length;
  const pending = batches.filter((b) => b.status === "pending").length;
  const processing = batches.filter((b) => b.status === "processing").length;

  const totalRecipients = batches.reduce(
    (sum, b) => sum + (b.recipients?.length || 0),
    0
  );
  const sentRecipients = batches
    .filter((b) => b.status === "completed")
    .reduce((sum, b) => sum + (b.recipients?.length || 0), 0);

  const errors = batches
    .filter((b) => b.status === "failed" && b.error_message)
    .map((b) => ({ batch: b.batch_index, error: b.error_message }));

  return jsonResponse({
    success: true,
    jobId,
    totalBatches: total,
    completed,
    failed,
    pending,
    processing,
    totalRecipients,
    sentRecipients,
    isDone: pending === 0 && processing === 0,
    errors,
  });
}

async function handleCancel(data: CancelPayload) {
  const { jobId, clientToken } = data;

  if (!jobId || !clientToken) {
    return jsonResponse(
      { success: false, error: "Missing jobId or clientToken" },
      400
    );
  }

  const supabase = getSupabaseAdmin();

  const { error } = await supabase
    .from("email_queue")
    .update({
      status: "cancelled",
      smtp_config: {},
      updated_at: new Date().toISOString(),
    })
    .eq("job_id", jobId)
    .eq("client_token", clientToken)
    .eq("status", "pending");

  if (error) {
    return jsonResponse({ success: false, error: error.message }, 500);
  }

  await supabase
    .from("email_queue")
    .update({ smtp_config: {} })
    .eq("job_id", jobId)
    .eq("client_token", clientToken);

  return jsonResponse({ success: true });
}

function jsonResponse(data: Record<string, unknown>, status = 200) {
  return new Response(JSON.stringify(data), {
    status,
    headers: { ...corsHeaders, "Content-Type": "application/json" },
  });
}

Deno.serve(async (req: Request) => {
  if (req.method === "OPTIONS") {
    return new Response(null, { status: 200, headers: corsHeaders });
  }

  try {
    const { action, ...data } = await req.json();

    switch (action) {
      case "enqueue":
        return await handleEnqueue(data as unknown as EnqueuePayload);
      case "process":
        return await handleProcess(data as unknown as ProcessPayload);
      case "status":
        return await handleStatus(data as unknown as StatusPayload);
      case "cancel":
        return await handleCancel(data as unknown as CancelPayload);
      default:
        return jsonResponse({ success: false, error: "Unknown action" }, 400);
    }
  } catch (error) {
    return jsonResponse(
      { success: false, error: (error as Error).message },
      500
    );
  }
});

import "jsr:@supabase/functions-js/edge-runtime.d.ts";
import nodemailer from "npm:nodemailer@6";

const corsHeaders = {
  "Access-Control-Allow-Origin": "*",
  "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
  "Access-Control-Allow-Headers":
    "Content-Type, Authorization, X-Client-Info, Apikey",
};

const MIN_INTERVAL_MS = 60 * 1000;
const lastSentMap = new Map<string, number>();

function getRecipientName(email: string): string {
  return email.split("@")[0];
}

function personalizeSubjectText(subject: string, email: string): string {
  return subject + " -" + getRecipientName(email) + "-";
}

function personalizeBodyText(body: string, email: string, prefix: string): string {
  return prefix + " " + email + "\n\n" + body;
}

function personalizeHtmlText(html: string, email: string, prefix: string): string {
  const greeting = '<p style="margin:0 0 12px 0;">' + prefix + " " + email + "</p>";
  if (html.toLowerCase().includes("<body")) {
    return html.replace(/(<body[^>]*>)/i, "$1" + greeting);
  }
  return greeting + html;
}

function addUnsubscribeLink(html: string | undefined, text: string | undefined, url: string): { html?: string; text?: string } {
  const result: { html?: string; text?: string } = {};
  if (html) {
    const unsubHtml = '<div style="margin-top:20px;padding-top:12px;border-top:1px solid #ddd;font-size:12px;color:#888;text-align:center;"><a href="' + url + '" style="color:#888;text-decoration:underline;">Unsubscribe</a></div>';
    if (html.toLowerCase().includes("</body>")) {
      result.html = html.replace(/(<\/body>)/i, unsubHtml + "$1");
    } else {
      result.html = html + unsubHtml;
    }
  }
  if (text) {
    result.text = text + "\n\n---\nUnsubscribe: " + url;
  }
  return result;
}

function sleep(ms: number): Promise<void> {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

function buildAntispamHeaders(unsubscribeUrl?: string): Record<string, string> {
  const headers: Record<string, string> = {
    "Precedence": "bulk",
    "X-Auto-Response-Suppress": "All",
    "Auto-Submitted": "auto-generated",
    "X-Priority": "3",
  };
  if (unsubscribeUrl) {
    headers["List-Unsubscribe"] = "<" + unsubscribeUrl + ">";
    headers["List-Unsubscribe-Post"] = "List-Unsubscribe=One-Click";
  }
  return headers;
}

interface SmtpConfig {
  host: string;
  port: string | number;
  user: string;
  pass: string;
  senderName?: string;
  senderEmail?: string;
}

interface PersonalizeConfig {
  subject?: boolean;
  body?: boolean;
  greetingPrefix?: string;
  randomDelay?: boolean;
  unsubscribe?: boolean;
  unsubscribeUrl?: string;
}

Deno.serve(async (req: Request) => {
  if (req.method === "OPTIONS") {
    return new Response(null, { status: 200, headers: corsHeaders });
  }

  try {
    const { to, subject, body, html, sendType, smtpConfig, personalize } = await req.json();

    if (!smtpConfig || !smtpConfig.host || !smtpConfig.port || !smtpConfig.user || !smtpConfig.pass) {
      return new Response(
        JSON.stringify({ success: false, error: "SMTP settings are missing. Please configure your SMTP settings first." }),
        { status: 400, headers: { ...corsHeaders, "Content-Type": "application/json" } }
      );
    }

    if (!to || !subject || (!body && !html)) {
      return new Response(
        JSON.stringify({ success: false, error: "Missing required fields: to, subject, body or html" }),
        { status: 400, headers: { ...corsHeaders, "Content-Type": "application/json" } }
      );
    }

    const recipients = Array.isArray(to) ? to : [to];

    const now = Date.now();
    const rateLimited: string[] = [];
    const allowed: string[] = [];

    for (const email of recipients) {
      const lastSent = lastSentMap.get(email);
      if (lastSent && now - lastSent < MIN_INTERVAL_MS) {
        rateLimited.push(email);
      } else {
        allowed.push(email);
      }
    }

    if (allowed.length === 0) {
      return new Response(
        JSON.stringify({
          success: false,
          error: "All recipients are rate-limited. Please wait 60 seconds.",
          rateLimited,
        }),
        { status: 429, headers: { ...corsHeaders, "Content-Type": "application/json" } }
      );
    }

    const transportConfig = {
      host: smtpConfig.host,
      port: Number(smtpConfig.port),
      secure: Number(smtpConfig.port) === 465,
      auth: {
        user: smtpConfig.user,
        pass: smtpConfig.pass,
      },
    };

    const senderName = smtpConfig.senderName || smtpConfig.user;
    const senderEmail = smtpConfig.senderEmail || smtpConfig.user;
    const sender = `"${senderName}" <${senderEmail}>`;

    const transporter = nodemailer.createTransport(transportConfig);

    const p: PersonalizeConfig | undefined = personalize && Object.keys(personalize).length > 0 ? personalize : undefined;
    const needsIndividual = p && (p.subject || p.body || p.unsubscribe);

    if (needsIndividual) {
      let sentCount = 0;
      const errors: string[] = [];

      for (let i = 0; i < allowed.length; i++) {
        const email = allowed[i];
        let mailSubject = subject;
        let mailText = body;
        let mailHtml = html;

        if (p.subject) {
          mailSubject = personalizeSubjectText(mailSubject, email);
        }

        if (p.body && p.greetingPrefix) {
          if (mailHtml) {
            mailHtml = personalizeHtmlText(mailHtml, email, p.greetingPrefix);
          }
          if (mailText) {
            mailText = personalizeBodyText(mailText, email, p.greetingPrefix);
          }
        }

        if (p.unsubscribe && p.unsubscribeUrl) {
          const unsub = addUnsubscribeLink(mailHtml, mailText, p.unsubscribeUrl);
          if (unsub.html) mailHtml = unsub.html;
          if (unsub.text) mailText = unsub.text;
        }

        const unsubUrl = p.unsubscribe && p.unsubscribeUrl ? p.unsubscribeUrl : undefined;
        const mailOptions: Record<string, unknown> = {
          from: sender,
          to: email,
          subject: mailSubject,
          replyTo: senderEmail,
          headers: buildAntispamHeaders(unsubUrl),
        };

        if (mailHtml) {
          mailOptions.html = mailHtml;
          mailOptions.text = mailText || mailHtml.replace(/<[^>]*>/g, "").trim();
        } else {
          mailOptions.text = mailText;
        }

        try {
          await transporter.sendMail(mailOptions);
          sentCount++;
          lastSentMap.set(email, Date.now());
        } catch (err) {
          errors.push(email + ": " + (err as Error).message);
        }

        if (p.randomDelay && i < allowed.length - 1) {
          await sleep(1000 + Math.random() * 2000);
        }
      }

      return new Response(
        JSON.stringify({
          success: sentCount > 0,
          sent: sentCount,
          rateLimited: rateLimited.length,
          rateLimitedEmails: rateLimited,
          personalized: true,
          errors: errors.length > 0 ? errors : undefined,
        }),
        { headers: { ...corsHeaders, "Content-Type": "application/json" } }
      );
    }

    const mailOptions: Record<string, unknown> = {
      from: sender,
      subject: subject,
      replyTo: senderEmail,
      headers: buildAntispamHeaders(),
    };

    if (html) {
      mailOptions.html = html;
      mailOptions.text = body || html.replace(/<[^>]*>/g, "").trim();
    } else {
      mailOptions.text = body;
    }

    if (sendType === "bcc") {
      mailOptions.bcc = allowed.join(", ");
    } else {
      mailOptions.to = allowed.join(", ");
    }

    const info = await transporter.sendMail(mailOptions);

    for (const email of allowed) {
      lastSentMap.set(email, now);
    }

    return new Response(
      JSON.stringify({
        success: true,
        messageId: info.messageId,
        sent: allowed.length,
        rateLimited: rateLimited.length,
        rateLimitedEmails: rateLimited,
      }),
      { headers: { ...corsHeaders, "Content-Type": "application/json" } }
    );
  } catch (error) {
    return new Response(
      JSON.stringify({ success: false, error: (error as Error).message }),
      { status: 500, headers: { ...corsHeaders, "Content-Type": "application/json" } }
    );
  }
});

import "jsr:@supabase/functions-js/edge-runtime.d.ts";
import { createClient } from "npm:@supabase/supabase-js@2";

const corsHeaders = {
  "Access-Control-Allow-Origin": "*",
  "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
  "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Client-Info, Apikey",
};

function getSupabaseAdmin() {
  return createClient(
    Deno.env.get("SUPABASE_URL")!,
    Deno.env.get("SUPABASE_SERVICE_ROLE_KEY")!
  );
}

interface Campaign {
  id?: string;
  client_token: string;
  name: string;
  recipients?: string[];
  messages?: unknown[];
  selected_message_ids?: unknown[];
  send_type?: string;
  batch_size?: number;
  batch_delay?: number;
  smtp_config?: Record<string, unknown>;
  smtp_mode?: string;
  personalize?: Record<string, unknown>;
  status?: string;
  results?: Record<string, unknown>;
}

function jsonResponse(data: Record<string, unknown>, status = 200) {
  return new Response(JSON.stringify(data), {
    status,
    headers: { ...corsHeaders, "Content-Type": "application/json" },
  });
}

async function handleList(clientToken: string) {
  if (!clientToken) return jsonResponse({ success: false, error: "Missing client token" }, 400);
  const supabase = getSupabaseAdmin();
  const { data, error } = await supabase
    .from("campaigns")
    .select("*")
    .eq("client_token", clientToken)
    .order("created_at", { ascending: false });
  if (error) return jsonResponse({ success: false, error: error.message }, 500);
  return jsonResponse({ success: true, campaigns: data || [] });
}

async function handleGet(clientToken: string, campaignId: string) {
  if (!clientToken || !campaignId)
    return jsonResponse({ success: false, error: "Missing client token or campaign id" }, 400);
  const supabase = getSupabaseAdmin();
  const { data, error } = await supabase
    .from("campaigns")
    .select("*")
    .eq("id", campaignId)
    .eq("client_token", clientToken)
    .maybeSingle();
  if (error) return jsonResponse({ success: false, error: error.message }, 500);
  if (!data) return jsonResponse({ success: false, error: "Campaign not found" }, 404);
  return jsonResponse({ success: true, campaign: data });
}

async function handleCreate(campaign: Campaign) {
  if (!campaign.client_token) return jsonResponse({ success: false, error: "Missing client token" }, 400);
  if (!campaign.name) return jsonResponse({ success: false, error: "Missing campaign name" }, 400);
  const supabase = getSupabaseAdmin();
  const insertData: Record<string, unknown> = {
    client_token: campaign.client_token,
    name: campaign.name,
    recipients: campaign.recipients || [],
    messages: campaign.messages || [],
    selected_message_ids: campaign.selected_message_ids || [],
    send_type: campaign.send_type || "bcc",
    batch_size: campaign.batch_size || 50,
    batch_delay: campaign.batch_delay || 3,
    smtp_config: campaign.smtp_config || {},
    smtp_mode: campaign.smtp_mode || "rotation",
    personalize: campaign.personalize || {},
    status: campaign.status || "draft",
    results: campaign.results || {},
  };
  const { data, error } = await supabase
    .from("campaigns")
    .insert(insertData)
    .select()
    .single();
  if (error) return jsonResponse({ success: false, error: error.message }, 500);
  return jsonResponse({ success: true, campaign: data });
}

async function handleUpdate(clientToken: string, campaignId: string, updates: Record<string, unknown>) {
  if (!clientToken || !campaignId)
    return jsonResponse({ success: false, error: "Missing client token or campaign id" }, 400);
  const allowed = [
    "name", "recipients", "messages", "selected_message_ids", "send_type",
    "batch_size", "batch_delay", "smtp_config", "smtp_mode", "personalize",
    "status", "results",
  ];
  const updateData: Record<string, unknown> = { updated_at: new Date().toISOString() };
  for (const key of allowed) {
    if (key in updates) updateData[key] = updates[key];
  }
  const supabase = getSupabaseAdmin();
  const { data, error } = await supabase
    .from("campaigns")
    .update(updateData)
    .eq("id", campaignId)
    .eq("client_token", clientToken)
    .select()
    .maybeSingle();
  if (error) return jsonResponse({ success: false, error: error.message }, 500);
  if (!data) return jsonResponse({ success: false, error: "Campaign not found" }, 404);
  return jsonResponse({ success: true, campaign: data });
}

async function handleDelete(clientToken: string, campaignId: string) {
  if (!clientToken || !campaignId)
    return jsonResponse({ success: false, error: "Missing client token or campaign id" }, 400);
  const supabase = getSupabaseAdmin();
  const { error } = await supabase
    .from("campaigns")
    .delete()
    .eq("id", campaignId)
    .eq("client_token", clientToken);
  if (error) return jsonResponse({ success: false, error: error.message }, 500);
  return jsonResponse({ success: true });
}

Deno.serve(async (req: Request) => {
  if (req.method === "OPTIONS") {
    return new Response(null, { status: 200, headers: corsHeaders });
  }
  try {
    const body = await req.json();
    const { action } = body;
    switch (action) {
      case "list": return await handleList(body.client_token);
      case "get": return await handleGet(body.client_token, body.campaign_id);
      case "create": return await handleCreate(body as Campaign);
      case "update": return await handleUpdate(body.client_token, body.campaign_id, body.updates || {});
      case "delete": return await handleDelete(body.client_token, body.campaign_id);
      default: return jsonResponse({ success: false, error: "Unknown action" }, 400);
    }
  } catch (error) {
    return jsonResponse({ success: false, error: (error as Error).message }, 500);
  }
});