Untitled

package net.thebridgemc.customtpa;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.stream.Collectors;

import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.command.TabCompleter;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.event.player.PlayerMoveEvent;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitRunnable;

import net.md_5.bungee.api.ChatColor;
import net.md_5.bungee.api.chat.TextComponent;

public class Main extends JavaPlugin implements CommandExecutor, TabCompleter, Listener {
    private final HashMap<UUID, UUID> teleportRequests = new HashMap<>();
    private final HashMap<UUID, BukkitRunnable> teleportTasks = new HashMap<>();
    private final HashMap<UUID, Boolean> pendingTeleports = new HashMap<>();

    @Override
    public void onEnable() {
        getCommand("tpa").setExecutor(this);
        getCommand("tpa").setTabCompleter(this);
        getCommand("tpaccept").setExecutor(this);
        getCommand("tpdeny").setExecutor(this);
        getServer().getPluginManager().registerEvents(this, this);
    }

    @EventHandler
    public void onPlayerMove(PlayerMoveEvent event) {
        UUID playerID = event.getPlayer().getUniqueId();
        if (pendingTeleports.containsKey(playerID) && pendingTeleports.get(playerID)) {
            Location from = event.getFrom();
            Location to = event.getTo();
            if (from.getBlockX() != to.getBlockX() || from.getBlockY() != to.getBlockY() || from.getBlockZ() != to.getBlockZ()) {
                cancelTeleport(playerID, "Teleport cancelled due to movement.");
            }
        }
    }

    @EventHandler
    public void onPlayerDamage(EntityDamageEvent event) {
        if (event.getEntity() instanceof Player) {
            Player player = (Player) event.getEntity();
            UUID playerID = player.getUniqueId();
            if (pendingTeleports.containsKey(playerID) && pendingTeleports.get(playerID)) {
                cancelTeleport(playerID, "Teleport cancelled due to taking damage.");
            }
        }
    }

    private void cancelTeleport(UUID playerID, String message) {
        if (teleportTasks.containsKey(playerID)) {
            teleportTasks.get(playerID).cancel();
            teleportTasks.remove(playerID);
            if (teleportRequests.containsKey(playerID)) {
                UUID targetID = teleportRequests.remove(playerID);
                teleportRequests.remove(targetID); // Invalidate reverse mapping if exists
                pendingTeleports.remove(playerID);
            }
            Player player = Bukkit.getPlayer(playerID);
            if (player != null) {
                sendActionBar(player, "&e&lTPA &8>> &f" + message);
            }
        }
    }

    private void sendActionBar(Player player, String message) {
        player.spigot().sendMessage(net.md_5.bungee.api.ChatMessageType.ACTION_BAR, TextComponent.fromLegacyText(ChatColor.translateAlternateColorCodes('&', message)));
    }

    @Override
    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
        if (!(sender instanceof Player)) {
            sender.sendMessage("Only players can use this command.");
            return true;
        }

