//// Replay must retain foreign fields and reject protocol or image mismatches.
//// Direct inputs cover invalid metadata that daemon admission rejects first.

import albedo/openai_api as openai
import albedo/openai_api/request
import albedo/openai_api/types
import gleam/dynamic/decode
import gleam/json
import gleam/list
import gleam/option.{None, Some}
import gleam/result
import gleam/string
import gleam/string_tree

fn body(protocol: types.Protocol, request: types.Request) -> String {
  let assert Ok(body) = request.encode(protocol, request)
  string_tree.to_string(body)
}

pub fn service_tier_is_encoded_only_when_explicit_for_supported_policies_test() -> Nil {
  let ordinary = openai.request("model", [])
  let assert Ok(Nil) =
    json.parse(body(types.Responses, ordinary), {
      use _ <- decode.field("model", decode.string)
      decode.success(Nil)
    })
  let fast =
    types.Request(
      ..ordinary,
      options: types.Options(..types.defaults, service_tier: Some("priority")),
    )
  let assert Ok("priority") =
    json.parse(body(types.Responses, fast), {
      use tier <- decode.field("service_tier", decode.string)
      decode.success(tier)
    })
  let codex_client =
    openai.codex_client(
      "https://chatgpt.com/backend-api",
      "token",
      "account",
      "session",
    )
  let assert True =
    list.contains(openai.request_headers(codex_client, fast), #(
      "x-codex-routing-hint",
      "model=model;tier=priority",
    ))
  let assert True =
    list.contains(openai.request_headers(codex_client, ordinary), #(
      "x-codex-routing-hint",
      "model=model",
    ))
  let assert Ok("priority") =
    json.parse(
      string_tree.to_string(result.unwrap(
        request.encode_with_policy(
          types.Responses,
          types.Codex("account", "session"),
          fast,
        ),
        string_tree.from_string(""),
      )),
      {
        use tier <- decode.field("service_tier", decode.string)
        decode.success(tier)
      },
    )
  list.each(
    [
      types.OpenCodeGo("session", "org"),
      types.Mistral("session"),
    ],
    fn(policy) {
      let assert Ok(None) =
        json.parse(
          string_tree.to_string(result.unwrap(
            request.encode_with_policy(types.ChatCompletions, policy, fast),
            string_tree.from_string(""),
          )),
          {
            use _ <- decode.field("model", decode.string)
            use service_tier <- decode.optional_field(
              "service_tier",
              None,
              decode.optional(decode.string),
            )
            decode.success(service_tier)
          },
        )
      Nil
    },
  )
  Nil
}

pub fn replay_preserves_unknown_fields_and_refuses_other_protocol_test() -> Result(
  string_tree.StringTree,
  types.Error,
) {
  let assert Ok(item) =
    json.parse(
      "{\"type\":\"reasoning\",\"encrypted_content\":\"opaque\",\"future\":{\"x\":1}}",
      types.replay_decoder(types.Responses),
    )
  let request = openai.request("model", [types.Replay(item)])
  let encoded = body(types.Responses, request)
  assert json.parse(
      encoded,
      decode.at(["input"], decode.list(decode.at(["future", "x"], decode.int))),
    )
    == Ok([1])
  let assert Error(types.InvalidRequest(_)) =
    request.encode(types.ChatCompletions, request)
}

pub fn validates_image_metadata_bounds_test() -> Result(
  types.Image,
  types.Error,
) {
  let assert Error(types.InvalidRequest(_)) =
    types.image("image/gif", "aGVsbG8=", 2, 3, 5)
  let assert Error(types.InvalidRequest(_)) =
    types.image("image/png", "aGVsbG8=", 10_000, 5000, 5)
  let assert Error(types.InvalidRequest(_)) =
    types.image("image/png", "aGVsbG8=", 2, 3, types.max_image_bytes + 1)
}

// Persisting a valid image must not reinterpret its padded base64 length as
// the decoded file length. Stored payloads remain lazy during validation.
pub fn inline_and_stored_images_have_the_same_size_contract_test() -> Nil {
  list.each(
    [
      types.max_image_bytes - 1,
      types.max_image_bytes,
      types.max_image_bytes + 1,
    ],
    fn(bytes) {
      let encoded_size = 4 * { { bytes + 2 } / 3 }
      let data = string.repeat("A", encoded_size)
      let inline = types.image("image/png", data, 2, 3, bytes)
      let stored =
        types.stored_image(
          "image/png",
          "hash",
          encoded_size,
          fn() { panic as "metadata validation read a stored payload" },
          2,
          3,
          bytes,
        )
      assert result.map(inline, types.image_meta)
        == result.map(stored, types.image_meta)
      assert result.is_ok(inline) == { bytes <= types.max_image_bytes }
    },
  )
}