package assets_gen

import os "core:os/os2"
import "core:fmt"
import "core:encoding/json"
import "core:path/filepath"
import "core:strings"

Rect :: struct {
  start: [2]f32,
  size: [2]f32,
}

Json_Map :: struct {
  backgroundcolor: string,
  class: string,
  compressionlevel: i32,
  width: i32,
  height: i32,
  infinite: bool,
  layers: []Json_Layer,
  nextlayerid: i32,
  nextobjectid: i32,
  orientation: string,
  parallaxoriginx: f64,
  parallaxoriginy: f64,
  properties: []Json_Property,
  renderorder: string,
  staggeraxis: string,
  staggerindex: string,
  tilewidth: i32,
  tileheight: i32,
  tilesets: []Json_Tileset,
}

Json_Layer :: struct {
  class: string,
  compression: string,
  data: union {
    []i32,
    string,
  },
  draworder: string,
  encoding: string,
  id: i32,
  image: string,
  image_width: i32,
  image_height: i32,
  layers: []Json_Layer,
  // locked: bool,
  name: string,
  objects: []Json_Object,
  offsetx: f64,
  offsety: f64,
  opacity: f32,
  parallaxx: f64,
  parallaxy: f64,
  properties: []Json_Property,
  repeatx: bool,
  repeaty: bool,
  tintcolor: string,
  transparentcolor: string,
  type: string,
  visible: bool,
  x: i32,
  y: i32,
  width: i32,
  height: i32,
}

Json_Object :: struct {
  ellipse: bool,
  gid: i32,
  width: f64,
  height: f64,
  id: i32,
  name: string,
  point: bool,
  polygon: []Json_Point,
  polyline: []Json_Point,
  properties: []Json_Property,
  rotation: f64,
  template: string,
  text: Maybe(struct {
    fontfamily: string,
    color: string,
    text: string,
    halign: string,
    valign: string,
    pixelsize: i32,
    wrap: bool,
    underline: bool,
    bold: bool,
    italic: bool,
    kerning: bool,
    strikeout: bool,
  }),
  type: string,
  visible: bool,
  x: f64,
  y: f64,
}

Json_Tileset :: struct {
  background_color: string,
  class: string,
  rows: i32,
  columns: i32,
  fillmode: string,
  firstgid: i32,
  grid: Maybe(Json_Grid),
  image: string,
  imagewidth: i32,
  imageheight: i32,
  margin: i32,
  name: string,
  objectalignment: string,
  properties: []Json_Property,
  source: string,
  spacing: i32,
  terrains: []Json_Terrain,
  tilecount: i32,
  tilewidth: i32,
  tileheight: i32,
  tileoffset: Json_Tile_Offset,
  tilerendersize: string,
  tiles: []Json_Tile,
  transformations: Json_Transformations,
  transparentcolor: string,
  type: string,
  wangsets: []Json_Wang_Set,
}

Json_Grid :: struct {
  width: i32,
  height: i32,
  orientation: string,
}

Json_Tile_Offset :: struct {
  x: i32,
  y: i32,
}

Json_Transformations :: struct {
  hflip: bool,
  vflip: bool,
  rotate: bool,
  preferuntransformed: bool,
}

Json_Tile :: struct {
  animation: []Json_Frame,
  id: i32,
  image: string,
  imagewidth: i32,
  imageheight: i32,
  x: i32,
  y: i32,
  width: i32,
  height: i32,
  objectgroup: Json_Layer,
  probability: f64,
  properties: []Json_Property,
  terrain: []i32,
  type: string,
}

Json_Frame :: struct {
  duration: i32, 
  tileid: i32,
}

Json_Terrain :: struct {
  name: string,
  properties: []Json_Property,
  tile: i32,
}

Json_Wang_Set :: struct {
  class: string,
  colors: []Json_Wang_Color,
  name: string,
  properties: []Json_Property,
  tile: i32,
  type: string,
  wangtiles: []Json_Wang_Tile,
}

