// recipe-1-pulse-check.ts
// Streams universal search results for a single topic.
// Run with: SOCIALCRAWL_KEY=sc_... npx tsx recipe-1-pulse-check.ts

const KEY = process.env.SOCIALCRAWL_KEY;
if (!KEY) throw new Error("Set SOCIALCRAWL_KEY");

const url = new URL("https://www.socialcrawl.dev/v1/search/everywhere");
url.searchParams.set("query", "anthropic claude 4");
url.searchParams.set("lookback_days", "7");

const res = await fetch(url, {
  headers: {
    "x-api-key": KEY,
    accept: "text/event-stream",
  },
});

if (!res.ok || !res.body) {
  throw new Error(`Search failed: ${res.status} ${await res.text()}`);
}

const decoder = new TextDecoder();
let buffer = "";

for await (const chunk of res.body) {
  buffer += decoder.decode(chunk as Uint8Array, { stream: true });
  const events = buffer.split("\n\n");
  buffer = events.pop() ?? "";

  for (const event of events) {
    const dataLine = event.split("\n").find((line) => line.startsWith("data: "));
    if (!dataLine) continue;
    const payload = JSON.parse(dataLine.slice(6));

    switch (payload.type) {
      case "plan_refined":
        console.log("plan ready, sub-queries:", payload.plan.subqueries.length);
        break;
      case "clusters":
        console.log(`clustered into ${payload.clusters.length} themes`);
        break;
      case "comments_enriched":
        for (const item of payload.items) {
          const top = item.source_items[0]?.metadata?.top_comments?.[0];
          console.log(`[${item.source}] ${item.title}`);
          if (top) console.log(`  → "${top.text.slice(0, 120)}…"`);
        }
        break;
      case "done":
        console.log(
          `done — ${payload.summary.total_items} results from ${payload.summary.sources_called.length} sources, charged ${payload.summary.credits_used}cr`,
        );
        break;
      case "error":
        console.error("search error:", payload.message);
        break;
    }
  }
}

// One `comments_enriched` SSE chunk — many of these arrive over the stream
{
  "type": "comments_enriched",                  // <-- discriminator
  "items": [
    {
      "candidate_id": "rd_18gha22",
      "source": "reddit",                       // <-- one of the 12 platforms
      "title": "Claude 4 is shockingly good at refactors",
      "url": "https://reddit.com/r/ClaudeAI/comments/...",
      "snippet": "I gave it a 4k-line Rust file and...",
      "final_score": 0.91,                      // <-- RRF + rerank fused
      "cluster_id": "cluster_3",                // <-- groups related posts
      "source_items": [{
        "metadata": {
          "top_comments": [                     // <-- real-people sentiment
            { "text": "Same. Just shipped a migration in 20 min.", "score": 142 }
          ]
        }
      }]
    }
  ]
}

// recipe-2-transcribe.ts
// Returns the transcript of any social video URL.
// Run with: SOCIALCRAWL_KEY=sc_... npx tsx recipe-2-transcribe.ts

const KEY = process.env.SOCIALCRAWL_KEY;
if (!KEY) throw new Error("Set SOCIALCRAWL_KEY");

type Platform =
  | "tiktok"
  | "instagram"
  | "youtube"
  | "facebook"
  | "twitter"
  | "reddit"
  | "rumble";

const ENDPOINT: Record<Platform, string> = {
  tiktok: "tiktok/post/transcript",
  instagram: "instagram/media/transcript",
  youtube: "youtube/video/transcript",
  facebook: "facebook/post/transcript",
  twitter: "twitter/tweet/transcript",
  reddit: "reddit/post/transcript",
  rumble: "rumble/video/transcript",
};

// Adapter that normalises the per-platform shape into a single text string.
// Each branch reflects the upstream's actual response (verified live).
function extractText(platform: Platform, data: Record<string, unknown>): string {
  if (platform === "youtube") {
    return (data.transcript_only_text as string) ?? "";
  }
  if (platform === "tiktok") {
    return (data.transcript as string) ?? "";
  }
  if (platform === "instagram") {
    const t = data.transcripts as Array<{ text?: string }> | undefined;
    return t?.[0]?.text ?? "";
  }
  // Facebook / Twitter / Reddit / Rumble: same upstream-pass-through pattern.
  // Inspect the response on first call and extend this switch as needed.
  return (
    (data.transcript_only_text as string) ??
    (data.transcript as string) ??
    ""
  );
}

