Sync — watchlists, history, and ratings

// === CONFIG — drop the types your app doesn't use ===
const SUPPORTED_TYPES = ['shows', 'movies', 'anime'];

// === Boilerplate: auth + a tiny GET helper ===
const HEADERS = {
  'User-Agent':    'my-app-name/1.0',
  'Authorization': `Bearer ${ACCESS_TOKEN}`,
};
async function api(path, query = {}) {
  const qs = new URLSearchParams({
    ...query, client_id: CLIENT_ID, 'app-name': 'my-app-name', 'app-version': '1.0',
  });
  const r = await fetch(`https://api.simkl.com${path}?${qs}`, { headers: HEADERS });
  if (!r.ok) throw new Error(`HTTP ${r.status} on ${path}`);   // a failed fetch must never save a snapshot
  return (await r.json()) ?? {};                      // older client_ids get `null` for an empty result
}

// The activities blocks are named differently from the endpoint types.
const BLOCK = { shows: 'tv_shows', movies: 'movies', anime: 'anime' };
const NOT_A_STATUS = new Set(['all', 'rated_at', 'playback', 'removed_from_list']);
const simklId = (item) => (item.show ?? item.movie).ids.simkl;

// One type → its per-type path (smaller); two or three → one bare call.
const scoped = (base) => SUPPORTED_TYPES.length === 1 ? `${base}/${SUPPORTED_TYPES[0]}` : base;

function merge(state, response) {
  for (const type of SUPPORTED_TYPES) {
    if (response[type]) state.cache[type] = mergeItems(state.cache[type] ?? [], response[type]);
  }
}

// === First run — pull the user's full library, type by type ===
async function initialSync(state) {
  const snapshot = await api('/sync/activities');      // read BEFORE the pull
  for (const type of SUPPORTED_TYPES) {
    const response = await api(`/sync/all-items/${type}`);
    state.cache[type] = response[type] ?? [];         // unwrap { shows: [...] } → just the array
  }
  state.snapshot = snapshot;                           // save only once every pull succeeded
}

// === Every poll after that — fetch only what moved ===
async function sync(state) {
  if (!state.snapshot) return initialSync(state);     // first run ever? bootstrap

  const prev = state.snapshot;
  const now  = await api('/sync/activities');          // read BEFORE fetching
  if (now.all === prev.all) return;                   // nothing changed anywhere — done

  const moved = (type, key) => now[BLOCK[type]]?.[key] !== prev[BLOCK[type]]?.[key];
  const listMoved = (type) =>
    Object.keys(now[BLOCK[type]] ?? {}).some(key => !NOT_A_STATUS.has(key) && moved(type, key));
  const since = prev.all ? { date_from: prev.all } : {};   // exactly as returned; null on a brand-new account

  // A watchlist status moved → the item delta.
  if (SUPPORTED_TYPES.some(listMoved)) {
    merge(state, await api(scoped('/sync/all-items'), since));
  }

  // Only when rated_at moved — never on every poll; all-items rows already carry user_rating.
  // No rating segment: it would drop removals (user_rating: null).
  if (SUPPORTED_TYPES.some(type => moved(type, 'rated_at'))) {
    merge(state, await api(scoped('/sync/ratings'), since));
  }

  // Something was removed → no delta can say what, so diff the full ID list.
  if (SUPPORTED_TYPES.some(type => moved(type, 'removed_from_list'))) {
    const ids = await api(scoped('/sync/all-items'), { extended: 'simkl_ids_only' });
    for (const type of SUPPORTED_TYPES) {
      const current = new Set((ids[type] ?? []).map(simklId));
      state.cache[type] = (state.cache[type] ?? []).filter(item => current.has(simklId(item)));
    }
  }

  // playback, settings, custom_lists: add the same check for any you display,
  // and drop any block above for data your app doesn't show.

  state.snapshot = now;                                // only reached if every fetch succeeded
}

import requests

# === CONFIG — drop the types your app doesn't use ===
SUPPORTED_TYPES = ('shows', 'movies', 'anime')

# === Boilerplate: auth + a tiny GET helper ===
PARAMS = {
    'client_id':   CLIENT_ID,
    'app-name':    'my-app-name',
    'app-version': '1.0',
}
HEADERS = {
    'User-Agent':    'my-app-name/1.0',
    'Authorization': f'Bearer {ACCESS_TOKEN}',
}

