import fs from "node:fs";
import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3";

const HEADERS = {
  Authorization: `Bearer ${process.env.MODA_API_KEY!}`,
  "Moda-Version": "2026-05-01",
};
const s3 = new S3Client({ region: process.env.AWS_REGION });
const BUCKET = process.env.EXPORT_BUCKET!;

async function* listAllCanvases() {
  let cursor: string | null = null;
  for (;;) {
    const u = new URL("https://api.moda.app/v1/canvases");
    u.searchParams.set("limit", "100");
    if (cursor) u.searchParams.set("cursor", cursor);
    const { data, next_cursor } = await fetch(u, { headers: HEADERS }).then(r => r.json());
    for (const c of data) yield c;
    if (!next_cursor) return;
    cursor = next_cursor;
  }
}

async function exportWithRetry(canvasId: string, retries = 3): Promise<string | null> {
  attempts: for (let attempt = 1; attempt <= retries; attempt++) {
    const res = await fetch(
      `https://api.moda.app/v1/canvases/${canvasId}/export?format=pdf`,
      { method: "POST", headers: HEADERS },
    );

    if (res.ok) {
      let exp = await res.json();
      if (exp.status === "in_progress") {                        // slow render; poll it out
        const taskId = exp.task_id;
        for (;;) {
          await new Promise(r => setTimeout(r, (exp.retry_after_seconds ?? 5) * 1000));
          const poll = await fetch(
            `https://api.moda.app/v1/canvases/${canvasId}/export-status?task_id=${taskId}`,
            { headers: HEADERS },
          );
          if (!poll.ok) continue attempts;                       // 429/5xx polling — not an export failure
          exp = await poll.json();
          if (exp.is_terminal !== false) break;                  // terminal, or a shape we don't recognise
        }
      }
      if (exp.status !== "completed") {
        console.error(`Canvas ${canvasId}: export failed`, exp.error, exp.error_code);
        if (exp.retryable) continue;                             // transient — spend another attempt
        return null;                                             // terminal for this canvas's content
      }
      return exp.url;
    }

    if (res.status === 409) {                                    // canvas_active_job
      const wait = Number(res.headers.get("Retry-After") ?? 10) * 1000;
      console.log(`Canvas ${canvasId}: task running; waiting ${wait / 1000}s`);
      await new Promise(r => setTimeout(r, wait));
      continue;
    }

    if (res.status === 429) {                                    // rate limit
      const wait = Number(res.headers.get("Retry-After") ?? 10) * 1000;
      await new Promise(r => setTimeout(r, wait));
      continue;
    }

    const body = await res.json().catch(() => null);
    console.error(`Canvas ${canvasId}: export failed`, body?.error);
    return null;
  }
  return null;
}

for await (const canvas of listAllCanvases()) {
  const exportUrl = await exportWithRetry(canvas.id);
  if (!exportUrl) continue;

  const bytes = Buffer.from(await (await fetch(exportUrl)).arrayBuffer());
  await s3.send(new PutObjectCommand({
    Bucket: BUCKET,
    Key: `canvases/${canvas.id}.pdf`,
    Body: bytes,
    ContentType: "application/pdf",
    Metadata: { "canvas-name": canvas.name, "updated-at": canvas.updated_at },
  }));
  console.log(`Archived ${canvas.name} (${canvas.id})`);
}

import os, time, httpx, boto3

HEADERS = {
    "Authorization": f"Bearer {os.environ['MODA_API_KEY']}",
    "Moda-Version": "2026-05-01",
}
s3 = boto3.client("s3")
BUCKET = os.environ["EXPORT_BUCKET"]

def iter_canvases(c):
    cursor = None
    while True:
        params = {"limit": 100}
        if cursor:
            params["cursor"] = cursor
        resp = c.get("/canvases", params=params).json()
        yield from resp["data"]
        cursor = resp["next_cursor"]
        if cursor is None:
            return

def export_with_retry(c, canvas_id, attempts=3):
    for _ in range(attempts):
        r = c.post(f"/canvases/{canvas_id}/export", params={"format": "pdf"})
        if r.is_success:
            exp = r.json()
            polling_failed = False
            if exp.get("status") == "in_progress":     # slow render; poll it out
                task_id = exp["task_id"]
                while exp.get("is_terminal") is not True:
                    time.sleep(exp.get("retry_after_seconds") or 5)
                    poll = c.get(f"/canvases/{canvas_id}/export-status",
                                 params={"task_id": task_id})
                    if not poll.is_success:            # 429/5xx polling — not an export failure
                        polling_failed = True
                        break
                    exp = poll.json()
            if polling_failed:
                continue                               # re-POST the export (cache-first, so cheap)
            if exp.get("status") != "completed":     # .get: an error envelope has no "status"
                print(f"export failed for {canvas_id}: {exp.get('error')} ({exp.get('error_code')})")
                if exp.get("retryable"):        # transient — spend another attempt
                    continue
                return None                    # terminal for this canvas's content
            return exp["url"]
        if r.status_code in (409, 429):
            wait = int(r.headers.get("Retry-After", 10))
            time.sleep(wait)
            continue
        print(f"export failed for {canvas_id}: {r.json().get('error')}")
        return None
    return None

with httpx.Client(base_url="https://api.moda.app/v1", headers=HEADERS, timeout=120) as c:
    for canvas in iter_canvases(c):
        url = export_with_retry(c, canvas["id"])
        if not url:
            continue
        # download and push to S3
        content = httpx.get(url, timeout=120).content
        s3.put_object(
            Bucket=BUCKET,
            Key=f"canvases/{canvas['id']}.pdf",
            Body=content,
            ContentType="application/pdf",
            Metadata={"canvas-name": canvas["name"], "updated-at": canvas["updated_at"]},
        )
        print(f"Archived {canvas['name']} ({canvas['id']})")

resp = c.get("/canvases/search", params={"q": "Q2 client decks", "limit": 100}).json()
for canvas in resp["canvases"]:
    ...