import config from '@/config'
import Tilemap = Phaser.Tilemaps.Tilemap
import TilemapLayer = Phaser.Tilemaps.TilemapLayer
import Tileset = Phaser.Tilemaps.Tileset
import Tile = Phaser.Tilemaps.Tile
import { useGameStore } from '@/stores/gameStore'
import { useAssetManager } from '@/utilities/assets'

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

export function tileToWorldXY(layer: TilemapLayer | Tilemap, pos_x: number, pos_y: number) {
  const worldPoint = layer.tileToWorldXY(pos_x, pos_y)
  if (!worldPoint) return { positionX: 0, positionY: 0 }

  const positionX = worldPoint.x + config.tile_size.y
  const positionY = worldPoint.y

  return { positionX, positionY }
}

export function tileToWorldX(layer: TilemapLayer | Tilemap, pos_x: number, pos_y: number): number {
  const worldPoint = layer.tileToWorldXY(pos_x, pos_y)
  if (!worldPoint) return 0

  return worldPoint.x + config.tile_size.x / 2
}

export function tileToWorldY(layer: TilemapLayer | Tilemap, pos_x: number, pos_y: number): number {
  const worldPoint = layer.tileToWorldXY(pos_x, pos_y)
  if (!worldPoint) return 0

  return worldPoint.y + config.tile_size.y * 1.5
}

/**
 * Can also be used to replace tiles
 * @param zone
 * @param layer
 * @param x
 * @param y
 * @param tileName
 */
export function placeTile(zone: Tilemap, layer: TilemapLayer, x: number, y: number, tileName: string) {
  let tileImg = zone.getTileset(tileName) as Tileset
  if (!tileImg) {
    tileImg = zone.getTileset('blank_tile') as Tileset
  }
  layer.putTileAt(tileImg.firstgid, x, y)
}

export function deleteTile(layer: TilemapLayer, x: number, y: number) {
  layer.removeTileAt(x, y)
}

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

export function createTileArray(width: number, height: number, tile: string = 'blank_tile') {
  return Array.from({ length: height }, () => Array.from({ length: width }, () => 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 clearAssets = (scene: Phaser.Scene) => {
  scene.load.destroy()
}