package tiled

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

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

res_dir: string
world: []World_Room
current_room: struct {
  tmap: Map,
  using room: World_Room,
}

load_world :: proc(path: string) -> bool {
  world_text, read_err := os.read_entire_file(path, context.temp_allocator)
  if read_err != nil {
    log.errorf("Failed to read file %v (%v)", path, read_err)
    return false
  }

  jworld: struct {
    maps: []World_Room,
  }
  unmarshal_err := json.unmarshal(
    world_text,
    &jworld,
  )
  if unmarshal_err != nil {
    log.errorf("Failed to unmarshal file %v (%v)", path, unmarshal_err)
    return false
  }

  world = jworld.maps
  res_dir = filepath.dir(path)

  return true
}

delete_world :: proc() {
  for room in world {
    delete(room.file_name)
  }

  delete_map(current_room.tmap)
  delete(world)
  delete(res_dir)
}

open_new_room_at :: proc(pos: [2]i32) -> bool {
  pos := pos
  pos += {current_room.room.x, current_room.room.y}

  log.debug("trying to change room...", pos)
  for room in world {
    if strings.compare(room.file_name, current_room.room.file_name) == 0 {
      continue
    }

    if pos.x >= room.x && pos.x <= room.x + room.width \
    && pos.y >= room.y && pos.y <= room.y + room.height {
      delete_map(current_room.tmap)

      path := strings.concatenate(
        {res_dir, "/", room.file_name},
        allocator = context.temp_allocator,
      )
      new_map, err := load_map(path)
      if err != .NONE {
        log.error("could not load new room")
        return false
      }
      current_room.tmap = new_map
      current_room.room = room
      return true
    }
  }
  return false
}