BpmRange = tuple[min: float, max: float]

Difficulty {.pure.} = enum
  Basic = "basic", Advanced = "advanced", Extreme = "extreme", Edit = "edit"

Memson = ref object
  songTitle*: string         ## The title of the chart's song.
  artist*: string            ## The artist of the chart's song.
  difficulty*: Difficulty    ## The difficulty of the chart.
  level*: int                ## The difficulty as level range (Usually 1-10) of the chart.
  bpm*: float                ## The BPM of the chart. May not be accurate if the `bpmRange` is set.
  bpmRange*: BpmRange        ## The BPM-Range of the chart.
                             ## May only be set if BPM changes occur in the chart.
  sections*: seq[Section]    ## The sections of the chart.
  

Note = ref object
  time*: int                 ## The timing id when this note has to be pressed.
  partIndex*: int            ## In which part this note was originally defined.
  case kind*: NoteType       ## Which kind this Note is (Note or Hold)
  of NoteType.Hold:
      animationStartIndex*: int ## On which position the animation for the hold starts on.
      releaseTime*: int      ## The release timing id when the hold has to be released.
      releasePart*: int      ## The part in which the the hold was released.
      releaseSection*: int   ## In which section it has to look for the timing id.
    
  else:
      nil

  

NoteRange = range[0 .. 15]

NoteType {.pure.} = enum
  Note = "note", Hold = "hold"

RowIndex = range[0 .. 3]

Section = ref object
  index*: int                ## The index of this section.
  bpm*: float                ## What BPM this section is using.
  partCount*: int            ## How many parts this section originally consisted of.
  timings*: seq[int]         ## Timing ids which defined when a note needs to be pressed.
  snaps*: seq[Snap]          ## The snaps for the timing.
  noteCount*: uint           ## How many notes in total are stored
  notes*: OrderedTable[NoteRange, seq[Note]] ## Notes that need to be played.
                                             ## Keys are the positions, which start from top-left to bottom-right.
                                             ## _`NoteRange`
  

Snap = ref object
  length*: int               ## How many notes fit into a Snap.
  partIndex*: int            ## In which part of the original section this snap is defined.
  row*: RowIndex             ## The row in which this snap is defined.
  

func newHold(time: int = 0; partIndex: int = 0; animationStartIndex: int = 0;
             releaseTime: int = 0; releasePart: int = 0; releaseSection: int = 1): Note {.
    ...raises: [], tags: [].}

func newMemson(songTitle: string = ""; artist: string = "";
               difficulty: Difficulty = Difficulty.Basic; level: int = 1;
               bpm: float = 0.0; bpmRange: BpmRange;
               sections: seq[Section] = @[]): Memson {....raises: [], tags: [].}

func newNote(time: int = 0; partIndex: int = 0): Note {....raises: [], tags: [].}

func newSection(index: int = 1; bpm: float = 0.0; partCount: int = 1;
                timings: seq[int] = @[]; snaps: seq[Snap] = @[];
                noteCount: uint = 0;
                notes: OrderedTable[NoteRange, seq[Note]] = initOrderedTable()): Section {.
    ...raises: [], tags: [].}

func newSnap(length: int = 1; partIndex: int = 0; row = 0): Snap {....raises: [],
    tags: [].}

func parseDifficulty(input: string): Difficulty {....raises: [], tags: [].}