async function transcribe(platform: Platform, videoUrl: string) {
  const url = new URL(`https://www.socialcrawl.dev/v1/${ENDPOINT[platform]}`);
  url.searchParams.set("url", videoUrl);

  const res = await fetch(url, { headers: { "x-api-key": KEY! } });
  const json = (await res.json()) as {
    success: boolean;
    data?: Record<string, unknown>;
    credits_remaining: number;
    error?: { message: string };
  };

  if (!json.success) throw new Error(json.error?.message ?? "transcript failed");
  return {
    platform,
    text: extractText(platform, json.data!),
    credits_remaining: json.credits_remaining,
  };
}

// Same input shape, same output shape, three different platforms.
const a = await transcribe(
  "youtube",
  "https://www.youtube.com/watch?v=erLbbextvlY",
);
const b = await transcribe(
  "tiktok",
  "https://www.tiktok.com/@mrbeast/video/7283145247503961371",
);
const c = await transcribe(
  "rumble",
  "https://rumble.com/v5o1eum-the-rubin-report-with-elon-musk.html",
);

for (const t of [a, b, c]) {
  console.log(`[${t.platform}] ${t.text.length} chars`);
  console.log(t.text.slice(0, 200), "…");
  console.log("---");
}

// YouTube — segments + full string + ISO language code
{
  "data": {
    "transcript": [                                                              // <-- array of segments
      { "text": "we are now stranded on this deserted", "startMs": "80", "endMs": "4000", "startTimeText": "0:00" }
      // ... 620 more
    ],
    "transcript_only_text": "we are now stranded on this deserted island...",   // <-- concatenated string
    "language": "en-US"
  }
}

// TikTok — transcript is the string directly
{
  "data": {
    "id": "7647161577057258775",
    "url": "https://www.tiktok.com/@...",
    "transcript": "claude is shockingly good at refactors..."                   // <-- full text as string
  }
}

// Instagram — note the PLURAL key
{
  "data": {
    "transcripts": [                                                             // <-- plural, array
      { "id": "DY7SXBFtEpC", "shortcode": "DY7SXBFtEpC", "text": "..." }
    ]
  }
}

// recipe-3-ad-audit.ts
// Pulls every ad a brand is running across 4 networks in parallel.
// Run with: SOCIALCRAWL_KEY=sc_... npx tsx recipe-3-ad-audit.ts

const KEY = process.env.SOCIALCRAWL_KEY;
if (!KEY) throw new Error("Set SOCIALCRAWL_KEY");

const BASE = "https://www.socialcrawl.dev/v1";
const brand = "stripe";

async function get(path: string, params: Record<string, string>) {
  const url = new URL(`${BASE}/${path}`);
  for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v);
  const res = await fetch(url, { headers: { "x-api-key": KEY! } });
  if (!res.ok) return { success: false, error: await res.text() };
  return (await res.json()) as {
    success: boolean;
    data?: { items?: unknown[] };
    credits_remaining: number;
  };
}

type AdRow = { network: string; ad: unknown };

// Google ad-library searches by domain or advertiser_id — not free-text.
// Brand → domain is the most common shape; map your input accordingly.
const brandDomain = "stripe.com";

const [meta, google, linkedin, reddit] = await Promise.all([
  get("facebook/adlibrary/search/ads", { query: brand }),
  get("google/company/ads", { domain: brandDomain }),
  get("linkedin/ads/search", { query: brand }),
  get("reddit/ads/search", { query: brand }),
]);

const ads: AdRow[] = [
  ...(meta.data?.items ?? []).map((ad) => ({ network: "meta", ad })),
  ...(google.data?.items ?? []).map((ad) => ({ network: "google", ad })),
  ...(linkedin.data?.items ?? []).map((ad) => ({ network: "linkedin", ad })),
  ...(reddit.data?.items ?? []).map((ad) => ({ network: "reddit", ad })),
];

console.log(`${ads.length} ads found for "${brand}"`);
const counts = ads.reduce<Record<string, number>>(
  (acc, row) => ({ ...acc, [row.network]: (acc[row.network] ?? 0) + 1 }),
  {},
);
console.table(counts);

console.log(`credits left: ${reddit.credits_remaining}`);

// Final aggregated shape after the flattening loop:
[
  {
    "network": "meta",
    "ad": {
      "id": "ad_1234567890",
      "page_name": "Stripe",
      "ad_creative_body": "Accept payments online in minutes...",
      "first_active": "2026-05-01",            // <-- normalised from raw upstream
      "active": true
    }
  },
  {
    "network": "linkedin",
    "ad": {
      "id": "ln_987654321",
      "advertiser_name": "Stripe",
      "headline": "Built for fast-growing teams",
      "creative_url": "https://www.linkedin.com/ads/..."
    }
  }
  // ... google + reddit rows mixed in
]

