ACMEApi = ref object of RootObj
  directory: Opt[ACMEDirectory]
  session: HttpSessionRef
  acmeServerURL*: Uri

ACMEAuthorizationsResponse = object
  challenges*: seq[ACMEChallenge]

ACMECertificateResponse = object
  rawCertificate*: string
  certificateExpiry*: DateTime

ACMEChallenge = object
  url*: string
  `type`*: ACMEChallengeType
  status*: ACMEChallengeStatus
  token*: ACMEChallengeToken

ACMEChallengeResponse = object
  status*: ACMEOrderStatus
  authorizations*: seq[Authorization]
  finalize*: string
  order*: string

ACMEChallengeResponseWrapper = object
  finalize*: string
  order*: string
  dns01*: ACMEChallenge

ACMEChallengeStatus {.pure.} = enum
  PENDING = "pending", PROCESSING = "processing", VALID = "valid",
  INVALID = "invalid"

ACMEChallengeToken = string

ACMEChallengeType {.pure.} = enum
  DNS01 = "dns-01", HTTP01 = "http-01", TLSALPN01 = "tls-alpn-01"

ACMECheckKind = enum
  ACMEOrderCheck, ACMEChallengeCheck

ACMECheckResponse = object
  case kind: ACMECheckKind
  of ACMEOrderCheck:
      orderStatus: ACMEOrderStatus

  of ACMEChallengeCheck:
      chalStatus: ACMEChallengeStatus

  retryAfter: Duration

ACMECompletedResponse = object
  url: string

ACMEDirectory = object
  newNonce*: string
  newOrder*: string
  newAccount*: string

ACMEFinalizeResponse = object
  status: ACMEOrderStatus

ACMEOrderResponse = object
  certificate: string
  expires: string

ACMEOrderStatus {.pure.} = enum
  PENDING = "pending", READY = "ready", PROCESSING = "processing",
  VALID = "valid", INVALID = "invalid"

ACMERegisterRequest = object
  termsOfServiceAgreed: bool
  contact: seq[Email]

ACMERegisterResponse = object
  kid*: Kid
  status*: ACMEAccountStatus

Authorization = string

Domain = string

HTTPResponse = object
  body*: JsonNode
  headers*: HttpTable

Kid = string

Nonce = string

LetsEncryptURL = "https://acme-v02.api.letsencrypt.org"

LetsEncryptURLStaging = "https://acme-staging-v02.api.letsencrypt.org"

proc certificateFinalized(self: ACMEApi; domain: Domain; finalize: Uri;
                          order: Uri; key: KeyPair; kid: Kid;
                          retries: int = DefaultFinalizeRetries): InternalRaisesFuture[
    bool, (ACMEError, CancelledError)] {.stackTrace: false, ...raises: [], gcsafe,
    tags: [RootEffect].}

proc checkCertFinalized(self: ACMEApi; order: Uri; key: KeyPair; kid: Kid;
                        retries: int = DefaultChalCompletedRetries): InternalRaisesFuture[
    bool, (ACMEError, CancelledError)] {.stackTrace: false, ...raises: [], gcsafe,
    tags: [RootEffect].}

proc checkChallengeCompleted(self: ACMEApi; checkURL: Uri; key: KeyPair;
                             kid: Kid;
                             retries: int = DefaultChalCompletedRetries): InternalRaisesFuture[
    bool, (ACMEError, CancelledError)] {.stackTrace: false, ...raises: [], gcsafe,
    tags: [RootEffect].}

proc close(self: ACMEApi): InternalRaisesFuture[void, (CancelledError,)] {.
    stackTrace: false, ...raises: [], gcsafe, tags: [RootEffect].}

proc completeChallenge(self: ACMEApi; chalURL: Uri; key: KeyPair; kid: Kid;
                       retries: int = DefaultChalCompletedRetries): InternalRaisesFuture[
    bool, (ACMEError, CancelledError)] {.stackTrace: false, ...raises: [], gcsafe,
    tags: [RootEffect].}

proc downloadCertificate(self: ACMEApi; order: Uri): InternalRaisesFuture[
    ACMECertificateResponse, (ACMEError, CancelledError)] {.stackTrace: false,
    ...raises: [], gcsafe, tags: [RootEffect].}

proc new(T: typedesc[ACMEApi]; acmeServerURL: Uri = parseUri(LetsEncryptURL)): ACMEApi

proc requestAuthorizations(self: ACMEApi; authorizations: seq[Authorization];
                           key: KeyPair; kid: Kid): InternalRaisesFuture[
    ACMEAuthorizationsResponse, (ACMEError, CancelledError)] {.
    stackTrace: false, ...raises: [], gcsafe, tags: [RootEffect].}

proc requestChallenge(self: ACMEApi; domains: seq[Domain]; key: KeyPair;
                      kid: Kid): InternalRaisesFuture[
    ACMEChallengeResponseWrapper, (ACMEError, CancelledError)] {.
    stackTrace: false, ...raises: [], gcsafe, tags: [RootEffect].}

proc requestCheck(self: ACMEApi; checkURL: Uri; checkKind: ACMECheckKind;
                  key: KeyPair; kid: Kid): InternalRaisesFuture[
    ACMECheckResponse, (ACMEError, CancelledError)] {.stackTrace: false,
    ...raises: [], gcsafe, tags: [RootEffect].}

proc requestFinalize(self: ACMEApi; domain: Domain; finalize: Uri; key: KeyPair;
                     kid: Kid): InternalRaisesFuture[ACMEFinalizeResponse,
    (ACMEError, CancelledError)] {.stackTrace: false, ...raises: [], gcsafe,
                                   tags: [RootEffect].}

proc requestGetOrder(self: ACMEApi; order: Uri): InternalRaisesFuture[
    ACMEOrderResponse, (ACMEError, CancelledError)] {.stackTrace: false,
    ...raises: [], gcsafe, tags: [RootEffect].}

proc requestNewOrder(self: ACMEApi; domains: seq[Domain]; key: KeyPair; kid: Kid): InternalRaisesFuture[
    ACMEChallengeResponse, (ACMEError, CancelledError)] {.stackTrace: false,
    ...raises: [], gcsafe, tags: [RootEffect].}

proc requestRegister(self: ACMEApi; key: KeyPair): InternalRaisesFuture[
    ACMERegisterResponse, (ACMEError, CancelledError)] {.stackTrace: false,
    ...raises: [], gcsafe, tags: [RootEffect].}

proc sendChallengeCompleted(self: ACMEApi; chalURL: Uri; key: KeyPair; kid: Kid): InternalRaisesFuture[
    ACMECompletedResponse, (ACMEError, CancelledError)] {.stackTrace: false,
    ...raises: [], gcsafe, tags: [RootEffect].}

method get(self: ACMEApi; uri: Uri): InternalRaisesFuture[HTTPResponse,
    (ACMEError, HttpError, CancelledError)] {.base, stackTrace: false,
    ...raises: [], gcsafe, tags: [RootEffect].}

method post(self: ACMEApi; uri: Uri; payload: string): InternalRaisesFuture[
    HTTPResponse, (ACMEError, HttpError, CancelledError)] {.base,
    stackTrace: false, ...raises: [], gcsafe, tags: [RootEffect].}

method requestNonce(self: ACMEApi): InternalRaisesFuture[Nonce,
    (ACMEError, CancelledError)] {.base, stackTrace: false, ...raises: [], gcsafe,
                                   tags: [RootEffect].}

template handleError(msg: string; body: untyped): untyped