import crate_server/identity_cache.{type Identity, Identity}
import gleam/dict
import gleam/set

fn identity() -> Identity {
  Identity(did: "did:plc:abc", handle: "abc.test", pds: "https://pds.test")
}

pub fn fresh_hit_returned_test() {
  let assert Ok(cache) =
    identity_cache.start(ttl_seconds: 3600, negative_ttl_seconds: 60)
  cache.put("did:plc:abc", identity())
  let resolution = cache.get_many(["did:plc:abc"])
  assert dict.get(resolution.hits, "did:plc:abc") == Ok(identity())
  assert resolution.suppressed == set.new()
}

pub fn expired_entry_is_a_miss_test() {
  // A zero TTL means "now - cached_at < 0", which is never true: the entry
  // is stale the instant it is written, without needing to sleep past a
  // real deadline.
  let assert Ok(cache) =
    identity_cache.start(ttl_seconds: 0, negative_ttl_seconds: 60)
  cache.put("did:plc:abc", identity())
  let resolution = cache.get_many(["did:plc:abc"])
  assert dict.get(resolution.hits, "did:plc:abc") == Error(Nil)
  assert resolution.suppressed == set.new()
}

pub fn put_overwrites_test() {
  let assert Ok(cache) =
    identity_cache.start(ttl_seconds: 3600, negative_ttl_seconds: 60)
  cache.put("did:plc:abc", identity())
  let updated = Identity(..identity(), handle: "renamed.test")
  cache.put("did:plc:abc", updated)
  let resolution = cache.get_many(["did:plc:abc"])
  assert dict.get(resolution.hits, "did:plc:abc") == Ok(updated)
}

pub fn negative_entry_suppresses_within_ttl_test() {
  let assert Ok(cache) =
    identity_cache.start(ttl_seconds: 3600, negative_ttl_seconds: 60)
  cache.put_failure("did:plc:gone")
  let resolution = cache.get_many(["did:plc:gone"])
  assert dict.get(resolution.hits, "did:plc:gone") == Error(Nil)
  assert set.contains(resolution.suppressed, "did:plc:gone")
}

pub fn negative_entry_expires_after_ttl_test() {
  // Same zero-TTL trick as the positive-cache expiry test, applied to the
  // negative TTL instead.
  let assert Ok(cache) =
    identity_cache.start(ttl_seconds: 3600, negative_ttl_seconds: 0)
  cache.put_failure("did:plc:gone")
  let resolution = cache.get_many(["did:plc:gone"])
  assert !set.contains(resolution.suppressed, "did:plc:gone")
}

pub fn put_clears_a_prior_failure_test() {
  let assert Ok(cache) =
    identity_cache.start(ttl_seconds: 3600, negative_ttl_seconds: 60)
  cache.put_failure("did:plc:abc")
  cache.put("did:plc:abc", identity())
  let resolution = cache.get_many(["did:plc:abc"])
  assert dict.get(resolution.hits, "did:plc:abc") == Ok(identity())
  assert !set.contains(resolution.suppressed, "did:plc:abc")
}

pub fn unknown_identifier_is_neither_hit_nor_suppressed_test() {
  let assert Ok(cache) =
    identity_cache.start(ttl_seconds: 3600, negative_ttl_seconds: 60)
  let resolution = cache.get_many(["did:plc:never-seen"])
  assert dict.get(resolution.hits, "did:plc:never-seen") == Error(Nil)
  assert !set.contains(resolution.suppressed, "did:plc:never-seen")
}