import
  preserves, std/tables

type
  PCompoundKind* {.pure.} = enum
    `rec`, `arr`, `dict`
  PCompoundRec*[Cap] {.acyclic, preservesRecord: "rec".} = ref object
    `label`*: Preserve[Cap]
    `fields`*: seq[Pattern[Cap]]

  PCompoundArr*[Cap] {.acyclic, preservesRecord: "arr".} = ref object
    `items`*: seq[Pattern[Cap]]

  PCompoundDict*[Cap] {.acyclic, preservesRecord: "dict".} = ref object
    `entries`*: Table[Preserve[Cap], Pattern[Cap]]

  `PCompound`*[Cap] {.acyclic, preservesOr.} = ref object
    case orKind*: PCompoundKind
    of PCompoundKind.`rec`:
        `rec`*: PCompoundRec[Cap]

    of PCompoundKind.`arr`:
        `arr`*: PCompoundArr[Cap]

    of PCompoundKind.`dict`:
        `dict`*: PCompoundDict[Cap]

  
  Reject*[Cap] {.acyclic, preservesRecord: "reject".} = ref object
    `pattern`*: Pattern[Cap]

  CaveatsFieldKind* {.pure.} = enum
    `present`, `invalid`, `absent`
  CaveatsFieldPresent*[Cap] {.acyclic, preservesDictionary.} = ref object
    `caveats`*: seq[Caveat[Cap]]

  CaveatsFieldInvalid*[Cap] {.preservesDictionary.} = object
    `caveats`*: Preserve[Cap]

  CaveatsFieldAbsent* {.preservesDictionary.} = object
  
  `CaveatsField`*[Cap] {.acyclic, preservesOr.} = ref object
    case orKind*: CaveatsFieldKind
    of CaveatsFieldKind.`present`:
        `present`*: CaveatsFieldPresent[Cap]

    of CaveatsFieldKind.`invalid`:
        `invalid`*: CaveatsFieldInvalid[Cap]

    of CaveatsFieldKind.`absent`:
        `absent`*: CaveatsFieldAbsent

  
  SturdyDescriptionDetail*[Cap] {.preservesDictionary.} = object
    `key`*: seq[byte]
    `oid`*: Preserve[Cap]

  PAnd*[Cap] {.acyclic, preservesRecord: "and".} = ref object
    `patterns`*: seq[Pattern[Cap]]

  SturdyStepDetail*[Cap] = Parameters[Cap]
  Rewrite*[Cap] {.acyclic, preservesRecord: "rewrite".} = ref object
    `pattern`*: Pattern[Cap]
    `template`*: Template[Cap]

  Parameters*[Cap] = Preserve[Cap]
  TRef* {.preservesRecord: "ref".} = object
    `binding`*: BiggestInt

  PBind*[Cap] {.acyclic, preservesRecord: "bind".} = ref object
    `pattern`*: Pattern[Cap]

  Lit*[Cap] {.preservesRecord: "lit".} = object
    `value`*: Preserve[Cap]

  TCompoundKind* {.pure.} = enum
    `rec`, `arr`, `dict`
  TCompoundRec*[Cap] {.acyclic, preservesRecord: "rec".} = ref object
    `label`*: Preserve[Cap]
    `fields`*: seq[Template[Cap]]

  TCompoundArr*[Cap] {.acyclic, preservesRecord: "arr".} = ref object
    `items`*: seq[Template[Cap]]

  TCompoundDict*[Cap] {.acyclic, preservesRecord: "dict".} = ref object
    `entries`*: Table[Preserve[Cap], Template[Cap]]

  `TCompound`*[Cap] {.acyclic, preservesOr.} = ref object
    case orKind*: TCompoundKind
    of TCompoundKind.`rec`:
        `rec`*: TCompoundRec[Cap]

    of TCompoundKind.`arr`:
        `arr`*: TCompoundArr[Cap]

    of TCompoundKind.`dict`:
        `dict`*: TCompoundDict[Cap]

  
  SturdyPathStepDetail*[Cap] = Parameters[Cap]
  `PAtom`* {.preservesOr, pure.} = enum
    `Boolean`, `Float`, `Double`, `SignedInteger`, `String`, `ByteString`,
    `Symbol`
  PDiscard* {.preservesRecord: "_".} = object
  
  TemplateKind* {.pure.} = enum
    `TAttenuate`, `TRef`, `Lit`, `TCompound`
  `Template`*[Cap] {.acyclic, preservesOr.} = ref object
    case orKind*: TemplateKind
    of TemplateKind.`TAttenuate`:
        `tattenuate`*: TAttenuate[Cap]

    of TemplateKind.`TRef`:
        `tref`*: TRef

    of TemplateKind.`Lit`:
        `lit`*: Lit[Cap]

    of TemplateKind.`TCompound`:
        `tcompound`*: TCompound[Cap]

  
  CaveatKind* {.pure.} = enum
    `Rewrite`, `Alts`, `Reject`, `unknown`
  CaveatUnknown*[Cap] = Preserve[Cap]
  `Caveat`*[Cap] {.acyclic, preservesOr.} = ref object
    case orKind*: CaveatKind
    of CaveatKind.`Rewrite`:
        `rewrite`*: Rewrite[Cap]

    of CaveatKind.`Alts`:
        `alts`*: Alts[Cap]

    of CaveatKind.`Reject`:
        `reject`*: Reject[Cap]

    of CaveatKind.`unknown`:
        `unknown`*: CaveatUnknown[Cap]

  
  PNot*[Cap] {.acyclic, preservesRecord: "not".} = ref object
    `pattern`*: Pattern[Cap]

  SturdyRef*[Cap] {.acyclic, preservesRecord: "ref".} = ref object
    `parameters`*: Parameters[Cap]

  WireRefKind* {.pure.} = enum
    `mine`, `yours`
  WireRefMine* {.preservesTuple.} = object
    `field0`* {.preservesLiteral: "0".}: tuple[]
    `oid`*: Oid

  WireRefYours*[Cap] {.acyclic, preservesTuple.} = ref object
    `field0`* {.preservesLiteral: "1".}: tuple[]
    `oid`*: Oid
    `attenuation`* {.preservesTupleTail.}: seq[Caveat[Cap]]

  `WireRef`*[Cap] {.acyclic, preservesOr.} = ref object
    case orKind*: WireRefKind
    of WireRefKind.`mine`:
        `mine`*: WireRefMine

    of WireRefKind.`yours`:
        `yours`*: WireRefYours[Cap]

  
  TAttenuate*[Cap] {.acyclic, preservesRecord: "attenuate".} = ref object
    `template`*: Template[Cap]
    `attenuation`*: seq[Caveat[Cap]]

  Oid* = BiggestInt
  Alts*[Cap] {.acyclic, preservesRecord: "or".} = ref object
    `alternatives`*: seq[Rewrite[Cap]]

  PatternKind* {.pure.} = enum
    `PDiscard`, `PAtom`, `PEmbedded`, `PBind`, `PAnd`, `PNot`, `Lit`,
    `PCompound`
  `Pattern`*[Cap] {.acyclic, preservesOr.} = ref object
    case orKind*: PatternKind
    of PatternKind.`PDiscard`:
        `pdiscard`*: PDiscard

    of PatternKind.`PAtom`:
        `patom`*: PAtom

    of PatternKind.`PEmbedded`:
        `pembedded`* {.preservesLiteral: "Embedded".}: bool

    of PatternKind.`PBind`:
        `pbind`*: PBind[Cap]

    of PatternKind.`PAnd`:
        `pand`*: PAnd[Cap]

    of PatternKind.`PNot`:
        `pnot`*: PNot[Cap]

    of PatternKind.`Lit`:
        `lit`*: Lit[Cap]

    of PatternKind.`PCompound`:
        `pcompound`*: PCompound[Cap]

  
