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 PARAMS  = `client_id=${CLIENT_ID}&app-name=my-app-name&app-version=1.0`;
const HEADERS = {
  'User-Agent':    'my-app-name/1.0',
  'Authorization': `Bearer ${ACCESS_TOKEN}`,
};
const api = (path) => fetch(
  `https://api.simkl.com${path}${path.includes('?') ? '&' : '?'}${PARAMS}`,
  { headers: HEADERS }
).then(r => r.json());

// === First run — pull the user's full library, type by type ===
async function initialSync(state) {
  for (const type of SUPPORTED_TYPES) {
    const response = await api(`/sync/all-items/${type}`);
    state.cache[type] = response[type] ?? [];        // unwrap { shows: [...] } → just the array
  }
  // Save the watermark so future polls only fetch what's changed since now.
  const activities = await api('/sync/activities');
  state.lastSync = activities.all;
}

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

  // Cheap: did anything change since our watermark?
  const activities = await api('/sync/activities');
  if (activities.all === state.lastSync) return;     // nothing changed — done

  // One type configured? Use the smaller per-type endpoint.
  // Two or three? One bare call covers them all.
  const path = SUPPORTED_TYPES.length === 1
    ? `/sync/all-items/${SUPPORTED_TYPES[0]}`
    : `/sync/all-items`;
  const since = encodeURIComponent(state.lastSync);
  const delta = await api(`${path}?date_from=${since}`);

  // Merge the changes into our local cache, type by type.
  for (const type of SUPPORTED_TYPES) {
    if (delta[type]) {
      state.cache[type] = mergeItems(state.cache[type] ?? [], delta[type]);
    }
  }

  // Move the watermark forward.
  state.lastSync = activities.all;
}

import requests
from urllib.parse import urlencode

# === 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):
    return requests.get(
        f'https://api.simkl.com{path}',
        params={**PARAMS, **(extra or {})},
        headers=HEADERS,
    ).json()

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

    # Save the watermark so future polls only fetch what's changed since now.
    activities = api('/sync/activities')
    state['last_sync'] = activities['all']

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

    # Cheap: did anything change since our watermark?
    activities = api('/sync/activities')
    if activities['all'] == state['last_sync']:
        return                                            # nothing changed — done

    # One type configured? Use the smaller per-type endpoint.
    # Two or three? One bare call covers them all.
    path = f'/sync/all-items/{SUPPORTED_TYPES[0]}' if len(SUPPORTED_TYPES) == 1 else '/sync/all-items'
    delta = api(path, {'date_from': state['last_sync']})

    # Merge the changes into our local cache, type by type.
    for type_ in SUPPORTED_TYPES:
        if type_ in delta:
            state['cache'][type_] = merge_items(state['cache'].get(type_, []), delta[type_])

    # Move the watermark forward.
    state['last_sync'] = activities['all']

import Foundation

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

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.
    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, _) = try await URLSession.shared.data(for: req)
        return (try JSONSerialization.jsonObject(with: data) as? [String: Any]) ?? [:]
    }

    // === First run — pull the user's full library, type by type ===
    func initialSync(_ state: AppState) async throws {
        for type in SUPPORTED_TYPES {
            let response = try await api("/sync/all-items/\(type)")
            state.cache[type] = response[type] as? [[String: Any]] ?? []
        }
        // Save the watermark so future polls only fetch what's changed since now.
        let activities = try await api("/sync/activities")
        state.lastSync = activities["all"] as? String
    }

    // === Every poll after that — fetch only the delta ===
    func sync(_ state: AppState) async throws {
        guard let lastSync = state.lastSync else {
            return try await initialSync(state)              // first run ever? bootstrap
        }

        // Cheap: did anything change since our watermark?
        let activities = try await api("/sync/activities")
        guard activities["all"] as? String != lastSync else { return }   // nothing changed

        // One type configured? Use the smaller per-type endpoint.
        // Two or three? One bare call covers them all.
        let path = SUPPORTED_TYPES.count == 1
            ? "/sync/all-items/\(SUPPORTED_TYPES[0])"
            : "/sync/all-items"
        let delta = try await api(path, extra: ["date_from": lastSync])

        // Merge the changes into our local cache, type by type.
        for type in SUPPORTED_TYPES {
            if let bucket = delta[type] as? [[String: Any]] {
                state.cache[type] = mergeItems(state.cache[type] ?? [], bucket)
            }
        }

        // Move the watermark forward.
        state.lastSync = activities["all"] as? String
    }
}

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")

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.
    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 JSONObject(http.newCall(req).execute().use { it.body!!.string() })
    }

    // === First run — pull the user's full library, type by type ===
    suspend fun initialSync(state: AppState) {
        for (type in SUPPORTED_TYPES) {
            val response = api("/sync/all-items/$type")
            state.cache[type] = response.optJSONArray(type) ?: JSONArray()
        }
        // Save the watermark so future polls only fetch what's changed since now.
        val activities = api("/sync/activities")
        state.lastSync = activities.optString("all").ifEmpty { null }
    }

    // === Every poll after that — fetch only the delta ===
    suspend fun sync(state: AppState) {
        val lastSync = state.lastSync ?: return initialSync(state)   // first run ever?

        // Cheap: did anything change since our watermark?
        val activities = api("/sync/activities")
        if (activities.optString("all") == lastSync) return          // nothing changed

        // One type configured? Use the smaller per-type endpoint.
        // Two or three? One bare call covers them all.
        val path = if (SUPPORTED_TYPES.size == 1)
            "/sync/all-items/${SUPPORTED_TYPES[0]}"
        else
            "/sync/all-items"
        val delta = api(path, mapOf("date_from" to lastSync))

        // Merge the changes into our local cache, type by type.
        for (type in SUPPORTED_TYPES) {
            if (delta.has(type)) {
                state.cache[type] = mergeItems(state.cache[type] ?: JSONArray(), delta.getJSONArray(type))
            }
        }

        // Move the watermark forward.
        state.lastSync = activities.optString("all")
    }
}

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'];

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.
  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',
    });
    return jsonDecode(res.body) as Map<String, dynamic>;
  }

  // === First run — pull the user's full library, type by type ===
  Future<void> initialSync(AppState state) async {
    for (final type in SUPPORTED_TYPES) {
      final response = await api('/sync/all-items/$type');
      state.cache[type] = (response[type] as List?) ?? [];
    }
    // Save the watermark so future polls only fetch what's changed since now.
    final activities = await api('/sync/activities');
    state.lastSync = activities['all'] as String?;
  }

  // === Every poll after that — fetch only the delta ===
  Future<void> sync(AppState state) async {
    if (state.lastSync == null) return initialSync(state);            // first run ever?

    // Cheap: did anything change since our watermark?
    final activities = await api('/sync/activities');
    if (activities['all'] == state.lastSync) return;                  // nothing changed

    // One type configured? Use the smaller per-type endpoint.
    // Two or three? One bare call covers them all.
    final path = SUPPORTED_TYPES.length == 1
        ? '/sync/all-items/${SUPPORTED_TYPES[0]}'
        : '/sync/all-items';
    final delta = await api(path, {'date_from': state.lastSync!});

    // Merge the changes into our local cache, type by type.
    for (final type in SUPPORTED_TYPES) {
      if (delta.containsKey(type)) {
        state.cache[type] = mergeItems(state.cache[type] ?? [], delta[type] as List);
      }
    }

    // Move the watermark forward.
    state.lastSync = activities['all'] as String?;
  }
}