import at_record_web/model.{
  ArtistHit, Discogs, Failure, Form, Model, Notice, Success, blank_discogs,
  blank_form,
}
import at_record_web/msg.{
  FormArtist, FormCounterparty, FormFolder, FormPriceAmount, FormPriceCurrency,
  FormRating, FormSleeveGrade, GotAdd, GotArtists, SubmitAdd, UseArtist,
}
import at_record_web/pages/add
import at_record_web/update.{update}
import gleam/option.{None, Some}
import gleam/string
import lustre/element
import support.{base, logged_in}

pub fn submit_add_rejects_whitespace_only_title_test() {
  let model =
    Model(..base(), form: Form(..blank_form(), title: "  ", artist: "x"))
  let #(after, _) = update(model, SubmitAdd)
  assert after.notice == Some(Notice(Failure, "Title and artist are required."))
}

pub fn submit_add_rejects_an_unparseable_price_test() {
  let model =
    Model(
      ..base(),
      form: Form(
        ..blank_form(),
        title: "Spiderland",
        artist: "Slint",
        price_amount: "free",
      ),
    )
  let #(after, _) = update(model, SubmitAdd)
  assert after.notice == Some(Notice(Failure, "Enter a valid price amount."))
  assert after.busy == False
}

pub fn submit_add_accepts_a_blank_price_test() {
  let model =
    Model(
      ..base(),
      form: Form(..blank_form(), title: "Spiderland", artist: "Slint"),
    )
  let #(after, _) = update(model, SubmitAdd)
  assert after.busy == True
  assert after.notice == None
}

pub fn submit_add_accepts_a_valid_price_test() {
  let model =
    Model(
      ..base(),
      form: Form(
        ..blank_form(),
        title: "Spiderland",
        artist: "Slint",
        price_amount: "40.00",
      ),
    )
  let #(after, _) = update(model, SubmitAdd)
  assert after.busy == True
  assert after.notice == None
}

pub fn form_sleeve_grade_updates_form_test() {
  let #(model, _) = update(base(), FormSleeveGrade("VG+"))
  assert model.form.sleeve_grade == "VG+"
}

pub fn form_rating_updates_form_test() {
  let #(model, _) = update(base(), FormRating("4"))
  assert model.form.rating == "4"
}

pub fn form_folder_updates_form_test() {
  let #(model, _) = update(base(), FormFolder("Rock A-M"))
  assert model.form.folder == "Rock A-M"
}

pub fn form_price_amount_updates_form_test() {
  let #(model, _) = update(base(), FormPriceAmount("40.00"))
  assert model.form.price_amount == "40.00"
}

pub fn form_price_currency_updates_form_test() {
  let #(model, _) = update(base(), FormPriceCurrency("USD"))
  assert model.form.price_currency == "USD"
}

pub fn form_counterparty_updates_form_test() {
  let #(model, _) = update(base(), FormCounterparty("Record shop"))
  assert model.form.counterparty == "Record shop"
}

pub fn got_add_success_sets_notice_with_title_test() {
  let model =
    Model(..logged_in(), form: Form(..blank_form(), title: "Spiderland"))
  let #(after, _) = update(model, GotAdd(Ok(Nil)))
  assert case after.notice {
    Some(Notice(Success, message)) -> string.contains(message, "Spiderland")
    _ -> False
  }
}

pub fn form_artist_debounces_and_clears_id_test() {
  let seeded =
    Model(..base(), discogs: Discogs(..blank_discogs(), artist_id: Some("123")))
  let #(model, effect) = update(seeded, FormArtist("Slint"))
  assert model.form.artist == "Slint"
  assert model.discogs.artist_id == None
  assert effect != support.empty_effect()
}

pub fn use_artist_sets_name_and_id_test() {
  let hit = ArtistHit(id: "42", name: "Slint", thumb_url: None)
  let #(model, _effect) = update(base(), UseArtist(hit))
  assert model.form.artist == "Slint"
  assert model.discogs.artist_id == Some("42")
}

pub fn got_artists_populates_suggestions_test() {
  let hit = ArtistHit(id: "42", name: "Slint", thumb_url: None)
  let #(model, _effect) = update(base(), GotArtists(Ok([hit])))
  assert model.discogs.artist_results == [hit]
}

pub fn add_view_no_longer_carries_the_discogs_section_test() {
  let html = add.view(logged_in()) |> element.to_string
  assert !string.contains(html, "DISCOGS ACCOUNT")
}

pub fn add_submits_through_a_form_test() {
  let html = add.view(logged_in()) |> element.to_string
  assert string.contains(html, "<form")
  assert string.contains(html, "type=\"submit\"")
}

pub fn segment_buttons_never_submit_the_form_test() {
  let html = add.view(logged_in()) |> element.to_string
  // Inside a <form>, a bare <button> defaults to type=submit: tapping
  // OWNED/WANTED would submit the whole page. The segment must opt out.
  assert string.contains(html, "class=\"segment\"")
  assert !string.contains(html, "<button class=\"is-active\">")
  assert string.contains(html, "class=\"is-active\" type=\"button\"")
}