package com.beemer.essentials.command

import com.beemer.essentials.config.PlayerConfig
import com.beemer.essentials.config.SpawnConfig
import com.beemer.essentials.data.Location
import com.beemer.essentials.util.CommandUtils
import com.beemer.essentials.util.DimensionUtils
import com.beemer.essentials.util.MessageUtils
import com.beemer.essentials.util.SoundUtils
import net.minecraft.commands.Commands
import net.neoforged.bus.api.SubscribeEvent
import net.neoforged.neoforge.event.RegisterCommandsEvent

object SpawnCommand {
        @SubscribeEvent
        fun onRegisterCommands(event: RegisterCommandsEvent) {
                listOf("setspawn", "스폰설정").forEach { command ->
                        event.dispatcher.register(
                                Commands.literal(command).executes { context ->
                                        val player =
                                                CommandUtils.getPlayerOrSendFailure(context.source)
                                                        ?: return@executes 0

                                        val exactPos = player.position()
                                        val blockPos = player.blockPosition()
                                        val dimension =
                                                player.level().dimension().location().toString()
                                        val biome =
                                                player.level()
                                                        .getBiome(blockPos)
                                                        .unwrapKey()
                                                        .map { it.location().toString() }
                                                        .orElse("minecraft:plains")

                                        val location =
                                                Location(
                                                        dimension = dimension,
                                                        biome = biome,
                                                        x = exactPos.x,
                                                        y = exactPos.y,
                                                        z = exactPos.z
                                                )

                                        SpawnConfig.setCustomSpawn(location)
                                        MessageUtils.sendSuccess(player, "스폰 지점이 현재 위치로 설정되었습니다.")
                                        1
                                }
                        )
                }

                listOf("spawn", "스폰", "넴주").forEach { command ->
                        event.dispatcher.register(
                                Commands.literal(command).executes { context ->
                                        val player =
                                                CommandUtils.getPlayerOrSendFailure(context.source)
                                                        ?: return@executes 0

                                        val target =
                                                SpawnConfig.getCustomSpawn()
                                                        ?: SpawnConfig.getDefaultSpawn()

                                        target?.let { t ->
                                                val level =
                                                        DimensionUtils.getLevelById(
                                                                player.server,
                                                                t.dimension
                                                        )

                                                level?.let { l ->
                                                        val exactPos = player.position()
                                                        val blockPos = player.blockPosition()
                                                        val currentDimension =
                                                                player.level()
                                                                        .dimension()
                                                                        .location()
                                                                        .toString()
                                                        val currentBiome =
                                                                player.level()
                                                                        .getBiome(blockPos)
                                                                        .unwrapKey()
                                                                        .map {
                                                                                it.location()
                                                                                        .toString()
                                                                        }
                                                                        .orElse("minecraft:plains")

                                                        val currentLocation =
                                                                Location(
                                                                        dimension =
                                                                                currentDimension,
                                                                        biome = currentBiome,
                                                                        x = exactPos.x,
                                                                        y = exactPos.y,
                                                                        z = exactPos.z
                                                                )

                                                        PlayerConfig.recordLastLocation(
                                                                player,
                                                                currentLocation
                                                        )
                                                        player.teleportTo(
                                                                l,
                                                                t.x,
                                                                t.y,
                                                                t.z,
                                                                player.yRot,
                                                                player.xRot
                                                        )
                                                        // 텔레포트 사운드 재생
                                                        SoundUtils.playTeleport(player)
                                                        MessageUtils.sendSuccess(
                                                                player,
                                                                "스폰으로 이동했습니다."
                                                        )
                                                }
                                        }
                                        1
                                }
                        )
                }

                listOf("delspawn", "스폰삭제").forEach { command ->
                        event.dispatcher.register(
                                Commands.literal(command).executes { context ->
                                        val player =
                                                CommandUtils.getPlayerOrSendFailure(context.source)
                                                        ?: return@executes 0

                                        SpawnConfig.removeCustomSpawn()
                                        MessageUtils.sendInfo(player, "스폰 지점이 기본 스폰 지점으로 변경되었습니다.")
                                        1
                                }
                        )
                }
        }
}