curl --netrc "https://api.conviva.com/insights/3.0/metrics/plays?days=1"
curl --netrc "https://api.conviva.com/insights/3.0/metrics/attempts?days=1"
curl --netrc "https://api.conviva.com/insights/3.0/metrics/rebuffering-ratio?days=1"

curl --netrc "https://api.conviva.com/insights/3.0/metrics/custom-selection?metric=plays&metric=attempts&metric=rebuffering-ratio&days=1"

for id in "${asset_ids[@]}"; do
  curl --netrc "https://api.conviva.com/insights/3.0/metrics/plays?days=1&filter_id=$id"
done

curl --netrc "https://api.conviva.com/insights/3.0/metrics/custom-selection/group-by/asset?metric=plays&metric=rebuffering-ratio&granularity=P1D&order=desc&sort_by=plays&limit=50&days=1"

"""Efficient Conviva Metrics V3 usage: batch, group-by, cache settled windows, back off on 429.
Reads credentials from your ~/.netrc (machine api.conviva.com), so nothing sensitive is in code."""
import os, json, time, random, calendar, hashlib
import requests

BASE = "https://api.conviva.com/insights/3.0/metrics"
CACHE_DIR = ".conviva_cache"
os.makedirs(CACHE_DIR, exist_ok=True)
session = requests.Session()  # requests reads ~/.netrc automatically


def api_get(path, params):
    """GET with exponential backoff + jitter, honoring Retry-After."""
    for attempt in range(5):
        r = session.get(f"{BASE}/{path}", params=params)
        if r.status_code == 200:
            return r.json()
        if r.status_code == 429:
            try:
                wait = float(r.headers.get("Retry-After", ""))
            except ValueError:
                wait = 2 ** attempt
            time.sleep(wait + random.random())  # backoff + jitter
            continue
        r.raise_for_status()
    raise RuntimeError("still rate-limited after retries")


def cached_get(path, params, end_epoch):
    """Cache any window whose end is in the past: settled data never changes."""
    key = hashlib.sha256(f"{path}?{sorted(params.items())}".encode()).hexdigest()
    cache_file = os.path.join(CACHE_DIR, key + ".json")
    settled = end_epoch < time.time()
    if settled and os.path.exists(cache_file):
        with open(cache_file) as f:
            return json.load(f)
    data = api_get(path, params)
    if settled:
        with open(cache_file, "w") as f:
            json.dump(data, f)
    return data


if __name__ == "__main__":
    # One call, three metrics (batching):
    api_get("custom-selection",
            {"metric": ["plays", "attempts", "rebuffering-ratio"], "days": 1})
    # One call, every asset (group-by):
    api_get("custom-selection/group-by/asset",
            {"metric": "plays", "granularity": "P1D",
             "order": "desc", "sort_by": "plays", "limit": 50, "days": 1})
    # A settled window, cached after the first fetch:
    start, end = "2026-09-01T00:00:00Z", "2026-09-02T00:00:00Z"
    end_epoch = calendar.timegm(time.strptime(end, "%Y-%m-%dT%H:%M:%SZ"))
    cached_get("plays", {"start_date": start, "end_date": end}, end_epoch)
    cached_get("plays", {"start_date": start, "end_date": end}, end_epoch)  # cache hit
    print("ok: batch, group-by, and cached settled window all returned")

// Efficient Conviva Metrics V3 usage: batch, group-by, cache settled windows, back off on 429.
// Reads credentials from environment variables, so nothing sensitive is in code:
//   export CONVIVA_CLIENT_ID=...   export CONVIVA_CLIENT_SECRET=...
import fs from "node:fs";
import path from "node:path";
import crypto from "node:crypto";

const BASE = "https://api.conviva.com/insights/3.0/metrics";
const CACHE_DIR = ".conviva_cache";
fs.mkdirSync(CACHE_DIR, { recursive: true });
const AUTH = "Basic " + Buffer.from(
  `${process.env.CONVIVA_CLIENT_ID}:${process.env.CONVIVA_CLIENT_SECRET}`).toString("base64");

const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

// Repeat a parameter (metric=a&metric=b) when its value is an array.
// Sort by key so the same request always produces the same string (a stable cache key).
function qs(params) {
  const sp = new URLSearchParams();
  for (const [k, v] of Object.entries(params).sort(([a], [b]) => a.localeCompare(b))) {
    if (Array.isArray(v)) v.forEach((x) => sp.append(k, x));
    else sp.append(k, v);
  }
  return sp.toString();
}

// GET with exponential backoff + jitter, honoring Retry-After.
async function apiGet(pathName, params) {
  const url = `${BASE}/${pathName}?${qs(params)}`;
  for (let attempt = 0; attempt < 5; attempt++) {
    const res = await fetch(url, { headers: { Authorization: AUTH } });
    if (res.status === 200) return res.json();
    if (res.status === 429) {
      const wait = Number(res.headers.get("retry-after")) || 2 ** attempt;
      await sleep((wait + Math.random()) * 1000); // backoff + jitter
      continue;
    }
    throw new Error(`request failed: HTTP ${res.status}`);
  }
  throw new Error("still rate-limited after retries");
}

// Cache any window whose end is in the past: settled data never changes.
async function cachedGet(pathName, params, endEpoch) {
  const key = crypto.createHash("sha256").update(`${pathName}?${qs(params)}`).digest("hex");
  const file = path.join(CACHE_DIR, `${key}.json`);
  const settled = endEpoch < Date.now() / 1000;
  if (settled && fs.existsSync(file)) return JSON.parse(fs.readFileSync(file));
  const data = await apiGet(pathName, params);
  if (settled) fs.writeFileSync(file, JSON.stringify(data));
  return data;
}

// One call, three metrics (batching):
await apiGet("custom-selection", { metric: ["plays", "attempts", "rebuffering-ratio"], days: 1 });
// One call, every asset (group-by):
await apiGet("custom-selection/group-by/asset",
  { metric: "plays", granularity: "P1D", order: "desc", sort_by: "plays", limit: 50, days: 1 });
// A settled window, cached after the first fetch:
const start = "2026-09-01T00:00:00Z", end = "2026-09-02T00:00:00Z";
const endEpoch = Date.parse(end) / 1000;
await cachedGet("plays", { start_date: start, end_date: end }, endEpoch);
await cachedGet("plays", { start_date: start, end_date: end }, endEpoch); // cache hit
console.log("ok: batch, group-by, and cached settled window all returned");