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 { useAssetManager } from '@/utilities/assetManager'

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 setLayerTiles(zone: Tilemap, layer: TilemapLayer, tiles: string[][]) {
  if (!tiles) return

  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
  }
  return baseDepth + (width + height) / (2 * config.tile_size.x)
}

export async function loadZoneTileTexture(scene: Phaser.Scene, textureId: string, updatedAt: Date): Promise<boolean> {
  const assetManager = useAssetManager

  // Check if the texture is already loaded in Phaser
  if (scene.textures.exists(textureId)) {
    return true
  }

  let assetData = await assetManager.getAsset(textureId)

  if (!assetData) {
    await assetManager.downloadAsset(textureId, `/assets/tiles/${textureId}.png`, 'tiles', updatedAt)
    assetData = await assetManager.getAsset(textureId)
  }

  if (assetData) {
    return new Promise<boolean>((resolve) => {
      scene.textures.addBase64(textureId, assetData.data)
      scene.textures.once(`addtexture-${textureId}`, () => {
        resolve(true)
      })
    })
  }

  return false
}

export async function loadZoneObjectTexture(scene: Phaser.Scene, textureId: string, updatedAt: Date): Promise<boolean> {
  const assetManager = useAssetManager

  // Check if the texture is already loaded in Phaser
  if (scene.textures.exists(textureId)) {
    return true
  }

  let assetData = await assetManager.getAsset(textureId)

  if (!assetData) {
    await assetManager.downloadAsset(textureId, `/assets/objects/${textureId}.png`, 'objects', updatedAt)
    assetData = await assetManager.getAsset(textureId)
  }

  if (assetData) {
    return new Promise<boolean>((resolve) => {
      scene.textures.addBase64(textureId, assetData.data)
      scene.textures.once(`addtexture-${textureId}`, () => {
        resolve(true)
      })
    })
  }

  return false
}