Json_Wang_Color :: struct {
  class: string,
  color: string,
  name: string,
  probability: f64,
  properties: []Json_Property,
  tile: i32,
}

Json_Wang_Tile :: struct {
  tileid: i32,
  wangid: []u8,
}

Json_Object_Template :: struct {
  tileset: Maybe(Json_Tileset),
  object: Json_Object,
}

Json_Property :: struct {
  name: string,
  type: string,
  propertytype: string,
  value: union{
    bool,
    int,
    string,
    f32,
  },
}

Json_Point :: struct {
  x: f64,
  y: f64,
}

Json_World_Room :: struct {
  file_name: string `json:"fileName"`, 
  x: i32,
  y: i32,
  width: i32,
  height: i32,
}

Json_World :: struct {
  maps: []Json_World_Room,
}

Gids :: struct {
  first: u32,
  last: u32,
}

gids: map[string]Gids

load_json_world :: proc(path: string) {
  json_text, read_err := os.read_entire_file(path, context.temp_allocator)
  if read_err != nil {
    die("Could not load world %v (%v)", path, read_err)
  }

  json_dat: Json_World
  unmarshal_err := json.unmarshal(
    json_text,
    &json_dat,
    allocator = context.temp_allocator,
  )
  if unmarshal_err != nil {
    die("Could not parse world %v (%v)", path, unmarshal_err)
  }

  for room in json_dat.maps {
    room_name := strings.to_screaming_snake_case(
      filepath.stem(room.file_name),
      allocator = context.temp_allocator,
    )

    line := fmt.aprintf(
      "{{id=.%v, x=%w, y=%w, width=%w, height=%w}}",
      room_name,
      room.x,
      room.y,
      room.width,
      room.height,
    )
    append(&world, line)
  }
}

create_tile :: proc(
  tileset_enum: string,
  rect: Rect,
  collisions: []Rect,
) -> string {
  line := fmt.aprintf(
    "{{tileset=.%v, rect=%w, id=%w, collisions=%w}}",
    tileset_enum,
    rect,
    len(tiles),
    collisions,
  )
  append(&tiles, line)
  return line
}

load_json_tileset :: proc(path: string) {
  json_text, read_err := os.read_entire_file(path, context.temp_allocator)
  if read_err != nil {
    die("Could not load tileset %v (%v)", path, read_err)
  }

  json_dat: Json_Tileset
  unmarshal_err := json.unmarshal(
    json_text,
    &json_dat,
    allocator = context.temp_allocator,
  )
  if unmarshal_err != nil {
    die("Failed to parse tileset %v (%v)", path, unmarshal_err)
  }

  tileset_enum := strings.to_screaming_snake_case(
    filepath.stem(path),
    allocator = context.temp_allocator,
  )

  image_enum := strings.to_screaming_snake_case(
    filepath.stem(json_dat.image),
    allocator = context.temp_allocator,
  )

  tiles_x := json_dat.imagewidth / json_dat.tilewidth
  tiles_y := json_dat.imageheight / json_dat.tileheight

  local_tiles := make([dynamic]string, allocator = context.temp_allocator)

  tile_size: [2]f32 = {f32(json_dat.tilewidth), f32(json_dat.tileheight)}

  first_gid := u32(len(tiles))

  gids[filepath.stem(path)] = {
    first = first_gid,
    last = u32(len(tiles) + int(json_dat.tilecount)),
  }

  collisions := make([][dynamic]Rect, json_dat.tilecount)
  defer {
    for collision in collisions {
      delete(collision)
    }
    delete(collisions)
  }

  for tile in json_dat.tiles {
    collision := &collisions[tile.id]
    for object in tile.objectgroup.objects {
      append(
        collision,
        Rect{
          start = {f32(object.x), f32(object.y)},
          size = {f32(object.width), f32(object.height)}
        }
      )
    }
  }

  for y in 0..<tiles_y {
    for x in 0..<tiles_x {
      append(&local_tiles, create_tile(
        tileset_enum,
        Rect{
          start = {f32(x * json_dat.tilewidth), f32(y * json_dat.tileheight)},
          size = tile_size,
        },
        collisions[y * tiles_x + x][:],
      ))
    }
  }

  gids := make([]u32, len(local_tiles), context.temp_allocator)
  for tile, i in local_tiles {
    gids[i] = first_gid + u32(i)
  }

  line := fmt.aprintf("{{tiles=%w, image=.%v}}", gids, image_enum)
  tilesets[filepath.stem(path)] = line
}

