import envoy
import gleam/bit_array
import gleam/dict
import gleam/dynamic
import gleam/dynamic/decode
import gleam/http/request
import gleam/httpc
import gleam/json
import gleam/list
import gleam/option
import gleam/result
import gleeunit
import global_value
import possum
import possum/did
import possum/handle
import possum/nsid

pub fn main() -> Nil {
  gleeunit.main()
}

const slingshot = "slingshot.microcosm.blue"

pub type Context {
  Context(handle: handle.Handle, did: did.Did, pds: String)
}

fn decode_record() -> decode.Decoder(
  dict.Dict(dynamic.Dynamic, dynamic.Dynamic),
) {
  decode.dict(decode.dynamic, decode.dynamic)
}

fn global_data() -> Context {
  global_value.create_with_unique_name("possum_test.global.data", fn() {
    use <- result.lazy_unwrap({
      use handle_string <- result.try(envoy.get("POSSUM_TEST_HANDLE"))
      use pds <- result.try(envoy.get("POSSUM_TEST_PDS"))
      use did_string <- result.try(envoy.get("POSSUM_TEST_DID"))
      use did <- result.map(did.parse(did_string) |> result.replace_error(Nil))
      let assert Ok(handle) = handle.parse(handle_string)

      Context(handle:, did:, pds:)
    })

    let assert Ok(handle) = handle.parse("bsky.app")
    let assert Ok(did_response) =
      possum.resolve_handle(handle, pds: slingshot)
      |> httpc.send

    let assert Ok(did) =
      json.parse(did_response.body, decode.at(["did"], did.decoder()))

    let assert Ok(pds_response) =
      possum.get_plc_data(did)
      |> httpc.send

    let decoder =
      decode.at(["services", "atproto_pds", "endpoint"], decode.string)

    let assert Ok("https://" <> pds) = json.parse(pds_response.body, decoder)
    Context(handle:, did:, pds:)
  })
}

pub fn get_plc_data_test() -> Nil {
  let context = global_data()

  let assert Ok(response) =
    possum.get_plc_data(context.did)
    |> httpc.send()

  let decoder = {
    use _ <- decode.field("did", decode.string)
    use _ <- decode.field("verificationMethods", decode_record())
    use _ <- decode.field("rotationKeys", decode.list(decode.string))
    use _ <- decode.field("alsoKnownAs", decode.list(decode.string))
    use _ <- decode.field("services", decode_record())
    decode.success(Nil)
  }

  let assert Ok(_) = json.parse(response.body, decoder)
  Nil
}

pub fn resolve_handle_test() -> Nil {
  let context = global_data()

  let assert Ok(response) =
    possum.resolve_handle(context.handle, pds: slingshot)
    |> httpc.send

  let decoder = decode.at(["did"], decode.string)

  let assert Ok(value) = json.parse(response.body, decoder)
  let assert Ok(_did) = did.parse(value)
  Nil
}

pub fn describe_repository_test() -> Nil {
  let context = global_data()

  let assert Ok(response) =
    possum.describe_repository(context.did, pds: context.pds)
    |> httpc.send

  let decoder = {
    use _ <- decode.field("did", did.decoder())
    use _ <- decode.field("didDoc", decode.optional(decode_record()))
    use _ <- decode.field("handle", decode.string)
    use _ <- decode.field("collections", decode.list(decode.string))
    use _ <- decode.field("handleIsCorrect", decode.bool)
    decode.success(Nil)
  }

  let assert Ok(_) = json.parse(response.body, decoder)
  Nil
}

pub fn authorized_test() -> Nil {
  let request =
    request.new()
    |> possum.authorized("wibble")

  assert list.contains(request.headers, #("authorization", "bearer wibble"))
  Nil
}

pub fn get_record_test() -> Nil {
  let context = global_data()
  let assert Ok(collection) = nsid.parse("app.bsky.actor.profile")

  let assert Ok(response) =
    possum.get_record(
      context.did,
      pds: context.pds,
      collection:,
      rkey: "self",
      cid: option.None,
    )
    |> httpc.send

  let decoder = {
    use _ <- decode.field("uri", decode.string)
    use _ <- decode.field("cid", decode.string)
    use _ <- decode.field("value", decode_record())
    decode.success(Nil)
  }

  let assert Ok(_) = json.parse(response.body, decoder)
  Nil
}

pub fn get_blob_test() -> Nil {
  let context = global_data()
  let assert Ok(bsky_profile) = nsid.parse("app.bsky.actor.profile")

  let assert Ok(bsky_query) =
    possum.get_record(
      context.did,
      pds: slingshot,
      collection: bsky_profile,
      rkey: "self",
      cid: option.None,
    )
    |> httpc.send

  let assert Ok(rkey) =
    json.parse(
      bsky_query.body,
      decode.at(["value", "avatar", "ref", "$link"], decode.string),
    )

  let assert Ok(response) =
    possum.get_blob(context.did, rkey, pds: context.pds)
    |> httpc.send_bits

  assert bit_array.byte_size(response.body) != 0
  Nil
}