import envoy
import gleam/result
import spacetraders_models/account_token.{type AccountToken}
import spacetraders_models/agent_token.{type AgentToken}
import spacetraders_models/token_parse_error.{type TokenParseError}

pub type Env {
  Env(account_token: AccountToken, agent_token: AgentToken)
}

pub type EnvError {
  MissingVar(name: String)
  InvalidTokenVar(name: String, error: TokenParseError)
}

fn get(name: String) -> Result(String, EnvError) {
  envoy.get(name)
  |> result.replace_error(MissingVar(name:))
}

fn get_token(name: String, parse: fn(String) -> Result(token, TokenParseError)) {
  get(name)
  |> result.try(fn(value) {
    parse(value) |> result.map_error(InvalidTokenVar(name:, error: _))
  })
}

pub fn get_account_token() -> Result(AccountToken, EnvError) {
  get_token("ACCOUNT_TOKEN", account_token.parse)
}

pub fn get_agent_token() -> Result(AgentToken, EnvError) {
  get_token("AGENT_TOKEN", agent_token.parse)
}

pub fn load_env() -> Result(Env, EnvError) {
  use account_token <- result.try(get_account_token())
  use agent_token <- result.try(get_agent_token())
  Ok(Env(account_token:, agent_token:))
}

pub fn load_env_unsafe() -> Env {
  let assert Ok(account_token) = get_account_token()
    as "Missing or invalid account token"
  let assert Ok(agent_token) = get_agent_token()
    as "Missing or invalid agent token"
  Env(account_token:, agent_token:)
}