proc `$`*[Cap](x: PCompound[Cap] | Reject[Cap] | CaveatsField[Cap] |
    SturdyDescriptionDetail[Cap] |
    PAnd[Cap] |
    Rewrite[Cap] |
    PBind[Cap] |
    Lit[Cap] |
    TCompound[Cap] |
    Template[Cap] |
    Caveat[Cap] |
    PNot[Cap] |
    SturdyRef[Cap] |
    WireRef[Cap] |
    TAttenuate[Cap] |
    Alts[Cap] |
    Pattern[Cap]): string =
  `$`(toPreserve(x, Cap))

proc encode*[Cap](x: PCompound[Cap] | Reject[Cap] | CaveatsField[Cap] |
    SturdyDescriptionDetail[Cap] |
    PAnd[Cap] |
    Rewrite[Cap] |
    PBind[Cap] |
    Lit[Cap] |
    TCompound[Cap] |
    Template[Cap] |
    Caveat[Cap] |
    PNot[Cap] |
    SturdyRef[Cap] |
    WireRef[Cap] |
    TAttenuate[Cap] |
    Alts[Cap] |
    Pattern[Cap]): seq[byte] =
  encode(toPreserve(x, Cap))

proc `$`*(x: TRef | PDiscard | Oid): string =
  `$`(toPreserve(x))

proc encode*(x: TRef | PDiscard | Oid): seq[byte] =
  encode(toPreserve(x))