import
  std/typetraits, preserves

type
  CreditAmountKind* {.pure.} = enum
    `count`, `unbounded`
  CreditAmountCount* = BiggestInt
  `CreditAmount`* {.preservesOr.} = object
    case orKind*: CreditAmountKind
    of CreditAmountKind.`count`:
        `count`*: CreditAmountCount

    of CreditAmountKind.`unbounded`:
        `unbounded`* {.preservesLiteral: "unbounded".}: bool

  
  StreamError* {.preservesRecord: "error".} = object
    `message`*: string

  StreamListenerError*[Cap] {.preservesRecord: "stream-listener-error".} = object
    `spec`*: Preserve[Cap]
    `message`*: string

  StreamConnection*[Cap] {.preservesRecord: "stream-connection".} = object
    `source`*: Cap
    `sink`*: Cap
    `spec`*: Preserve[Cap]

  `LineMode`* {.preservesOr, pure.} = enum
    `lf`, `crlf`
  SourceKind* {.pure.} = enum
    `sink`, `StreamError`, `credit`
  SourceSink*[Cap] {.preservesRecord: "sink".} = object
    `controller`*: Cap

  SourceCredit*[Cap] {.preservesRecord: "credit".} = object
    `amount`*: CreditAmount
    `mode`*: Mode[Cap]

  `Source`*[Cap] {.preservesOr.} = object
    case orKind*: SourceKind
    of SourceKind.`sink`:
        `sink`*: SourceSink[Cap]

    of SourceKind.`StreamError`:
        `streamerror`*: StreamError

    of SourceKind.`credit`:
        `credit`*: SourceCredit[Cap]

  
  SinkKind* {.pure.} = enum
    `source`, `StreamError`, `data`, `eof`
  SinkSource*[Cap] {.preservesRecord: "source".} = object
    `controller`*: Cap

  SinkData*[Cap] {.preservesRecord: "data".} = object
    `payload`*: Preserve[Cap]
    `mode`*: Mode[Cap]

  SinkEof* {.preservesRecord: "eof".} = object
  
  `Sink`*[Cap] {.preservesOr.} = object
    case orKind*: SinkKind
    of SinkKind.`source`:
        `source`*: SinkSource[Cap]

    of SinkKind.`StreamError`:
        `streamerror`*: StreamError

    of SinkKind.`data`:
        `data`*: SinkData[Cap]

    of SinkKind.`eof`:
        `eof`*: SinkEof

  
  StreamListenerReady*[Cap] {.preservesRecord: "stream-listener-ready".} = object
    `spec`*: Preserve[Cap]

  ModeKind* {.pure.} = enum
    `bytes`, `lines`, `packet`, `object`
  ModePacket* {.preservesRecord: "packet".} = object
    `size`*: BiggestInt

  ModeObject*[Cap] {.preservesRecord: "object".} = object
    `description`*: Preserve[Cap]

  `Mode`*[Cap] {.preservesOr.} = object
    case orKind*: ModeKind
    of ModeKind.`bytes`:
        `bytes`* {.preservesLiteral: "bytes".}: bool

    of ModeKind.`lines`:
        `lines`*: LineMode

    of ModeKind.`packet`:
        `packet`*: ModePacket

    of ModeKind.`object`:
        `object`*: ModeObject[Cap]

  
proc `$`*[Cap](x: StreamListenerError[Cap] | StreamConnection[Cap] | Source[Cap] |
    Sink[Cap] |
    StreamListenerReady[Cap] |
    Mode[Cap]): string =
  `$`(toPreserve(x, Cap))

proc encode*[Cap](x: StreamListenerError[Cap] | StreamConnection[Cap] |
    Source[Cap] |
    Sink[Cap] |
    StreamListenerReady[Cap] |
    Mode[Cap]): seq[byte] =
  encode(toPreserve(x, Cap))

proc `$`*(x: CreditAmount | StreamError): string =
  `$`(toPreserve(x))

proc encode*(x: CreditAmount | StreamError): seq[byte] =
  encode(toPreserve(x))