minecraft-mod/Essentials/src/main/kotlin/com/beemer/essentials/nickname/NicknameCommand.kt

package com.beemer.essentials.nickname

import com.beemer.essentials.util.MessageUtils
import com.mojang.brigadier.arguments.StringArgumentType
import net.minecraft.commands.Commands
import net.minecraft.server.level.ServerPlayer
import net.neoforged.bus.api.SubscribeEvent
import net.neoforged.neoforge.event.RegisterCommandsEvent

/** 닉네임 명령어 /닉네임 변경 <닉네임> /닉네임 초기화 */
object NicknameCommand {
        @SubscribeEvent
        fun onRegisterCommands(event: RegisterCommandsEvent) {
                // 한글 명령어
                event.dispatcher.register(
                        Commands.literal("닉네임")
                                .then(
                                        Commands.literal("변경")
                                                .then(
                                                        Commands.argument(
                                                                        "닉네임",
                                                                        StringArgumentType
                                                                                .greedyString()
                                                                )
                                                                .executes { context ->
                                                                        val player =
                                                                                context.source
                                                                                        .entity as?
                                                                                        ServerPlayer
                                                                                        ?: return@executes 0
                                                                        val nickname =
                                                                                StringArgumentType
                                                                                        .getString(
                                                                                                context,
                                                                                                "닉네임"
                                                                                        )
                                                                                        .trim()
                                                                        executeSet(player, nickname)
                                                                }
                                                )
                                )
                                .then(
                                        Commands.literal("초기화").executes { context ->
                                                val player =
                                                        context.source.entity as? ServerPlayer
                                                                ?: return@executes 0
                                                executeReset(player)
                                        }
                                )
                )

                // 영어 명령어
                event.dispatcher.register(
                        Commands.literal("nickname")
                                .then(
                                        Commands.literal("set")
                                                .then(
                                                        Commands.argument(
                                                                        "name",
                                                                        StringArgumentType
                                                                                .greedyString()
                                                                )
                                                                .executes { context ->
                                                                        val player =
                                                                                context.source
                                                                                        .entity as?
                                                                                        ServerPlayer
                                                                                        ?: return@executes 0
                                                                        val nickname =
                                                                                StringArgumentType
                                                                                        .getString(
                                                                                                context,
                                                                                                "name"
                                                                                        )
                                                                                        .trim()
                                                                        executeSet(player, nickname)
                                                                }
                                                )
                                )
                                .then(
                                        Commands.literal("reset").executes { context ->
                                                val player =
                                                        context.source.entity as? ServerPlayer
                                                                ?: return@executes 0
                                                executeReset(player)
                                        }
                                )
                )
        }

        private fun executeSet(player: ServerPlayer, nickname: String): Int {
                // 유효성 검사: 길이
                if (nickname.length < 2 || nickname.length > 16) {
                        MessageUtils.sendError(player, "닉네임은 2~16자 사이여야 합니다.")
                        return 0
                }

                // 유효성 검사: 현재 닉네임과 동일
                val currentNickname = NicknameDataStore.getNickname(player.uuid)
                if (currentNickname == nickname) {
                        MessageUtils.sendError(player, "현재 사용 중인 닉네임과 동일합니다.")
                        return 0
                }

                // 유효성 검사: 중복
                if (NicknameDataStore.isNicknameTaken(nickname, player.uuid)) {
                        MessageUtils.sendError(player, "이미 사용 중인 닉네임입니다.")
                        return 0
                }

                // 닉네임 저장 및 적용
                NicknameDataStore.setNickname(player.uuid, player.gameProfile.name, nickname)
                NicknameManager.applyNickname(player, nickname)

                MessageUtils.sendSuccess(player, "닉네임이 {$nickname}(으)로 변경되었습니다.")
                return 1
        }

        private fun executeReset(player: ServerPlayer): Int {
                if (!NicknameDataStore.hasNickname(player.uuid)) {
                        MessageUtils.sendError(player, "설정된 닉네임이 없습니다.")
                        return 0
                }

                NicknameDataStore.removeNickname(player.uuid)
                NicknameManager.removeNickname(player)

                MessageUtils.sendSuccess(player, "닉네임이 초기화되었습니다.")
                return 1
        }
}