def api(path, extra=None):
    r = requests.get(
        f'https://api.simkl.com{path}',
        params={**PARAMS, **(extra or {})},
        headers=HEADERS,
    )
    r.raise_for_status()                                  # a failed fetch must never save a snapshot
    return r.json() or {}                                 # older client_ids get null for an empty result

# The activities blocks are named differently from the endpoint types.
BLOCK = {'shows': 'tv_shows', 'movies': 'movies', 'anime': 'anime'}
NOT_A_STATUS = {'all', 'rated_at', 'playback', 'removed_from_list'}

def simkl_id(item):
    return (item.get('show') or item.get('movie'))['ids']['simkl']

# One type → its per-type path (smaller); two or three → one bare call.
def scoped(base):
    return f'{base}/{SUPPORTED_TYPES[0]}' if len(SUPPORTED_TYPES) == 1 else base

def merge(state, response):
    for type_ in SUPPORTED_TYPES:
        if type_ in response:
            state['cache'][type_] = merge_items(state['cache'].get(type_, []), response[type_])

# === First run — pull the user's full library, type by type ===
def initial_sync(state):
    snapshot = api('/sync/activities')                    # read BEFORE the pull
    for type_ in SUPPORTED_TYPES:
        response = api(f'/sync/all-items/{type_}')
        state['cache'][type_] = response.get(type_, [])   # unwrap { shows: [...] }
    state['snapshot'] = snapshot                          # save only once every pull succeeded

# === Every poll after that — fetch only what moved ===
def sync(state):
    if not state.get('snapshot'):
        return initial_sync(state)                        # first run ever? bootstrap

    prev = state['snapshot']
    now = api('/sync/activities')                         # read BEFORE fetching
    if now['all'] == prev['all']:
        return                                            # nothing changed anywhere — done

    def moved(type_, key):
        return now.get(BLOCK[type_], {}).get(key) != prev.get(BLOCK[type_], {}).get(key)

    def list_moved(type_):
        return any(key not in NOT_A_STATUS and moved(type_, key) for key in now.get(BLOCK[type_], {}))

    since = {'date_from': prev['all']} if prev['all'] else {}   # exactly as returned; None on a brand-new account

    # A watchlist status moved → the item delta.
    if any(list_moved(t) for t in SUPPORTED_TYPES):
        merge(state, api(scoped('/sync/all-items'), since))

    # Only when rated_at moved — never on every poll; all-items rows already carry user_rating.
    # No rating segment: it would drop removals (user_rating: None).
    if any(moved(t, 'rated_at') for t in SUPPORTED_TYPES):
        merge(state, api(scoped('/sync/ratings'), since))

    # Something was removed → no delta can say what, so diff the full ID list.
    if any(moved(t, 'removed_from_list') for t in SUPPORTED_TYPES):
        ids = api(scoped('/sync/all-items'), {'extended': 'simkl_ids_only'})
        for type_ in SUPPORTED_TYPES:
            current = {simkl_id(i) for i in ids.get(type_, [])}
            state['cache'][type_] = [i for i in state['cache'].get(type_, []) if simkl_id(i) in current]

    # playback, settings, custom_lists: add the same check for any you display,
    # and drop any block above for data your app doesn't show.

    state['snapshot'] = now                               # only reached if every fetch succeeded

import Foundation

// === CONFIG — drop the types your app doesn't use ===
let SUPPORTED_TYPES = ["shows", "movies", "anime"]

// The activities blocks are named differently from the endpoint types.
let BLOCK = ["shows": "tv_shows", "movies": "movies", "anime": "anime"]
let NOT_A_STATUS: Set<String> = ["all", "rated_at", "playback", "removed_from_list"]

func simklId(_ item: [String: Any]) -> Int? {
    let media = (item["show"] ?? item["movie"]) as? [String: Any]
    return (media?["ids"] as? [String: Any])?["simkl"] as? Int
}

struct SimklClient {
    let clientId: String
    let accessToken: String
    private let appName = "my-app-name"
    private let appVer  = "1.0"

    // Tiny GET helper — appends auth params to any path, throws on any non-2xx.
    private func api(_ path: String, extra: [String: String] = [:]) async throws -> [String: Any] {
        var comps = URLComponents(string: "https://api.simkl.com\(path)")!
        comps.queryItems = [
            URLQueryItem(name: "client_id",   value: clientId),
            URLQueryItem(name: "app-name",    value: appName),
            URLQueryItem(name: "app-version", value: appVer),
        ] + extra.map { URLQueryItem(name: $0.key, value: $0.value) }

        var req = URLRequest(url: comps.url!)
        req.setValue("Bearer \(accessToken)", forHTTPHeaderField: "Authorization")
        req.setValue("\(appName)/\(appVer)",  forHTTPHeaderField: "User-Agent")
        let (data, response) = try await URLSession.shared.data(for: req)
        guard let http = response as? HTTPURLResponse, (200..<300).contains(http.statusCode) else {
            throw URLError(.badServerResponse)                // a failed fetch must never save a snapshot
        }
        return (try JSONSerialization.jsonObject(with: data) as? [String: Any]) ?? [:]
    }

