package com.alttd.essentia.commands;

import com.alttd.essentia.EssentiaPlugin;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.command.TabExecutor;
import org.jetbrains.annotations.NotNull;

import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public abstract class SubCommand implements TabExecutor {

    protected EssentiaPlugin plugin;
    private final String name;
    private final String[] aliases;
    private final Map<String, SubCommand> subCommands = new LinkedHashMap<>();

    protected SubCommand(EssentiaPlugin plugin, String name, String... aliases) {
        this.plugin = plugin;
        this.name = name;
        this.aliases = aliases;
    }

    protected abstract boolean execute(CommandSender sender, String... args);

    @Override
    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command cmd, @NotNull String label, String[] args) {
        if (args.length > 0) {
            SubCommand subCommand = getSubCommand(args[0]);
            if (subCommand != null) {
                return subCommand.onCommand(sender, cmd, args[0], Arrays.copyOfRange(args, 1, args.length));
            }
        }
        return execute(sender, args);
    }

    public List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String alias, String[] args) {
        if (args.length == 0) {
            return subCommands.keySet().stream()
                    .sorted(String::compareToIgnoreCase)
                    .collect(Collectors.toList());
        }

        SubCommand subCommand = getSubCommand(args[0]);
        if (subCommand != null) {
            return subCommand.onTabComplete(sender, command, args[0], Arrays.copyOfRange(args, 1, args.length));
        } else if (args.length == 1) {
            return subCommands.keySet().stream()
                    .filter(s -> s.toLowerCase().startsWith(args[0]))
                    .sorted(String::compareToIgnoreCase)
                    .collect(Collectors.toList());
        }
        return null;
    }

    public void registerSubCommand(SubCommand subCommand) {
        subCommands.put(subCommand.name.toLowerCase(), subCommand);
        for (String alias : subCommand.aliases) {
            subCommands.putIfAbsent(alias.toLowerCase(), subCommand);
        }
    }

    private SubCommand getSubCommand(String name) {
        return subCommands.get(name.toLowerCase());
    }
}