// recipe-4-engagement-table.ts
// Compares one creator's engagement across TikTok, Instagram, and YouTube.
// Run with: SOCIALCRAWL_KEY=sc_... npx tsx recipe-4-engagement-table.ts

const KEY = process.env.SOCIALCRAWL_KEY;
if (!KEY) throw new Error("Set SOCIALCRAWL_KEY");

const BASE = "https://www.socialcrawl.dev/v1";
const handle = "mrbeast";

type Profile = {
  success: boolean;
  platform: string;
  data?: {
    author: { username: string | null; followers: number | null };
    computed: {
      engagement_rate: number | null;
      estimated_reach: number | null;
      language: string | null;
      content_category: string | null;
    };
  };
};

async function get(path: string, params: Record<string, string>): Promise<Profile> {
  const url = new URL(`${BASE}/${path}`);
  for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v);
  const res = await fetch(url, { headers: { "x-api-key": KEY! } });
  return (await res.json()) as Profile;
}

const [tiktok, instagram, youtube] = await Promise.all([
  get("tiktok/profile", { handle }),
  get("instagram/profile", { handle }),
  get("youtube/channel", { handle }),
]);

const rows = [tiktok, instagram, youtube]
  .filter((p) => p.success && p.data)
  .map((p) => ({
    platform: p.platform,
    followers: p.data!.author.followers,
    engagement_rate: p.data!.computed.engagement_rate,
    estimated_reach: p.data!.computed.estimated_reach,
  }))
  .sort(
    (a, b) => (b.engagement_rate ?? 0) - (a.engagement_rate ?? 0),
  );

console.table(rows);

// console.table output:
// ┌─────────┬───────────┬───────────┬─────────────────┬──────────────────┐
// │ (index) │ platform  │ followers │ engagement_rate │ estimated_reach  │
// ├─────────┼───────────┼───────────┼─────────────────┼──────────────────┤
// │    0    │ "tiktok"  │ 95000000  │       1         │     9500000      │ // <-- clamped, see warnings
// │    1    │ "youtube" │ 351000000 │     0.0842      │     2957420      │
// │    2    │ "instagram"│ 64200000 │     0.0413      │      265146      │
// └─────────┴───────────┴───────────┴─────────────────┴──────────────────┘

// recipe-5-music-heat.ts
// Calculates a cross-platform "heat score" for one track.
// Run with: SOCIALCRAWL_KEY=sc_... npx tsx recipe-5-music-heat.ts

const KEY = process.env.SOCIALCRAWL_KEY;
if (!KEY) throw new Error("Set SOCIALCRAWL_KEY");

const BASE = "https://www.socialcrawl.dev/v1";

const tiktokClipId = "7349589214432069122";
const spotifyQuery = "Espresso Sabrina Carpenter";
const soundcloudUrl = "https://soundcloud.com/sabrinacarpenter/espresso";

async function get(path: string, params: Record<string, string>) {
  const url = new URL(`${BASE}/${path}`);
  for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v);
  const res = await fetch(url, { headers: { "x-api-key": KEY! } });
  return (await res.json()) as { success: boolean; data?: Record<string, unknown> };
}

const [tiktok, spotify, soundcloud] = await Promise.all([
  get("tiktok/song/videos", { clipId: tiktokClipId }),
  get("spotify/search", { query: spotifyQuery }),
  get("soundcloud/track", { url: soundcloudUrl }),
]);

// Pull the three signals — every list endpoint returns { items, total? }
const tiktokVideos = (tiktok.data?.total as number | undefined) ?? 0;
const spotifyPlays =
  ((spotify.data?.items as Array<{ post?: { engagement?: { views?: number } } }>)?.[0]
    ?.post?.engagement?.views) ?? 0;
const soundcloudPlays =
  (((soundcloud.data?.post as { engagement?: { views?: number } } | undefined)
    ?.engagement?.views) ?? 0);

// Weighted composite. Tune the weights for your use case.
const heat =
  Math.log10(tiktokVideos + 1) * 0.5 +
  Math.log10(spotifyPlays + 1) * 0.3 +
  Math.log10(soundcloudPlays + 1) * 0.2;