    // One type → its per-type path (smaller); two or three → one bare call.
    private func scoped(_ base: String) -> String {
        SUPPORTED_TYPES.count == 1 ? "\(base)/\(SUPPORTED_TYPES[0])" : base
    }

    private func merge(_ state: AppState, _ response: [String: Any]) {
        for type in SUPPORTED_TYPES {
            if let rows = response[type] as? [[String: Any]] {
                state.cache[type] = mergeItems(state.cache[type] ?? [], rows)
            }
        }
    }

    // === First run — pull the user's full library, type by type ===
    func initialSync(_ state: AppState) async throws {
        let snapshot = try await api("/sync/activities")       // read BEFORE the pull
        for type in SUPPORTED_TYPES {
            let response = try await api("/sync/all-items/\(type)")
            state.cache[type] = response[type] as? [[String: Any]] ?? []
        }
        state.snapshot = snapshot                               // save only once every pull succeeded
    }

    // === Every poll after that — fetch only what moved ===
    func sync(_ state: AppState) async throws {
        guard let prev = state.snapshot else {
            return try await initialSync(state)                 // first run ever? bootstrap
        }
        let now = try await api("/sync/activities")            // read BEFORE fetching
        let prevAll = prev["all"] as? String
        guard (now["all"] as? String) != prevAll else { return }   // nothing changed anywhere

        func value(_ s: [String: Any], _ type: String, _ key: String) -> String? {
            (s[BLOCK[type]!] as? [String: Any])?[key] as? String
        }
        func moved(_ type: String, _ key: String) -> Bool {
            value(now, type, key) != value(prev, type, key)
        }
        func listMoved(_ type: String) -> Bool {
            ((now[BLOCK[type]!] as? [String: Any]) ?? [:]).keys
                .contains { !NOT_A_STATUS.contains($0) && moved(type, $0) }
        }
        let since = prevAll.map { ["date_from": $0] } ?? [:]   // exactly as returned; nil on a brand-new account

        // A watchlist status moved → the item delta.
        if SUPPORTED_TYPES.contains(where: { listMoved($0) }) {
            let delta = try await api(scoped("/sync/all-items"), extra: since)
            merge(state, delta)
        }

        // Only when rated_at moved — never on every poll; all-items rows already carry user_rating.
        // No rating segment: it would drop removals (user_rating: null).
        if SUPPORTED_TYPES.contains(where: { moved($0, "rated_at") }) {
            let ratings = try await api(scoped("/sync/ratings"), extra: since)
            merge(state, ratings)
        }

        // Something was removed → no delta can say what, so diff the full ID list.
        if SUPPORTED_TYPES.contains(where: { moved($0, "removed_from_list") }) {
            let ids = try await api(scoped("/sync/all-items"), extra: ["extended": "simkl_ids_only"])
            for type in SUPPORTED_TYPES {
                let current = Set(((ids[type] as? [[String: Any]]) ?? []).compactMap(simklId))
                state.cache[type] = (state.cache[type] ?? []).filter { current.contains(simklId($0) ?? -1) }
            }
        }

        // playback, settings, custom_lists: add the same check for any you display,
        // and drop any block above for data your app doesn't show.

        state.snapshot = now                                    // only reached if every fetch succeeded
    }
}

import java.io.IOException
import okhttp3.HttpUrl.Companion.toHttpUrl
import okhttp3.OkHttpClient
import okhttp3.Request
import org.json.JSONObject
import org.json.JSONArray

// === CONFIG — drop the types your app doesn't use ===
val SUPPORTED_TYPES = listOf("shows", "movies", "anime")

// The activities blocks are named differently from the endpoint types.
val BLOCK = mapOf("shows" to "tv_shows", "movies" to "movies", "anime" to "anime")
val NOT_A_STATUS = setOf("all", "rated_at", "playback", "removed_from_list")

fun simklId(item: JSONObject): Long =
    (item.optJSONObject("show") ?: item.getJSONObject("movie")).getJSONObject("ids").getLong("simkl")

