import gleam/dynamic/decode.{type Decoder}
import gleam/json
import models/account.{type Account}
import models/agent.{type Agent}
import models/agent_symbol.{type AgentSymbol}
import models/contract.{type Contract}
import models/faction.{type Faction}
import models/faction_symbol.{type FactionSymbol}
import models/ship.{type Ship}
import utils/api.{type ApiResponse}
import utils/auth.{type AccountToken, type AgentToken, AccountAuth, AgentAuth}

pub type GetAccountResponse {
  GetAccountResponse(account: Account)
}

fn get_account_response_decoder() -> Decoder(GetAccountResponse) {
  use account <- decode.field("account", account.decoder())
  decode.success(GetAccountResponse(account:))
}

pub fn get_account(token: AgentToken) -> ApiResponse(GetAccountResponse) {
  let request = api.get(AgentAuth(token), "/my/account")
  use response <- api.try_send(request)
  case response.status {
    200 -> api.parse_data_response(response, get_account_response_decoder())
    _ -> api.parse_error_response(response)
  }
}

pub type RegisterNewAgentResponse {
  RegisterNewAgentResponse(
    token: AgentToken,
    agent: Agent,
    faction: Faction,
    contract: Contract,
    ships: List(Ship),
  )
}

fn register_new_agent_response_decoder() -> Decoder(RegisterNewAgentResponse) {
  use token <- decode.field("token", auth.agent_token_decoder())
  use agent <- decode.field("agent", agent.decoder())
  use faction <- decode.field("faction", faction.decoder())
  use contract <- decode.field("contract", contract.decoder())
  use ships <- decode.field("ships", decode.list(ship.decoder()))
  decode.success(RegisterNewAgentResponse(
    token:,
    agent:,
    faction:,
    contract:,
    ships:,
  ))
}

pub fn register_new_agent(
  token: AccountToken,
  agent_symbol: AgentSymbol,
  faction_symbol: FactionSymbol,
) -> ApiResponse(RegisterNewAgentResponse) {
  let request =
    api.post_json(
      AccountAuth(token),
      "/register",
      json.object([
        #("symbol", agent_symbol.encode(agent_symbol)),
        #("faction", faction_symbol.encode(faction_symbol)),
      ]),
    )
  use response <- api.try_send(request)
  case response.status {
    201 ->
      api.parse_data_response(response, register_new_agent_response_decoder())
    _ -> api.parse_error_response(response)
  }
}