package org.blz.adminmode.commands;

import java.util.List;
import java.util.UUID;

import org.blz.adminmode.config.ConfigManager;
import org.blz.adminmode.dialog.AdminDialogService;
import org.blz.adminmode.integrations.CoreProtectIntegration;
import org.blz.adminmode.moderation.ModeManager;
import org.blz.adminmode.moderation.ModeratorProfile;
import org.blz.adminmode.moderation.PlayerListAction;
import org.bukkit.Bukkit;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;

import net.kyori.adventure.text.Component;

public class AdminModeCommand implements CommandExecutor {

    private final ConfigManager configManager;
    private final ModeManager modeManager;
    private final CoreProtectIntegration coreProtectIntegration;
    private AdminDialogService dialogService;

    public AdminModeCommand(
            ConfigManager configManager,
            ModeManager modeManager,
            CoreProtectIntegration coreProtectIntegration) {
        this.configManager = configManager;
        this.modeManager = modeManager;
        this.coreProtectIntegration = coreProtectIntegration;
    }

    public void setDialogService(AdminDialogService dialogService) {
        this.dialogService = dialogService;
    }

    @Override
    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
        if (args.length > 0 && args[0].equalsIgnoreCase("reload")) {
            if (!sender.hasPermission("adminmode.reload")) {
                sender.sendMessage(configManager.getPrefixedMessage(configManager.getMsgNoPermission()));
                return true;
            }
            configManager.loadConfig();
            sender.sendMessage(configManager.getPrefixedMessage(configManager.getMsgReloaded()));
            return true;
        }

        if (args.length > 0 && args[0].equalsIgnoreCase("disable")) {
            if (!canUseHardActions(sender)) {
                sender.sendMessage(configManager.getPrefixedMessage(configManager.getMsgNoPermission()));
                return true;
            }

            if (args.length < 2) {
                sender.sendMessage(configManager.getPrefixedMessage("§cИспользование: /adminmode disable <игрок>"));
                return true;
            }

            forceDisableTarget(sender, args[1]);
            return true;
        }

        if (!(sender instanceof Player player)) {
            sender.sendMessage("Эта команда доступна только игрокам!");
            return true;
        }

        if (!configManager.isEnabled()) {
            player.sendMessage(configManager.getPrefixedMessage("§cРежим администратора отключен!"));
            return true;
        }

        if (args.length > 0 && args[0].equalsIgnoreCase("dialog")) {
            if (!openRelevantDialog(player)) {
                player.sendMessage(configManager.getPrefixedMessage("§eDialog-панель сейчас недоступна."));
            }
            return true;
        }

        if (args.length > 0 && (args[0].equalsIgnoreCase("enable") || args[0].equalsIgnoreCase("profile"))) {
            if (args.length < 2) {
                openRelevantDialog(player);
                return true;
            }

            ModeratorProfile profile = ModeratorProfile.fromInput(args[1]).orElse(null);
            if (profile == null) {
                player.sendMessage(configManager.getPrefixedMessage("§cНеизвестный профиль. Доступно: soft, hard."));
                return true;
            }

            activateProfile(player, profile);
            return true;
        }

        if (!isInAdminMode(player.getUniqueId()) && getAvailableProfiles(player).isEmpty()) {
            player.sendMessage(configManager.getPrefixedMessage(configManager.getMsgNoPermission()));
            return true;
        }