console.log({
  tiktok_videos: tiktokVideos,
  spotify_plays: spotifyPlays,
  soundcloud_plays: soundcloudPlays,
  heat_score: heat.toFixed(2),
});

// Aggregated, post-composite:
{
  "tiktok_videos": 2400000,                    // <-- `data.total` from TikTok song/videos
  "spotify_plays": 1180000000,                 // <-- top track from Spotify search
  "soundcloud_plays": 8200000,                 // <-- track plays on SoundCloud
  "heat_score": "4.91"                         // <-- log-weighted composite
}

// recipe-6-deep-research.ts
// Finds top posts on a topic, fetches their transcripts, returns the corpus.
// Run with: SOCIALCRAWL_KEY=sc_... npx tsx recipe-6-deep-research.ts

const KEY = process.env.SOCIALCRAWL_KEY;
if (!KEY) throw new Error("Set SOCIALCRAWL_KEY");

const BASE = "https://www.socialcrawl.dev/v1";
const topic = "ozempic side effects";
const POSTS_PER_SOURCE = 5;

// ── Step 1: Universal search, sync mode, scoped to TikTok + Instagram ─────
async function search(query: string) {
  const url = new URL(`${BASE}/search/everywhere`);
  url.searchParams.set("query", query);
  url.searchParams.set("sources", "tiktok,instagram");
  url.searchParams.set("lookback_days", "30");

  const res = await fetch(url, {
    headers: { "x-api-key": KEY!, accept: "application/json" },
  });
  const json = (await res.json()) as {
    success: boolean;
    data: { items: Array<{ source: string; url: string; title: string }> };
    credits_used: number;
  };
  if (!json.success) throw new Error("search failed");
  return json.data.items;
}

// ── Step 2: Per-platform transcript fan-out ───────────────────────────────
type Platform = "tiktok" | "instagram";
const TRANSCRIPT_PATH: Record<Platform, string> = {
  tiktok: "tiktok/post/transcript",
  instagram: "instagram/media/transcript",
};

// See Recipe 2 — transcript shapes differ per platform. This adapter
// covers the three verified live; extend for the others as needed.
function extractText(platform: Platform, data: Record<string, unknown>): string {
  if (platform === "tiktok") return (data.transcript as string) ?? "";
  if (platform === "instagram") {
    const t = data.transcripts as Array<{ text?: string }> | undefined;
    return t?.[0]?.text ?? "";
  }
  return (data.transcript_only_text as string) ?? "";
}

async function getTranscript(platform: Platform, postUrl: string) {
  const url = new URL(`${BASE}/${TRANSCRIPT_PATH[platform]}`);
  url.searchParams.set("url", postUrl);
  const res = await fetch(url, { headers: { "x-api-key": KEY! } });
  const json = (await res.json()) as {
    success: boolean;
    data?: Record<string, unknown>;
    error?: { message: string };
  };
  if (!json.success) {
    console.warn(`skipped ${postUrl}: ${json.error?.message}`);
    return null;
  }
  return { text: extractText(platform, json.data!) };
}

// ── Step 3: Pipeline ──────────────────────────────────────────────────────
const items = await search(topic);

const tiktoks = items.filter((i) => i.source === "tiktok").slice(0, POSTS_PER_SOURCE);
const instagrams = items
  .filter((i) => i.source === "instagram")
  .slice(0, POSTS_PER_SOURCE);

const transcripts = await Promise.all([
  ...tiktoks.map(async (item) => ({
    title: item.title,
    url: item.url,
    transcript: await getTranscript("tiktok", item.url),
  })),
  ...instagrams.map(async (item) => ({
    title: item.title,
    url: item.url,
    transcript: await getTranscript("instagram", item.url),
  })),
]);

const corpus = transcripts
  .filter((t) => t.transcript !== null && t.transcript.text.length > 0)
  .map((t) => `# ${t.title}\n${t.url}\n\n${t.transcript!.text}`)
  .join("\n\n---\n\n");

console.log(`corpus length: ${corpus.length} chars`);
console.log(corpus.slice(0, 500), "…");

// The final `corpus` string after Step 3 — markdown-formatted, ready for an LLM:
// # I tried Ozempic for 90 days — here's what happened
// https://www.tiktok.com/@drmike/video/7314...
//
// So I want to talk about what nobody tells you about Ozempic...
//
// ---
//
// # The Ozempic side effect doctors won't mention
// https://www.instagram.com/reel/CzA1234abcd/
//
// Three weeks in I started experiencing what they call...
//
// ---
//
// (8 more transcripts concatenated)