        Player player = (Player) sender;
        switch (command.getName().toLowerCase()) {
            case "tpa":
                if (args.length != 1) {
                    sendActionBar(player, "&e&lTPA &8>> &fUsage: /tpa <player>");
                    return true;
                }
                Player target = Bukkit.getPlayer(args[0]);
                if (target == null) {
                    sendActionBar(player, "&e&lTPA &8>> &fPlayer not found.");
                    return true;
                }

                // Cancel any existing request from the player
                if (teleportRequests.containsKey(player.getUniqueId())) {
                    cancelTeleport(player.getUniqueId(), "Previous teleport request cancelled.");
                }

                teleportRequests.put(player.getUniqueId(), target.getUniqueId());
                sendActionBar(player, "&e&lTPA &8>> &fTeleport request sent to " + target.getName());
                sendActionBar(target, "&e&lTPA &8>> &f" + player.getName() + " has requested to teleport to you.");

                // Schedule a task to cancel the request if not responded within 45 seconds
                BukkitRunnable cancelTask = new BukkitRunnable() {
                    @Override
                    public void run() {
                        if (teleportRequests.containsKey(player.getUniqueId())) {
                            cancelTeleport(player.getUniqueId(), "Teleport request timed out.");
                        }
                    }
                };
                cancelTask.runTaskLater(this, 900); // 900 ticks = 45 seconds
                teleportTasks.put(player.getUniqueId(), cancelTask);

                return true;

            case "tpaccept":
                UUID requesterUUID = teleportRequests.entrySet().stream()
                        .filter(e -> e.getValue().equals(player.getUniqueId()))
                        .map(Map.Entry::getKey)
                        .findFirst().orElse(null);
                if (requesterUUID == null) {
                    sendActionBar(player, "&e&lTPA &8>> &fYou have no pending teleport requests.");
                    return true;
                }
                Player requester = Bukkit.getPlayer(requesterUUID);
                if (requester == null) {
                    sendActionBar(player, "&e&lTPA &8>> &fThe player who requested to teleport is no longer online.");
                    teleportRequests.remove(requesterUUID);
                    return true;
                }
                // Cancel the timeout task
                BukkitRunnable timeoutTask = teleportTasks.remove(requesterUUID);
                if (timeoutTask != null) {
                    timeoutTask.cancel();
                }

                pendingTeleports.put(requesterUUID, true); // Mark the requester as in the process of teleporting

                BukkitRunnable task = new BukkitRunnable() {
                    int counter = 5; // 5 seconds countdown

                    @Override
                    public void run() {
                        if (counter > 0) {
                            sendActionBar(requester, "&e&lTPA &8>> &fTeleport in " + counter + " seconds");
                            sendActionBar(player, "&e&lTPA &8>> &f" + requester.getName() + " is teleporting to you in " + counter + " seconds");
                            counter--;
                        } else {
                            if (pendingTeleports.containsKey(requesterUUID)) {
                                requester.teleport(player);
                                sendActionBar(requester, "&e&lTPA &8>> &fTeleport successful.");
                                sendActionBar(player, "&e&lTPA &8>> &fTeleport request accepted.");
                                pendingTeleports.remove(requesterUUID); // Remove from pending teleports
                                teleportTasks.remove(requesterUUID);
                                teleportRequests.remove(requesterUUID);
                                cancel(); // Stop the countdown
                            }
                        }
                    }
                };
                task.runTaskTimer(this, 0, 20); // Schedule to run every second (20 ticks)
                teleportTasks.put(requesterUUID, task);
                return true;

            case "tpdeny":
                UUID requesterUUIDDeny = teleportRequests.entrySet().stream()
                        .filter(e -> e.getValue().equals(player.getUniqueId()))
                        .map(Map.Entry::getKey)
                        .findFirst().orElse(null);
                if (requesterUUIDDeny == null) {
                    sendActionBar(player, "&e&lTPA &8>> &fYou have no pending teleport requests.");
                    return true;
                }
                teleportRequests.remove(requesterUUIDDeny);
                sendActionBar(player, "&e&lTPA &8>> &fTeleport request denied.");
                Player requesterDeny = Bukkit.getPlayer(requesterUUIDDeny);
                if (requesterDeny != null) {
                    sendActionBar(requesterDeny, "&e&lTPA &8>> &fYour teleport request was denied.");
                }
                return true;

            default:
                return false;
        }
    }

    @Override
    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
        if (command.getName().equalsIgnoreCase("tpa") && args.length == 1) {
            List<String> playerNames = new ArrayList<>();
            String partialName = args[0].toLowerCase();
            for (Player onlinePlayer : Bukkit.getOnlinePlayers()) {
                if (onlinePlayer.getName().toLowerCase().startsWith(partialName)) {
                    playerNames.add(onlinePlayer.getName());
                }
            }
            return playerNames;
        }
        return new ArrayList<>();
    }
}