        openRelevantDialog(player);
        return true;
    }

    public boolean activateProfile(Player player, ModeratorProfile profile) {
        if (profile == null) {
            return openRelevantDialog(player);
        }

        if (!profile.isAvailableFor(player)) {
            player.sendMessage(configManager.getPrefixedMessage(configManager.getMsgNoPermission()));
            return false;
        }

        if (modeManager.hasSession(player.getUniqueId())) {
            ModeratorProfile activeProfile = getActiveProfile(player.getUniqueId());
            if (activeProfile == profile) {
                return openRelevantDialog(player);
            }

            player.sendMessage(configManager.getPrefixedMessage(
                    "§eУ вас уже активен профиль §f" + activeProfile.getDisplayName() + "§e. Сначала выйдите из режима."));
            return false;
        }

        return modeManager.enterMode(player, profile);
    }

    public boolean exitMode(Player player) {
        return modeManager.exitMode(player);
    }

    public boolean recoverSession(Player player) {
        return modeManager.recoverSession(player);
    }

    public List<ModeratorProfile> getAvailableProfiles(Player player) {
        return modeManager.getAvailableProfiles(player);
    }

    public ModeratorProfile getActiveProfile(UUID playerId) {
        return modeManager.getProfile(playerId);
    }

    public boolean isInAdminMode(UUID playerId) {
        return modeManager.hasSession(playerId);
    }

    public List<Component> getOnlineSummary(Player player) {
        return modeManager.buildOnlineSummary(player);
    }

    public void applyAdminSettings(Player player, float flySpeed, float walkSpeed, boolean godMode) {
        if (!modeManager.hasSession(player.getUniqueId())) {
            return;
        }

        modeManager.applyAdminSettings(player, flySpeed, walkSpeed, godMode);
        player.sendMessage(configManager.getPrefixedMessage("§aНастройки режима обновлены."));
    }

    public boolean performPlayerListAction(Player moderator, PlayerListAction action, String targetName) {
        Player target = validateActiveTarget(moderator, targetName);
        if (target == null) {
            return false;
        }

        return switch (action) {
            case SPECTATE -> modeManager.spectatePlayer(moderator, target);
            case TELEPORT -> modeManager.teleportToPlayer(moderator, target);
            case INVSEE -> modeManager.openInvsee(moderator, target);
        };
    }

    public boolean teleportToPlayer(Player moderator, String targetName) {
        Player target = validateActiveTarget(moderator, targetName);
        return target != null && modeManager.teleportToPlayer(moderator, target);
    }

    public boolean teleportPlayerHere(Player moderator, String targetName) {
        if (!validateHardActionPlayer(moderator)) {
            return false;
        }

        Player target = resolveOnlinePlayer(targetName, moderator);
        return target != null && modeManager.teleportPlayerHere(moderator, target);
    }

    public boolean forceDisableTarget(CommandSender sender, String targetName) {
        if (!canUseHardActions(sender)) {
            sender.sendMessage(configManager.getPrefixedMessage(configManager.getMsgNoPermission()));
            return false;
        }

        Player target = resolveOnlinePlayer(targetName, sender);
        if (target == null) {
            return false;
        }

        forceDisableAbilities(target);
        sender.sendMessage(configManager.getPrefixedMessage("§aРежим и способности игрока §f" + target.getName() + "§a сброшены."));
        target.sendMessage(configManager.getPrefixedMessage("§eВаш режим модерации был принудительно отключен."));
        return true;
    }

    public boolean executeCPLookup(Player player, String targetPlayer, int radius, String time) {
        if (!validateHardActionPlayer(player)) {
            return false;
        }
        return coreProtectIntegration.lookup(player, targetPlayer, radius, time);
    }

    public boolean executeCPRollback(Player player, int radius, String time, String targetPlayer) {
        if (!validateHardActionPlayer(player)) {
            return false;
        }
        return coreProtectIntegration.rollback(player, radius, time, targetPlayer);
    }

    public boolean toggleInspector(Player player) {
        if (!validateHardActionPlayer(player)) {
            return false;
        }
        return coreProtectIntegration.toggleInspector(player);
    }

    public void forceDisableAbilities(Player player) {
        if (modeManager.hasSession(player.getUniqueId())) {
            modeManager.exitMode(player);
            return;
        }

        player.setInvulnerable(false);
        player.setFlying(false);
        player.setAllowFlight(false);
        player.setFlySpeed(0.1f);
        player.setWalkSpeed(0.2f);
    }

    public boolean canUseHardActions(CommandSender sender) {
        return modeManager.canUseHardActions(sender);
    }

    private boolean openRelevantDialog(Player player) {
        if (dialogService == null || !configManager.isDialogsEnabled()) {
            return false;
        }

        if (modeManager.hasSession(player.getUniqueId())) {
            return dialogService.openCurrentPanel(player);
        }

        return dialogService.openModeSelectDialog(player);
    }

    private boolean validateHardActionPlayer(Player moderator) {
        if (!canUseHardActions(moderator)) {
            moderator.sendMessage(configManager.getPrefixedMessage("§cДля этого действия нужен активный профиль Hard Moder."));
            return false;
        }

        return true;
    }

    private Player validateActiveTarget(Player moderator, String targetName) {
        if (!modeManager.hasSession(moderator.getUniqueId())) {
            moderator.sendMessage(configManager.getPrefixedMessage("§cСначала войдите в режим модерации."));
            return null;
        }
        return resolveOnlinePlayer(targetName, moderator);
    }

    private Player resolveOnlinePlayer(String targetName, CommandSender sender) {
        if (targetName == null || targetName.isBlank()) {
            sender.sendMessage(configManager.getPrefixedMessage("§cУкажите ник игрока."));
            return null;
        }

        Player target = Bukkit.getPlayerExact(targetName.trim());
        if (target == null) {
            target = Bukkit.getPlayer(targetName.trim());
        }

        if (target == null) {
            sender.sendMessage(configManager.getPrefixedMessage("§cИгрок не найден!"));
            return null;
        }

        return target;
    }
}