export async function publishForm(formId: string) {
  const form = await getForm(formId);

  await supabaseAdmin
    .from("forms")
    .update({
      published_schema: form.draft_schema,
      last_published_at: new Date().toISOString(),
      published_version: form.published_version + 1,
      status: "published",
    })
    .eq("id", formId);

  // Create version snapshot
  await recordFormVersionSnapshot(formId, form.draft_schema);
}

// Set scheduled publish time
await formsRepository.schedulePublish(formId, new Date("2025-02-01T00:00:00Z"));

async function processScheduledPublishes(): Promise<number> {
  const result = await formsRepository.getFormsDueForPublish();

  for (const form of result.data) {
    await supabaseAdmin
      .from("forms")
      .update({
        status: "published",
        published_schema: form.schema,
      })
      .eq("id", form.id);

    logger.info("Auto-published form", { formId: form.id });
  }

  return result.data.length;
}

// Set scheduled close time (deadline)
await formsRepository.scheduleClose(formId, new Date("2025-03-31T23:59:59Z"));

async function processScheduledCloses(): Promise<number> {
  const result = await formsRepository.getFormsDueForClose();

  for (const form of result.data) {
    await supabaseAdmin
      .from("forms")
      .update({ status: "closed" })
      .eq("id", form.id);

    logger.info("Auto-closed form", { formId: form.id });
  }

  return result.data.length;
}

interface Form {
  frozen: boolean;
  frozen_at: string | null;
  frozen_reason: string | null;
}

async function processAutoFreeze(): Promise<number> {
  // Find published, non-frozen forms with submissions
  const { data: forms } = await supabaseAdmin
    .from("forms")
    .select("id, title")
    .eq("status", "published")
    .eq("frozen", false);

  for (const form of forms) {
    const { count } = await supabaseAdmin
      .from("submissions")
      .select("*", { count: "exact", head: true })
      .eq("form_id", form.id);

    if (count > 0) {
      await supabaseAdmin
        .from("forms")
        .update({
          frozen: true,
          frozen_at: new Date().toISOString(),
          frozen_reason: "First submission received",
        })
        .eq("id", form.id);
    }
  }
}

// Freeze a form
await formsRepository.freeze(formId, "Locked for audit");

// Unfreeze (be careful!)
await formsRepository.unfreeze(formId);

/f/rental-assistance?preview=draft

function getEffectiveFormStatus(
  status: "draft" | "published" | "closed",
  publishedAt: string | null,
  closesAt: string | null
): "draft" | "published" | "closed" {
  const now = new Date();

  // If closed, stay closed
  if (status === "closed") return "closed";

  // If draft and published_at hasn't passed, still draft
  if (status === "draft") {
    if (publishedAt && new Date(publishedAt) <= now) {
      return "published";  // Scheduled publish time has passed
    }
    return "draft";
  }

  // If published, check if closes_at has passed
  if (closesAt && new Date(closesAt) <= now) {
    return "closed";
  }

  return "published";
}