import at_record/gen/catalog/release as catalog_release
import at_record/gen/defs
import at_record/gen/repo/strong_ref.{RepoStrongRef}
import at_record/gen/shelf/entry.{type ShelfEntry, ShelfEntry}
import at_record/storage.{type StoredItem, StoredItem}
import at_record_server/crate
import gleam/json
import gleam/list
import gleam/option.{None, Some}
import support

fn event_uri(rkey: String) -> String {
  "at://did/dev.mokkenstorm.crate.shelf.entry/" <> rkey
}

// A genesis event (no subject) when `subject_rkey` is None; otherwise an
// append referencing that genesis.
fn ev(
  rkey: String,
  subject_rkey: option.Option(String),
  action: String,
  media_grade: option.Option(String),
) -> StoredItem(ShelfEntry) {
  ev_with_source(rkey, subject_rkey, action, media_grade, None)
}

fn ev_with_source(
  rkey: String,
  subject_rkey: option.Option(String),
  action: String,
  media_grade: option.Option(String),
  source: option.Option(defs.Source),
) -> StoredItem(ShelfEntry) {
  StoredItem(
    uri: event_uri(rkey),
    cid: "cid-" <> rkey,
    rkey:,
    value: ShelfEntry(
      ..support.blank_shelf_entry(),
      subject: option.map(subject_rkey, fn(genesis) {
        RepoStrongRef(uri: event_uri(genesis), cid: "cid-" <> genesis)
      }),
      action:,
      media_grade:,
      source:,
      created_at: "t",
    ),
  )
}

pub fn fold_reduces_log_to_current_state_test() {
  // Deliberately shuffled: fold must order by rkey, not input order.
  let events = [
    ev("3e", None, "acquired", Some("M")),
    ev("3c", Some("3a"), "regraded", Some("NM")),
    ev("3a", None, "wanted", None),
    ev("3d", Some("3a"), "sold", None),
    ev("3b", Some("3a"), "acquired", Some("VG+")),
  ]
  let folded = crate.fold(events)

  // The genesis TID is the entry id.
  let assert Ok(e1) = list.find(folded, fn(e) { e.entry_id == "3a" })
  assert e1.status == crate.Gone
  // last-write-wins: NM set by regraded, never overwritten
  assert e1.media_grade == Some("NM")
  assert list.length(e1.events) == 4

  let assert Ok(e2) = list.find(folded, fn(e) { e.entry_id == "3e" })
  assert e2.status == crate.Owned
  assert e2.media_grade == Some("M")
}

pub fn fold_wanted_is_wishlist_test() {
  let folded = crate.fold([ev("3a", None, "wanted", None)])
  let assert Ok(w) = list.find(folded, fn(e) { e.entry_id == "3a" })
  assert w.status == crate.Wanted
}

pub fn fold_drops_orphan_appends_test() {
  // An append whose genesis was purged must not surface as an entry.
  let folded =
    crate.fold([
      ev("3b", Some("3a"), "regraded", Some("NM")),
      ev("3c", None, "acquired", None),
    ])
  assert list.map(folded, fn(e) { e.entry_id }) == ["3c"]
}

fn a_source(origin: String) -> defs.Source {
  defs.Source(
    client_agent: None,
    external: Some(defs.ExternalId(id: "123", provider: "discogs", url: None)),
    origin: Some(origin),
    origin_url: None,
    record: None,
  )
}

pub fn fold_carries_genesis_source_test() {
  // Provenance describes how the physical item entered the crate, so it
  // comes from the genesis event only, never overwritten by later appends.
  let folded =
    crate.fold([
      ev_with_source("3a", None, "acquired", None, Some(a_source("scan"))),
      ev_with_source(
        "3b",
        Some("3a"),
        "regraded",
        Some("NM"),
        Some(a_source("manual")),
      ),
    ])
  let assert Ok(e) = list.find(folded, fn(e) { e.entry_id == "3a" })
  assert e.source == Some(a_source("scan"))
}

fn blank_release() -> catalog_release.CatalogRelease {
  support.blank_catalog_release()
}

pub fn encode_release_info_includes_present_display_fields_test() {
  let release =
    catalog_release.CatalogRelease(
      ..blank_release(),
      artist_display: Some("Slint"),
      genres: Some(["Rock"]),
      styles: Some(["Math Rock"]),
      country: Some("US"),
      released: Some("1991-03-27"),
    )
  let body = crate.encode_release_info(release) |> json.to_string
  assert support.field_string(body, ["artistDisplay"]) == Ok("Slint")
  assert support.field_string(body, ["country"]) == Ok("US")
  assert support.field_string(body, ["released"]) == Ok("1991-03-27")
}

pub fn encode_release_info_omits_absent_fields_test() {
  let body = crate.encode_release_info(blank_release()) |> json.to_string
  assert support.field_present(body, ["artistDisplay"]) == False
  assert support.field_present(body, ["genres"]) == False
  assert support.field_present(body, ["styles"]) == False
  assert support.field_present(body, ["country"]) == False
  assert support.field_present(body, ["released"]) == False
}

fn blank_entry() -> crate.CrateEntry {
  crate.CrateEntry(
    entry_id: "3a",
    status: crate.Owned,
    snapshot: None,
    media_grade: None,
    sleeve_grade: None,
    rating: None,
    folder: None,
    notes: None,
    release: None,
    price: None,
    counterparty: None,
    source: None,
    created_at: "t",
    updated_at: "t",
    events: [],
  )
}

pub fn encode_entry_includes_source_when_present_test() {
  let body =
    crate.encode_entry(
      crate.CrateEntry(..blank_entry(), source: Some(a_source("scan"))),
    )
    |> json.to_string
  assert support.field_string(body, ["source", "origin"]) == Ok("scan")
  assert support.field_string(body, ["source", "external", "provider"])
    == Ok("discogs")
}

pub fn encode_entry_omits_source_when_absent_test() {
  let body = crate.encode_entry(blank_entry()) |> json.to_string
  assert support.field_present(body, ["source"]) == False
}