// A JSON null reads as null here — optString() would turn it into the text "null".
fun JSONObject.str(key: String): String? = if (isNull(key)) null else getString(key)

class SimklClient(private val clientId: String, private val accessToken: String) {
    private val appName = "my-app-name"
    private val appVer  = "1.0"
    private val http    = OkHttpClient()

    // Tiny GET helper — appends auth params to any path, throws on any non-2xx.
    private fun api(path: String, extra: Map<String, String> = emptyMap()): JSONObject {
        val url = "https://api.simkl.com$path".toHttpUrl().newBuilder()
            .addQueryParameter("client_id",   clientId)
            .addQueryParameter("app-name",    appName)
            .addQueryParameter("app-version", appVer)
            .apply { extra.forEach { (k, v) -> addQueryParameter(k, v) } }
            .build()
        val req = Request.Builder().url(url)
            .header("Authorization", "Bearer $accessToken")
            .header("User-Agent",    "$appName/$appVer")
            .build()
        return http.newCall(req).execute().use {
            if (!it.isSuccessful) throw IOException("HTTP ${it.code} on $path")   // never save a snapshot after this
            val body = it.body!!.string()
            if (body.trim() == "null") JSONObject() else JSONObject(body)   // older client_ids get null for an empty result
        }
    }

    // One type → its per-type path (smaller); two or three → one bare call.
    private fun scoped(base: String) =
        if (SUPPORTED_TYPES.size == 1) "$base/${SUPPORTED_TYPES[0]}" else base

    private fun merge(state: AppState, response: JSONObject) {
        for (type in SUPPORTED_TYPES) {
            if (response.has(type)) {
                state.cache[type] = mergeItems(state.cache[type] ?: JSONArray(), response.getJSONArray(type))
            }
        }
    }

    // === First run — pull the user's full library, type by type ===
    suspend fun initialSync(state: AppState) {
        val snapshot = api("/sync/activities")                 // read BEFORE the pull
        for (type in SUPPORTED_TYPES) {
            val response = api("/sync/all-items/$type")
            state.cache[type] = response.optJSONArray(type) ?: JSONArray()
        }
        state.snapshot = snapshot                               // save only once every pull succeeded
    }

    // === Every poll after that — fetch only what moved ===
    suspend fun sync(state: AppState) {
        val prev = state.snapshot ?: return initialSync(state)  // first run ever?
        val now = api("/sync/activities")                      // read BEFORE fetching
        if (now.str("all") == prev.str("all")) return          // nothing changed anywhere

        fun moved(type: String, key: String) =
            now.optJSONObject(BLOCK.getValue(type))?.str(key) != prev.optJSONObject(BLOCK.getValue(type))?.str(key)
        fun listMoved(type: String) =
            now.optJSONObject(BLOCK.getValue(type))?.keys()?.asSequence()
                ?.any { it !in NOT_A_STATUS && moved(type, it) } ?: false
        // Exactly as returned; null on a brand-new account.
        val since = prev.str("all")?.let { mapOf("date_from" to it) } ?: emptyMap()

        // A watchlist status moved → the item delta.
        if (SUPPORTED_TYPES.any { listMoved(it) }) {
            merge(state, api(scoped("/sync/all-items"), since))
        }

        // Only when rated_at moved — never on every poll; all-items rows already carry user_rating.
        // No rating segment: it would drop removals (user_rating: null).
        if (SUPPORTED_TYPES.any { moved(it, "rated_at") }) {
            merge(state, api(scoped("/sync/ratings"), since))
        }

        // Something was removed → no delta can say what, so diff the full ID list.
        if (SUPPORTED_TYPES.any { moved(it, "removed_from_list") }) {
            val ids = api(scoped("/sync/all-items"), mapOf("extended" to "simkl_ids_only"))
            for (type in SUPPORTED_TYPES) {
                val rows = ids.optJSONArray(type) ?: JSONArray()
                val current = (0 until rows.length()).map { simklId(rows.getJSONObject(it)) }.toSet()
                val cached = state.cache[type] ?: JSONArray()
                state.cache[type] = JSONArray(
                    (0 until cached.length()).map { cached.getJSONObject(it) }.filter { simklId(it) in current }
                )
            }
        }

        // playback, settings, custom_lists: add the same check for any you display,
        // and drop any block above for data your app doesn't show.

        state.snapshot = now                                    // only reached if every fetch succeeded
    }
}

import 'dart:convert';
import 'package:http/http.dart' as http;

