Ads

export function winningCampaign(faker: Faker) {
  const exhausted = makeCampaign(faker, {
    precedence: "over_plan",
    priority: 10,
    servesBudget: 100,
    delivered: 100,
  });
  const open = makeCampaign(faker, { precedence: "over_plan", priority: 1 });

  hasCampaignBudget(exhausted); // => false
  hasCampaignBudget(open); // => true: null budget never runs out

  // The exhausted campaign is skipped despite its higher priority.
  return pickCampaign([exhausted, open], "over_plan", { teachingMode: "auction" });
  // => open
}

const rules: AdsSponsorshipRules = {
  match: "any",
  rules: [{ kind: "teaching-mode", modes: ["petit-bridge"] }],
};

evaluateAdsSponsorshipRules(rules, { teachingMode: "petit-bridge" }); // => true
evaluateAdsSponsorshipRules(rules, { teachingMode: null }); // => false: no known mode
evaluateAdsSponsorshipRules({ match: "any", rules: [] }, { teachingMode: null }); // => false

validateAdsSponsorshipRules({ match: "all", rules: [{ kind: "always" }] });
// => { ok: true, value: { match: "all", rules: [{ kind: "always" }] } }
validateAdsSponsorshipRules({ match: "any", rules: [{ kind: "teaching-mode", modes: [] }] });
// => { ok: false, error: { field: "rules.rules[0].modes", reason: "must_be_non_empty_array" } }

const stored: StoredBrandAssetImage = {
  size: 120_000,
  contentType: "image/png",
  width: 640,
  height: 100,
};
validateBrandAssetImage(stored, "top"); // => { ok: true, image: { ... } } (2x of 320x50)
validateBrandAssetImage(stored, "rail-160"); // => { ok: false, reason: "wrong_dimensions" }
validateBrandAssetImage({ ...stored, size: 3_000_000 }, null); // => { ok: false, reason: "too_large" }

slotForCreative({ orientation: "horizontal", width: 728 }); // => "top"
slotForCreative({ orientation: "vertical", width: 160 }); // => "rail-160"
slotForCreative({ orientation: "vertical", width: 300 }); // => "rail-300"

const key = brandAssetStorageKey("acc-1", { kind: "slot", slot: "top" }, "obj-1", "image/png");
// => "brand-assets/acc-1/top/obj-1.png"
storageKeyBelongsTo("acc-1", { kind: "slot", slot: "top" }, key); // => true
storageKeyBelongsTo("acc-2", { kind: "slot", slot: "top" }, key); // => false

export function completeSet(faker: Faker): boolean {
  const top = makeBrandAsset(faker, { slot: "top" });
  brandAssetToCreative(top); // => { orientation: "horizontal", imageUrl, width: 320, height: 50 }

  const assets: BrandAsset[] = [
    top,
    makeBrandAsset(faker, { slot: "rail-160" }),
    makeBrandAsset(faker, { slot: "rail-300" }),
  ];
  return isCompleteBrandAssetSet(assets); // => true
}

export async function resolveDealAds(
  deps: AdsPolicyResolverDeps,
  ownerAccountId: string | null,
  viewerAccountId: string | null
) {
  const resolver = createDbAdsPolicyResolver({
    ...deps,
    onError: (stage, error) => console.error(`ads resolve failed at ${stage}`, error),
  });

  // Mints a serve: an ad_free viewer pays first, else the owner may be debited.
  const { policy, payer } = await resolver.resolveForServe({
    ownerAccountId,
    viewerAccountId,
    ctx: { teachingMode: "auction" },
  });
  // payer => { kind: "viewer", viewerAccountId } | { kind: "campaign", sponsorshipId }
  //        | { kind: "plan", diffusionDecidedAt } | { kind: "none" }

  // Read without a serve: ad-free viewer, campaigns or provider, never the plan.
  const readOnly = await resolver.resolveWithoutServe({
    ownerAccountId,
    viewerAccountId,
    ctx: { teachingMode: null },
  });
  return { policy, payer, readOnly };
}

export async function uploadOwnVisuals(deps: BrandAssetsServiceDeps, accountId: string) {
  const brandAssets = createBrandAssetsService(deps);

  // 1. One ticket per object; the browser PUTs the bytes to `uploadUrl`.
  const ticket = await brandAssets.createUploadTicket({
    accountId,
    target: { kind: "slot", slot: "top" },
    contentType: "image/png",
  });
  // ticket => { storageKey: "brand-assets/<accountId>/top/<id>.png", uploadUrl, token, expiresAt }

  // 2. Confirm the full set: every slot is read back and validated before the write.
  return brandAssets.confirmSet({
    accountId,
    sourceStorageKey: null,
    clickUrl: "https://example.org",
    alt: "Our club",
    slots: {
      top: { storageKey: ticket.storageKey },
      "rail-160": { storageKey: "brand-assets/<accountId>/rail-160/<id>.png" },
      "rail-300": { storageKey: "brand-assets/<accountId>/rail-300/<id>.png" },
    },
  });
}

export function createCampaign(deps: AdsSponsorshipsAdminServiceDeps) {
  const admin = createAdsSponsorshipsAdminService(deps);
  return admin.create({
    sponsor: "  Acme Bridge  ", // trimmed to "Acme Bridge"
    precedence: "over_plan",
    priority: 5,
    servesBudget: 10_000,
    validFrom: new Date("2026-09-01T00:00:00Z"),
    validUntil: null, // open-ended
    rules: { match: "any", rules: [{ kind: "always" }] },
    visuals: [
      {
        orientation: "horizontal",
        imageUrl: "https://cdn.example.org/acme-320x50.png",
        width: 320,
        height: 50,
        clickUrl: "https://acme.example.org",
        alt: null,
      },
    ],
  });
}

export function listSponsorBanners(storage: AdBannersStorage, sponsorSlug: string) {
  const banners = createAdBannersService({ storage });
  return banners.listForSponsor(sponsorSlug); // => [] for an empty slug, without a storage call
}

export async function readAndWriteCampaigns(
  sponsorshipsRead: AdsSponsorshipReadRepository,
  sponsorships: AdsSponsorshipsRepository,
  now: Date
) {
  // What the resolver loads: the campaigns in their window, resolver order.
  const active = await sponsorshipsRead.findMany(
    AdsSponsorshipQuery.active(now).withSorting({ column: "priority", desc: true }),
    AdsSponsorshipProjections.campaign()
  ); // => AdsCampaign[], each with `delivered` and its active `assets`

  // What the admin list shows: every campaign with its paid diffusions.
  const listed = await sponsorshipsRead.findMany(
    AdsSponsorshipQuery.empty().withSorting({ column: "validUntil", desc: true }),
    AdsSponsorshipProjections.withUsage()
  ); // => { sponsorship, delivered }[]

  // A criteria scopes every write; `visuals` replaces the active set.
  const [first] = listed;
  if (first) {
    await sponsorships.update(AdsSponsorshipCriteria.byId(first.sponsorship.id), {
      priority: 3,
      visuals: [],
    }); // => { updatedIds: [id] }, [] for an unknown id
  }
  return active;
}