//// End-to-end test for the browse handler's `?strategy=` param: HTTP wiring
//// only, domain correctness lives in catalog_variants/stats/strategy_test.

import at_record_server/catalog/row.{BrowseRow}
import at_record_server/catalog/source.{type Source, Source}
import at_record_server/context.{type Context}
import at_record_server/handlers/browse.{browse}
import at_record_server/oauth/config
import at_record_server/oauth/session_store
import at_record_server/oauth/sessions
import gleam/http
import gleam/list
import gleam/option.{None, Some}
import gleam/string
import support
import wisp
import wisp/simulate

const session_cookie = "ar_oauth_sid"

const far_future = 9_999_999_999

fn a_session() -> sessions.OauthSession {
  support.stub_session_with(
    access_token: "at",
    refresh_token: "rt",
    expires_at: far_future,
  )
}

/// Same Discogs release: `a` has far more adoption, `b` is more recent.
fn variant_source() -> Source {
  let more_adopted =
    BrowseRow(
      uri: "at://a/1",
      cid: "bafya",
      title: "Spiderland",
      artist_display: Some("Slint"),
      genres: [],
      styles: [],
      released: None,
      country: None,
      cover: None,
      thumb_url: None,
      discogs_id: Some("42"),
      created_at: "2020-01-01T00:00:00Z",
      publisher_did: "did:plc:pub",
      publisher_handle: "pub.test",
      publisher_pds: "https://pds.test",
      supersedes: None,
      based_on: None,
    )
  let more_recent =
    BrowseRow(
      ..more_adopted,
      uri: "at://b/1",
      cid: "bafyb",
      created_at: "2024-01-01T00:00:00Z",
    )
  Source(
    releases: fn() { [more_adopted, more_recent] },
    adoption_count: fn(uri) {
      case uri {
        "at://a/1" -> 10
        "at://b/1" -> 1
        _ -> 0
      }
    },
  )
}

fn test_context() -> #(Context, config.Config) {
  let cfg =
    support.stub_config_with(
      support.unreachable_client(),
      "https://resolver.test",
      "http://localhost:8080",
    )
  let ctx = support.stub_context_with_variant_source(cfg, variant_source())
  #(ctx, cfg)
}

fn browse_body(query: String, ctx: Context, cfg: config.Config) -> String {
  let assert Ok(id) = session_store.create(cfg.sessions, a_session())
  let req =
    simulate.request(
      http.Get,
      "/xrpc/dev.mokkenstorm.crate.catalog.listReleases" <> query,
    )
    |> simulate.cookie(session_cookie, id, wisp.Signed)
  let resp = browse(req, ctx)
  assert resp.status == 200
  simulate.read_body(resp)
}

pub fn strategy_query_param_selects_the_winner_test() {
  let #(ctx, cfg) = test_context()
  let cases = [
    #("", "at://a/1", "at://b/1"),
    #("?strategy=most-recent", "at://b/1", "at://a/1"),
    #("?strategy=not-a-real-strategy", "at://a/1", "at://b/1"),
  ]
  cases
  |> list.each(fn(c) {
    let #(query, winner, loser) = c
    let body = browse_body(query, ctx, cfg)
    assert string.contains(body, "\"uri\":\"" <> winner <> "\"")
    assert !string.contains(body, "\"uri\":\"" <> loser <> "\"")
  })
}

pub fn resolved_release_includes_variant_count_test() {
  let #(ctx, cfg) = test_context()
  let body = browse_body("", ctx, cfg)
  assert string.contains(body, "\"variantCount\":2")
}