// === CONFIG — drop the types your app doesn't use ===
const SUPPORTED_TYPES = ['shows', 'movies', 'anime'];

// The activities blocks are named differently from the endpoint types.
const BLOCK = {'shows': 'tv_shows', 'movies': 'movies', 'anime': 'anime'};
const NOT_A_STATUS = {'all', 'rated_at', 'playback', 'removed_from_list'};

int simklId(Map item) => (item['show'] ?? item['movie'])['ids']['simkl'] as int;

class SimklClient {
  final String clientId;
  final String accessToken;
  static const _appName = 'my-app-name';
  static const _appVer  = '1.0';

  SimklClient({required this.clientId, required this.accessToken});

  // Tiny GET helper — appends auth params to any path, throws on any non-2xx.
  Future<Map<String, dynamic>> api(String path, [Map<String, String>? extra]) async {
    final uri = Uri.https('api.simkl.com', path, {
      'client_id':   clientId,
      'app-name':    _appName,
      'app-version': _appVer,
      ...?extra,
    });
    final res = await http.get(uri, headers: {
      'Authorization': 'Bearer $accessToken',
      'User-Agent':    '$_appName/$_appVer',
    });
    if (res.statusCode < 200 || res.statusCode >= 300) {
      throw Exception('HTTP ${res.statusCode} on $path');    // a failed fetch must never save a snapshot
    }
    return (jsonDecode(res.body) as Map<String, dynamic>?) ?? {};   // older client_ids get null for an empty result
  }

  // One type → its per-type path (smaller); two or three → one bare call.
  String scoped(String base) =>
      SUPPORTED_TYPES.length == 1 ? '$base/${SUPPORTED_TYPES[0]}' : base;

  void merge(AppState state, Map<String, dynamic> response) {
    for (final type in SUPPORTED_TYPES) {
      if (response.containsKey(type)) {
        state.cache[type] = mergeItems(state.cache[type] ?? [], response[type] as List);
      }
    }
  }

  // === First run — pull the user's full library, type by type ===
  Future<void> initialSync(AppState state) async {
    final snapshot = await api('/sync/activities');             // read BEFORE the pull
    for (final type in SUPPORTED_TYPES) {
      final response = await api('/sync/all-items/$type');
      state.cache[type] = (response[type] as List?) ?? [];
    }
    state.snapshot = snapshot;                                   // save only once every pull succeeded
  }

  // === Every poll after that — fetch only what moved ===
  Future<void> sync(AppState state) async {
    final prev = state.snapshot;
    if (prev == null) return initialSync(state);                 // first run ever?

    final now = await api('/sync/activities');                  // read BEFORE fetching
    if (now['all'] == prev['all']) return;                      // nothing changed anywhere

    String? value(Map s, String type, String key) => (s[BLOCK[type]] as Map?)?[key] as String?;
    bool moved(String type, String key) => value(now, type, key) != value(prev, type, key);
    bool listMoved(String type) => ((now[BLOCK[type]] as Map?)?.keys ?? const [])
        .any((key) => !NOT_A_STATUS.contains(key) && moved(type, key as String));
    // Exactly as returned; null on a brand-new account.
    final since = prev['all'] == null ? <String, String>{} : {'date_from': prev['all'] as String};

    // A watchlist status moved → the item delta.
    if (SUPPORTED_TYPES.any(listMoved)) {
      merge(state, await api(scoped('/sync/all-items'), since));
    }

    // Only when rated_at moved — never on every poll; all-items rows already carry user_rating.
    // No rating segment: it would drop removals (user_rating: null).
    if (SUPPORTED_TYPES.any((t) => moved(t, 'rated_at'))) {
      merge(state, await api(scoped('/sync/ratings'), since));
    }

    // Something was removed → no delta can say what, so diff the full ID list.
    if (SUPPORTED_TYPES.any((t) => moved(t, 'removed_from_list'))) {
      final ids = await api(scoped('/sync/all-items'), {'extended': 'simkl_ids_only'});
      for (final type in SUPPORTED_TYPES) {
        final current = ((ids[type] as List?) ?? []).map((i) => simklId(i as Map)).toSet();
        state.cache[type] =
            (state.cache[type] ?? []).where((i) => current.contains(simklId(i as Map))).toList();
      }
    }

    // playback, settings, custom_lists: add the same check for any you display,
    // and drop any block above for data your app doesn't show.

    state.snapshot = now;                                        // only reached if every fetch succeeded
  }
}