import envoy
import gleam/erlang/process
import gleam/http
import gleeunit
import global_value
import pog
import server
import server/context.{type Context, Context}
import server/router
import server/seed
import shared/contract/login as login_contract
import wisp.{type Request}
import wisp/simulate

pub fn main() {
  gleeunit.main()
}

fn global_context() -> Context {
  global_value.create_with_unique_name("server_test.global.data", fn() {
    let db_process_name = process.new_name("db_conn")
    let db = pog.named_connection(db_process_name)

    let assert Ok(static_directory) = server.static_directory()
    let assert Ok(secret_key) = envoy.get("SECRET_KEY")
    let assert Ok(pog_config) = server.read_connection_uri(db_process_name)
    let assert Ok(_db_process) = pog.start(pog_config)

    let ctx = Context(static_directory:, db:, secret_key:)
    let assert Ok(_result) = seed.germinate(ctx)

    ctx
  })
}

pub fn with_context(next: fn(Context) -> a) -> Nil {
  let ctx = global_context()
  let transaction = fn(db) {
    next(Context(..ctx, db:))
    Error(Nil)
  }

  let assert Error(pog.TransactionRolledBack(Nil)) =
    pog.transaction(ctx.db, transaction)

  Nil
}

pub fn with_authorization(
  next next_request: Request,
  ctx ctx: Context,
) -> wisp.Request {
  let body =
    login_contract.RequestBody(email: seed.email, password: seed.password)
    |> login_contract.request_to_json()

  let req =
    simulate.browser_request(http.Post, "/api/login")
    |> simulate.json_body(body)

  let resp = router.handle_request(req, ctx)
  simulate.session(next_request, req, resp)
}