import config from '@/config'
import Tilemap = Phaser.Tilemaps.Tilemap
import TilemapLayer = Phaser.Tilemaps.TilemapLayer
import Tileset = Phaser.Tilemaps.Tileset
import { useGameStore } from '@/stores/game'

export function getTile(x: number, y: number, layer: Phaser.Tilemaps.TilemapLayer): Phaser.Tilemaps.Tile | undefined {
  const tile: Phaser.Tilemaps.Tile = layer.getTileAtWorldXY(x, y)
  if (!tile) return undefined
  return tile
}

export function tileToWorldXY(layer: Phaser.Tilemaps.TilemapLayer, pos_x: number, pos_y: number) {
  const worldPoint = layer.tileToWorldXY(pos_x, pos_y)
  const positionX = worldPoint.x + config.tile_size.y
  const positionY = worldPoint.y

  return { positionX, positionY }
}

export function tileToWorldX(layer: Phaser.Tilemaps.TilemapLayer, pos_x: number, pos_y: number): number {
  const worldPoint = layer.tileToWorldXY(pos_x, pos_y)
  return worldPoint.x + config.tile_size.x / 2
}

export function tileToWorldY(layer: TilemapLayer, pos_x: number, pos_y: number): number {
  const worldPoint = layer.tileToWorldXY(pos_x, pos_y)
  return worldPoint.y + config.tile_size.y * 1.5
}

export function placeTile(zone: Tilemap, layer: TilemapLayer, x: number, y: number, tileName: string) {
  const tileImg = zone.getTileset(tileName) as Tileset
  if (!tileImg) return
  layer.putTileAt(tileImg.firstgid, x, y)
}

export function setAllTiles(zone: Tilemap, layer: TilemapLayer, tiles: string[][]) {
  tiles.forEach((row, y) => {
    row.forEach((tile, x) => {
      placeTile(zone, layer, x, y, tile)
    })
  })
}

export const calculateIsometricDepth = (x: number, y: number, width: number = 0, height: number = 0, isCharacter: boolean = false) => {
  const baseDepth = x + y
  if (isCharacter) {
    return baseDepth // @TODO: Fix collision, this is a hack
  }

  // For objects, use their back bottom corner
  return baseDepth + (width + height) / (2 * config.tile_size.x)
}

export const sortByIsometricDepth = <T extends { positionX: number; positionY: number }>(items: T[]) => {
  return [...items].sort((a, b) => {
    return calculateIsometricDepth(a.positionX, a.positionY, 0, 0) - calculateIsometricDepth(b.positionX, b.positionY, 0, 0)
  })
}

export const loadAssets = (scene: Phaser.Scene): Promise<void> => {
  return new Promise((resolve) => {
    const gameStore = useGameStore()
    let addedLoad = false;

    gameStore.assets.forEach((asset) => {
      if (scene.load.textureManager.exists(asset.key)) return
      addedLoad = true;
      if (asset.group === 'sprite_animations') {
        scene.load.spritesheet(asset.key, config.server_endpoint + asset.url, { frameWidth: asset.frameWidth ?? 0, frameHeight: asset.frameHeight ?? 0 })
      } else {
        scene.load.image(asset.key, config.server_endpoint + asset.url)
      }
    })

    if(addedLoad) {
      scene.load.start()
      scene.load.on(Phaser.Loader.Events.COMPLETE, () => {
        resolve()
      })
    } else {
      resolve()
    }
  })
}