type AsgiApp = async (Scope, async () -> Event, async (Event) -> Unit) -> Unit

type AsgiAppInstance = async (async () -> Event, async (Event) -> Unit) -> Unit

type Handler = (Request) -> Response

type LegacyAsgiApp = (Scope) -> (async (async () -> Event, async (Event) -> Unit) -> Unit)

type Middleware = ((Request) -> Response) -> ((Request) -> Response)

type Receive = async () -> Event

type Send = async (Event) -> Unit

type StreamHandler = (Request) -> StreamingResponse

pub(all) enum AsgiApplication {
  Single(async (Scope, async () -> Event, async (Event) -> Unit) -> Unit)
  Legacy((Scope) -> (async (async () -> Event, async (Event) -> Unit) -> Unit))
}

pub(all) struct AsgiVersion {
  version : String
  spec_version : String
} derive(Eq)

pub(all) struct ConformanceReport {
  total : Int
  passed : Int
  failures : Array[String]
} derive(Eq)

pub(all) enum Drain {
  Complete
  Disconnected
  Truncated
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum Event {
  HttpRequest(body~ : Bytes, more_body~ : Bool)
  HttpDisconnect
  HttpResponseStart(status~ : Int, headers~ : Array[(String, String)], trailers~ : Bool)
  HttpResponseBody(body~ : Bytes, more_body~ : Bool)
  HttpResponseTrailers(headers~ : Array[(String, String)], more_trailers~ : Bool)
  HttpResponsePush(path~ : String, headers~ : Array[(String, String)])
  HttpResponsePathSend(path~ : String)
  HttpResponseZeroCopySend(fd~ : Int, offset~ : Int?, count~ : Int?, more_body~ : Bool)
  HttpResponseDebug(info~ : Json)
  HttpResponseEarlyHint(links~ : Array[String])
  WebSocketConnect
  WebSocketReceive(text~ : String?, bytes~ : Bytes?)
  WebSocketDisconnect(code~ : Int, reason~ : String?)
  WebSocketAccept(subprotocol~ : String?, headers~ : Array[(String, String)])
  WebSocketSendText(String)
  WebSocketSendBytes(Bytes)
  WebSocketClose(code~ : Int, reason~ : String)
  WebSocketHttpResponseStart(status~ : Int, headers~ : Array[(String, String)], trailers~ : Bool)
  WebSocketHttpResponseBody(body~ : Bytes, more_body~ : Bool)
  LifespanStartup
  LifespanShutdown
  LifespanStartupComplete
  LifespanStartupFailed(message~ : String)
  LifespanShutdownComplete
  LifespanShutdownFailed(message~ : String)
  Other(type_~ : String, payload~ : Json)
} derive(Eq)

pub(all) enum EventOrderError {
  BodyBeforeStart
  DuplicateResponseStart
  EarlyHintAfterStart
  BodyAfterComplete
  UnexpectedTrailers
  TrailersBeforeBody
  MissingResponseStart
  IncompleteBody
  MissingTrailers
  EventAfterComplete
  DebugAfterStart
  DuplicateDebug
  PushBeforeStart
  PathSendMixedWithBody
  IllegalResponseHeader
  FrameBeforeAccept
  DuplicateAccept
  EventAfterClose
  DenialBodyBeforeStart
  DenialAfterAccept
  AcceptAfterDenial
  IncompleteDenial
  MissingHandshakeReply
  DuplicateLifespanReply
  ShutdownBeforeStartup
  NonResponseEvent
} derive(Eq)

pub(all) struct Extensions {
  tls : TlsExtension?
  http_response_push : Bool
  http_response_trailers : Bool
  http_response_pathsend : Bool
  http_response_zerocopysend : Bool
  http_response_early_hint : Bool
  http_response_debug : Bool
  websocket_http_response : Bool
  custom : Map[String, Json]
} derive(Eq)

pub(all) enum Http2HeaderError {
  MissingMethod
  MissingScheme
  MissingPath
  EmptyPath
  DuplicatePseudoHeader(String)
  UnknownPseudoHeader(String)
  PseudoHeaderAfterRegular(String)
} derive(Eq)

pub(all) struct HttpScope {
  http_version : String
  http_method : String
  scheme : String
  path : String
  raw_path : Bytes
  query_string : Bytes
  root_path : String
  headers : Array[(String, String)]
  client : (String, Int)?
  server : (String, Int?)?
  asgi : AsgiVersion
  extensions : Extensions
  state : Map[String, Json]
}

pub(all) struct LifespanHandler {
  on_startup : (LifespanScope) -> LifespanReply
  on_shutdown : (LifespanScope) -> LifespanReply
}

pub(all) enum LifespanReply {
  Complete
  Failed(message~ : String)
} derive(Eq)

pub(all) struct LifespanScope {
  asgi : AsgiVersion
  state : Map[String, Json]
}

pub(all) struct PushPromise {
  path : String
  headers : Array[(String, String)]
} derive(Eq)

pub(all) struct Request {
  http_method : String
  path : String
  query_string : Bytes
  headers : Array[(String, String)]
  body : Bytes
} derive(Eq)

pub(all) struct Response {
  status : Int
  headers : Array[(String, String)]
  body : Bytes
} derive(Eq)

pub(all) enum Scope {
  Http(HttpScope)
  WebSocket(WebSocketScope)
  Lifespan(LifespanScope)
}

pub(all) struct StreamingResponse {
  status : Int
  headers : Array[(String, String)]
  chunks : Array[Bytes]
  trailers : Array[(String, String)]
  early_hints : Array[Array[String]]
} derive(Eq)

pub(all) struct TestClient {
  app : (Request) -> Array[Event]
  root_path : String
  base_headers : Array[(String, String)]
  client : (String, Int)?
  server : (String, Int?)?
  extensions : Extensions
}

pub(all) struct TestResponse {
  status : Int
  headers : Array[(String, String)]
  body : Bytes
  trailers : Array[(String, String)]
  pushes : Array[PushPromise]
  pathsend : String?
  zerocopysend : ZeroCopySend?
  debug : Array[Json]
  early_hints : Array[Array[String]]
} derive(Eq)

pub(all) struct TlsExtension {
  server_cert : String?
  client_cert_chain : Array[String]
  client_cert_name : String?
  client_cert_error : String?
  tls_version : Int?
  cipher_suite : Int?
} derive(Eq)

pub(all) struct WebSocketHandler {
  on_connect : (WebSocketScope) -> WsAccept
  on_receive : (WsMessage) -> Array[WsSend]
  on_disconnect : (Int, String?) -> Array[WsSend]
}