load_json_room :: proc(path: string, file: ^os.File) {
  json_text, read_err := os.read_entire_file(file, context.temp_allocator)
  if read_err != nil {
    die("Could not load room %v (%v)", path, read_err)
  }

  json_dat: Json_Map
  unmarshal_err := json.unmarshal(
    json_text,
    &json_dat,
    allocator = context.temp_allocator,
  )
  if unmarshal_err != nil {
    die("Failed to parse room %v (%v)", path, unmarshal_err)
  }

  width := json_dat.width
  height := json_dat.height

  tile_width := json_dat.tilewidth
  tile_height := json_dat.tileheight
  
  tiled_to_real_gid: map[i32]u32
  defer delete(tiled_to_real_gid)

  // map tiled's map-based GIDs to my actually global GIDs
  id: i32 = 1
  for tileset in json_dat.tilesets {
    tileset_name := filepath.stem(tileset.source)
    gid, exists := gids[tileset_name]
    if !exists {
      load_json_tileset(strings.concatenate({
        filepath.dir(path, context.temp_allocator),
        "/",
        tileset.source,
      }))
      gid = gids[tileset_name]
    }

    for i in gid.first..<gid.last {
      tiled_to_real_gid[id] = i
      id += 1
    }
  }

  objects: [dynamic]string
  defer delete(objects)

  layers: [dynamic][]u32
  defer delete(layers)

  for layer in json_dat.layers {
    switch layer.type {
    case "tilelayer":
      json_layer_dat, ok := layer.data.([]i32)
      if !ok {
        continue
      }

      data := make(
        []u32,
        len(json_layer_dat),
        allocator = context.temp_allocator,
      )

      for cell, i in json_layer_dat {
        data[i] = tiled_to_real_gid[cell]
      }

      append(&layers, data)
    case "objectgroup":
      parallax := [2]f32{f32(layer.parallaxx), f32(layer.parallaxy)}

      for obj in layer.objects {
        type_name := strings.to_screaming_snake_case(obj.type)

        // `object_type_names` now owns `type_name`; freed in main
        object_type_names[type_name] = {}

        pos := [2]f32{f32(obj.x), f32(obj.y)}
        size := [2]f32{f32(obj.width), f32(obj.height)}

        properties: map[string]union{
          bool,
          int,
          string,
          f32,
        }
        defer delete(properties)

        for property in obj.properties {
          fmt.println(property.name, property.value)
          properties[property.name] = property.value
        }

        line := fmt.tprintf(
          "{{type = .%v, pos = %w, size = %w, parallax = %w, properties = %w}}",
          type_name,
          pos,
          size,
          parallax,
          properties,
        )

        append(&objects, line)
      }
    case:
      fmt.eprintfln("WARNING: Unsupported tile layer type '%v'", layer.type)
    }
  }

  objects_arr_str := ""

  for obj in objects {
    objects_arr_str = strings.concatenate({
      objects_arr_str,
      obj,
      ", "
    }, allocator = context.temp_allocator)
  }

  line := fmt.aprintf(
    "{{width=%v, height=%v, tile_width=%v, tile_height=%v, layers=%w, objects={{%v}}, background_image=nil}}",
    width,
    height,
    tile_width,
    tile_height,
    layers[:],
    objects_arr_str,
  )
  rooms[filepath.stem(path)] = line
}