TiledColor = (float, float, float, float)

TiledRegion = object
  x, y, width, height: int

TiledOrientation = enum
  Orthogonal, Orthographic

TiledRenderorder = enum
  RightDown

TiledValueType = enum
  tvInt, tvFloat, tvString, tvColor, tvBool

TiledValue = ref object
  case valueType*: TiledValueType
  of tvInt:
      valueInt*: int

  of tvFloat:
      valueFloat*: float

  of tvString:
      valueString*: string

  of tvColor:
      valueColor*: (float, float, float, float)

  of tvBool:
      valueBool*: bool

  

TiledObject = ref object of RootObj
  x, y, width, height, rotation: float
  properties: TableRef[string, TiledValue]

TiledPolygon = ref object of TiledObject
  points: seq[(float, float)]

TiledPolyline = ref object of TiledObject
  points: seq[(float, float)]

TiledPoint = ref object of TiledObject

TiledEllipse = ref object of TiledObject

TiledTileset = ref object
  name: string
  imagePath: string
  tilewidth, tileheight: int
  firstgid: int
  width, height: int
  tilecount: int
  columns: int
  regions: seq[TiledRegion]

TiledLayer = ref object
  name: string
  width, height: int
  tiles: seq[int]

TiledObjectGroup = ref object
  objects: seq[TiledObject]

TiledMap = ref object
  version: string
  tiledversion: string
  orientation: TiledOrientation
  renderorder: TiledRenderorder
  nextlayerid, nextobjectid: int
  width, height: int
  tilewidth, tileheight: int
  infinite: bool
  tilesets: seq[TiledTileset]
  layers: seq[TiledLayer]
  objectGroups: seq[TiledObjectGroup]

proc `$`(r: TiledRegion): string {.
raises: [], tags: []
.}

proc version(map: TiledMap): string {.
inline, raises: [], tags: []
.}

proc tiledversion(map: TiledMap): string {.
inline, raises: [], tags: []
.}

proc orientation(map: TiledMap): TiledOrientation {.
inline, raises: [], tags: []
.}

proc renderorder(map: TiledMap): TiledRenderorder {.
inline, raises: [], tags: []
.}

proc width(map: TiledMap): int {.
inline, raises: [], tags: []
.}

proc height(map: TiledMap): int {.
inline, raises: [], tags: []
.}

proc tilewidth(map: TiledMap): int {.
inline, raises: [], tags: []
.}

proc tileheight(map: TiledMap): int {.
inline, raises: [], tags: []
.}

proc infinite(map: TiledMap): bool {.
inline, raises: [], tags: []
.}

proc tilesets(map: TiledMap): seq[TiledTileset] {.
inline, raises: [], tags: []
.}

proc layers(map: TiledMap): seq[TiledLayer] {.
inline, raises: [], tags: []
.}

proc objectGroups(map: TiledMap): seq[TiledObjectGroup] {.
inline, raises: [], tags: []
.}

proc name(layer: TiledLayer): string {.
inline, raises: [], tags: []
.}

proc width(layer: TiledLayer): int {.
inline, raises: [], tags: []
.}

proc height(layer: TiledLayer): int {.
inline, raises: [], tags: []
.}

proc tiles(layer: TiledLayer): seq[int] {.
inline, raises: [], tags: []
.}

proc objects(layer: TiledObjectGroup): seq[TiledObject] {.
inline, raises: [], tags: []
.}

proc name(tileset: TiledTileset): string {.
inline, raises: [], tags: []
.}

proc imagePath(tileset: TiledTileset): string {.
inline, raises: [], tags: []
.}

proc tilewidth(tileset: TiledTileset): int {.
inline, raises: [], tags: []
.}

proc tileheight(tileset: TiledTileset): int {.
inline, raises: [], tags: []
.}

proc firstgid(tileset: TiledTileset): int {.
inline, raises: [], tags: []
.}

proc width(tileset: TiledTileset): int {.
inline, raises: [], tags: []
.}

proc height(tileset: TiledTileset): int {.
inline, raises: [], tags: []
.}

proc tilecount(tileset: TiledTileset): int {.
inline, raises: [], tags: []
.}

proc columns(tileset: TiledTileset): int {.
inline, raises: [], tags: []
.}

proc regions(tileset: TiledTileset): seq[TiledRegion] {.
inline, raises: [], tags: []
.}

proc x(r: TiledRegion): auto {.
inline, raises: [], tags: []
.}

proc y(r: TiledRegion): auto {.
inline, raises: [], tags: []
.}

proc width(r: TiledRegion): auto {.
inline, raises: [], tags: []
.}

proc height(r: TiledRegion): auto {.
inline, raises: [], tags: []
.}

proc x(r: TiledObject): auto {.
inline, raises: [], tags: []
.}

proc y(r: TiledObject): auto {.
inline, raises: [], tags: []
.}

proc width(r: TiledObject): auto {.
inline, raises: [], tags: []
.}

proc height(r: TiledObject): auto {.
inline, raises: [], tags: []
.}

proc properties(r: TiledObject): auto {.
inline, raises: [], tags: []
.}

proc `$`(o: TiledPolygon): auto {.
raises: [], tags: []
.}

proc `$`(o: TiledPolyline): auto {.
raises: [], tags: []
.}

proc `$`(o: TiledPoint): auto {.
raises: [], tags: []
.}

proc `$`(o: TiledEllipse): auto {.
raises: [], tags: []
.}

proc `$`(o: TiledObject): auto {.
raises: [], tags: []
.}

proc `$`(t: TiledTileset): auto {.
raises: [], tags: []
.}

proc newTiledRegion(x, y, width, height: int): TiledRegion {.
raises: [], tags: []
.}

proc loadTileset(theXml: XmlNode): TiledTileset {.

    raises: [OverflowError, ValueError], tags: []
.}

proc loadTileset(path: string): TiledTileset {.
raises: [IOError, KeyError, Exception,
    ValueError, XmlError, OverflowError],
    tags: [WriteIOEffect, ReadDirEffect, ReadIOEffect, RootEffect]
.}

proc loadTiledMap(path: string): TiledMap {.
raises: [IOError, KeyError, Exception,
    ValueError, XmlError, OverflowError, OutOfMemError, ZlibStreamError], tags: [
    WriteIOEffect, ReadDirEffect, ReadIOEffect, RootEffect]
.}