package demonchime

import "core:math"
import "core:math/linalg"
import "core:log"

import "fw"
import "phys"

Prop :: struct {
  handle: Entity_Handle,
  image_id: Image_Id,
  pos: Vec2,
  scale: Vec2,
}

make_prop :: proc(prop: Prop) -> (Entity_Handle, ^Prop) {
  return make_entity(&state.prop_list, prop)
}

draw_props :: proc() {
  iter := iter_entity_list(state.prop_list)
  for p in entity_list_iter(&iter) {
    image := get_image(p.image_id)
    fw.draw_tex(
      image,
      p.pos,
      scale = p.scale,
    )
  }
}

Wiggle_Prop :: struct {
  handle: Entity_Handle,
  image_id: Image_Id,
  pos: Vec2,
  scale: Vec2,
  offset: Vec2,
  shear: f32,
  shear_factor: f32,
}

make_wiggle_prop :: proc(prop: Wiggle_Prop) -> (Entity_Handle, ^Wiggle_Prop) {
  return make_entity(&state.wiggle_prop_list, prop)
}

update_wiggle_props :: proc(dt: f32) {
  iter := iter_entity_list(state.wiggle_prop_list)
  for p in entity_list_iter(&iter) {
    player_vel := phys.get_velocity(player.body)
    player_pos := phys.get_position(player.body)

    image := get_image(p.image_id)
    dist := linalg.length(p.pos - player_pos)
    dist = f32(max(image.size.x, image.size.y)) - dist
    if dist < 0 {
      dist = 0
    }
    p.shear = math.clamp(
      player_vel.x / PLAYER_SPEED * dist * p.shear_factor,
      -0.25,
      0.25,
    )
  }
}

draw_wiggle_props :: proc() {
  iter := iter_entity_list(state.wiggle_prop_list)
  for p in entity_list_iter(&iter) {
    fw.draw_tex_ex(
      get_image(p.image_id),
      p.pos,
      offset = p.offset,
      // rot = p.rotation,
      shear = Vec2{-p.shear, 0},
    )
  }
}

clear_props :: proc() {
  p_iter := iter_entity_list(state.prop_list)
  for p in entity_list_iter(&p_iter) {
    delete_entity(&state.prop_list, p.handle)
  }

  wp_iter := iter_entity_list(state.wiggle_prop_list)
  for p in entity_list_iter(&wp_iter) {
    delete_entity(&state.wiggle_prop_list, p.handle)
  }
}

object_spawner_prop :: proc(obj: Object_Resource) {
  tile_id, has_tile_id := obj.tile_id.(u32)
  if !has_tile_id || tile_id == 0 {
    log.warn("Prop does not have a tile id!")
    return
  }

  tile := tiles[tile_id]
  img := get_image(tile.image)

  pos := obj.pos - Vec2{0, f32(img.size.y)}
  scale := Vec2{1, 1}
  if obj.size.x < 0 {
    scale.x = -1
    // pos.x -= f32(img.width)
  }
  if obj.size.y < 0 {
    scale.y = -1
    // pos.y -= f32(img.height)
  }

  #partial switch tile.image {
  case .Carrabasset_Vines_0,
       .Carrabasset_Vines_1,
       .Carrabasset_Vines_2,
       .Small_Lamp,
       .Windchimes_0,
       .Windchimes_1:
    offset := linalg.round(Vec2{
      f32(img.size.x) * 0.5,
      0,
    })

    shear_factor: f32 = 1
    #partial switch tile.image {
    case .Carrabasset_Vines_0:
      shear_factor = 0.1
    }

    make_wiggle_prop(Wiggle_Prop{
      image_id = tile.image,
      pos = pos + offset,
      scale = scale,
      offset = offset,
      shear_factor = -shear_factor,
    })
  case .Carrabassett_Small_Bush_0, .Carrabassett_Big_Bush_0:
    offset := linalg.round(Vec2{
      f32(img.size.x) * 0.5,
      f32(img.size.y),
    })

    shear_factor: f32 = 0.01
    #partial switch tile.image {
    case .Carrabassett_Big_Bush_0:
      shear_factor = 0.01
    }

    make_wiggle_prop(Wiggle_Prop{
      image_id = tile.image,
      pos = pos + offset,
      scale = scale,
      offset = offset,
      shear_factor = shear_factor,
    })
  case:
    make_prop(Prop{
      image_id = tile.image,
      pos = pos,
      scale = scale,
    })
  }
}

on_room_open_props :: proc(room_id: Room_Id) {
  clear_props()
}