package de.mviper.adventskalender;

import org.bukkit.Bukkit;
import org.bukkit.command.*;
import org.bukkit.OfflinePlayer;
import org.bukkit.entity.Player;
import java.time.MonthDay;
import java.util.*;
import java.util.stream.Collectors;

public class AdventCommand implements CommandExecutor, TabCompleter {

    private static final int MAX_DAYS = 36;

    @Override
    public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
        Adventskalender plugin = Adventskalender.getInstance();

        // Christmas+-Kurzbefehle: /ac test  und  /ac reset <Spieler> <Tag|all>
        boolean elevated = false;
        if (args.length == 1 && args[0].equalsIgnoreCase("test")
                && sender instanceof Player tp && tp.hasPermission("christmasplus.adventcalendar.test")) {
            boolean on = de.mviper.adventskalender.christmas.CalendarPerks.toggle(tp);
            var xm = de.mviper.adventskalender.christmas.ChristmasManager.get();
            tp.sendMessage(xm != null ? xm.msg(on ? "calendar-test-on" : "calendar-test-off") : (on ? "Testmodus an" : "Testmodus aus"));
            return true;
        }
        if (args.length == 3 && args[0].equalsIgnoreCase("reset")
                && sender.hasPermission("christmasplus.adventcalendar.reset")) {
            args = args[2].equalsIgnoreCase("all")
                    ? new String[]{"admin", "reset", args[1]}
                    : new String[]{"admin", "resetday", args[1], args[2]};
            elevated = true;
        }

        if (args.length > 0 && args[0].equalsIgnoreCase("admin")) {
            if (!elevated && !sender.hasPermission("adventskalender.admin")) {
                sender.sendMessage(LanguageManager.getMessage("messages.no_permission"));
                return true;
            }

            // /ak admin reload
            if (args.length == 2 && args[1].equalsIgnoreCase("reload")) {
                plugin.reloadConfig();
                plugin.reloadSettings();
                LanguageManager.setup();
                DataHandler.setup();
                AdventInventory.initCache();
                de.mviper.adventskalender.christmas.ChristmasManager.reload();
                sender.sendMessage(LanguageManager.getMessage("messages.admin.reload_success"));
                return true;
            }

            // /ak admin test [Event] <Tag/reset>
            if ((args.length == 3 || args.length == 4) && args[1].equalsIgnoreCase("test")) {
                CalendarEvent ev = null;
                if (args.length == 4) {
                    ev = EventManager.getAny(args[2]);
                    if (ev == null) {
                        sendUnknownEvent(sender, args[2]);
                        return true;
                    }
                }
                String value = args[args.length - 1];
                List<CalendarEvent> targets = ev != null ? List.of(ev) : EventManager.allConfigured();

                if (value.equalsIgnoreCase("reset")) {
                    for (CalendarEvent t : targets) t.setTestDay(0);
                    sender.sendMessage(LanguageManager.getString("messages.admin.test_mode_off").replace("%event%", label(ev)));
                    return true;
                }

                int day = parseDay(value, ev != null ? ev.getDays() : MAX_DAYS);
                if (day == -1) {
                    sender.sendMessage(LanguageManager.getString("messages.admin.invalid_day"));
                    return true;
                }
                for (CalendarEvent t : targets) t.setTestDay(day);
                sender.sendMessage(LanguageManager.getString("messages.admin.test_mode_on")
                        .replace("%day%", String.valueOf(day)).replace("%event%", label(ev)));
                return true;
            }

            // /ak admin resetday [Event] <global/Spieler> <Tag>
            if ((args.length == 4 || args.length == 5) && args[1].equalsIgnoreCase("resetday")) {
                CalendarEvent ev = null;
                int shift = 0;
                if (args.length == 5) {
                    ev = EventManager.getAny(args[2]);
                    if (ev == null) {
                        sendUnknownEvent(sender, args[2]);
                        return true;
                    }
                    shift = 1;
                }
                String target = args[2 + shift];
                int day = parseDay(args[3 + shift], ev != null ? ev.getDays() : MAX_DAYS);
                if (day == -1) {
                    sender.sendMessage(LanguageManager.getString("messages.admin.invalid_day"));
                    return true;
                }

                final CalendarEvent event = ev;
                runAsync(() -> {
                    if (target.equalsIgnoreCase("global")) {
                        DataHandler.resetGlobalDay(event, day);
                        reply(sender, LanguageManager.getString("messages.admin.reset_day_global")
                                .replace("%day%", String.valueOf(day)).replace("%event%", label(event)));
                    } else {
                        boolean found = DataHandler.resetPlayerDay(target, event, day);
                        reply(sender, found
                                ? LanguageManager.getString("messages.admin.reset_day_player")
                                    .replace("%day%", String.valueOf(day)).replace("%player%", target).replace("%event%", label(event))
                                : LanguageManager.getString("messages.admin.player_not_found").replace("%player%", target));
                    }
                });
                return true;
            }

            // /ak admin reset [Event] <global/Spieler>
            if (args.length >= 3 && args[1].equalsIgnoreCase("reset")) {
                CalendarEvent ev = null;
                String targetName = args[2];
                if (args.length >= 4) {
                    ev = EventManager.getAny(args[2]);
                    if (ev == null) {
                        sendUnknownEvent(sender, args[2]);
                        return true;
                    }
                    targetName = args[3];
                }
                final CalendarEvent event = ev;
                final String name = targetName;

                if (name.equalsIgnoreCase("global")) {
                    runAsync(() -> {
                        DataHandler.resetAll(event);
                        Bukkit.getScheduler().runTask(plugin, AdventInventory::closeAll);
                        reply(sender, LanguageManager.getString("messages.admin.reset_all").replace("%event%", label(event)));
                    });
                } else {
                    Player target = Bukkit.getPlayerExact(name);
                    if (target != null) {
                        runAsync(() -> {
                            DataHandler.resetPlayer(target, event);
                            Bukkit.getScheduler().runTask(plugin, () -> AdventInventory.closeFor(target));
                            reply(sender, LanguageManager.getString("messages.admin.reset_player")
                                    .replace("%player%", target.getName()).replace("%event%", label(event)));
                        });
                    } else {
                        runAsync(() -> {
                            boolean found = DataHandler.resetOfflinePlayer(name, event);
                            reply(sender, found
                                    ? LanguageManager.getString("messages.admin.reset_offline")
                                        .replace("%player%", name).replace("%event%", label(event))
                                    : LanguageManager.getString("messages.admin.player_not_found").replace("%player%", name));
                        });
                    }
                }
                return true;
            }

            // /ak admin birthday <set|remove|reset> <Spieler> [TT.MM]
            if (args.length >= 4 && args[1].equalsIgnoreCase("birthday")) {
                String action = args[2].toLowerCase();
                String targetName = args[3];
                MonthDay date = null;
                if (action.equals("set")) {
                    date = args.length == 5 ? BirthdayManager.parse(args[4]) : null;
                    if (date == null) {
                        sender.sendMessage(LanguageManager.getMessage("birthday.invalid_date", "birthday.prefix"));
                        return true;
                    }
                } else if (!action.equals("remove") && !action.equals("reset")) {
                    for (String line : LanguageManager.getStringList("messages.admin.help")) sender.sendMessage(line);
                    return true;
                }

                final MonthDay md = date;
                runAsync(() -> {
                    @SuppressWarnings("deprecation")
                    OfflinePlayer target = Bukkit.getOfflinePlayer(targetName);
                    if (!target.isOnline() && !target.hasPlayedBefore()) {
                        reply(sender, LanguageManager.getString("messages.admin.player_not_found").replace("%player%", targetName));
                        return;
                    }
                    String shownName = target.getName() != null ? target.getName() : targetName;
                    try {
                        switch (action) {
                            case "set" -> {
                                DataHandler.setBirthday(target.getUniqueId(), shownName, md.getMonthValue(), md.getDayOfMonth(), false);
                                reply(sender, LanguageManager.getString("birthday.admin_set")
                                        .replace("%player%", shownName).replace("%date%", BirthdayManager.format(md)));
                            }
                            case "remove" -> {
                                boolean removed = DataHandler.removeBirthday(target.getUniqueId(), shownName);
                                reply(sender, LanguageManager.getString(removed ? "birthday.admin_removed" : "birthday.admin_none")
                                        .replace("%player%", shownName));
                            }
                            default -> {
                                boolean reset = DataHandler.resetBirthdayClaim(target.getUniqueId(), shownName);
                                reply(sender, LanguageManager.getString(reset ? "birthday.admin_reset" : "birthday.admin_none")
                                        .replace("%player%", shownName));
                            }
                        }
                    } catch (DataHandler.DataException e) {
                        reply(sender, LanguageManager.getMessage("messages.db_error"));
                    }
                });
                return true;
            }

            for (String line : LanguageManager.getStringList("messages.admin.help")) {
                sender.sendMessage(line);
            }
            return true;
        }

        if (!(sender instanceof Player player)) {
            sender.sendMessage(LanguageManager.getMessage("messages.only_player"));
            return true;
        }
        if (!player.hasPermission("adventskalender.use")) {
            player.sendMessage(LanguageManager.getMessage("messages.no_permission"));
            return true;
        }

        // /ak birthday [set <TT.MM> | claim | remove]
        if (args.length >= 1 && args[0].equalsIgnoreCase("birthday")) {
            if (!player.hasPermission("adventskalender.birthday")) {
                player.sendMessage(LanguageManager.getMessage("messages.no_permission"));
                return true;
            }
            if (args.length == 1) {
                BirthdayManager.handleInfo(player);
                BirthdayManager.sendHelp(player);
            } else if (args[1].equalsIgnoreCase("set") && args.length == 3) {
                BirthdayManager.handleSet(player, args[2]);
            } else if (args[1].equalsIgnoreCase("claim")) {
                BirthdayManager.handleClaim(player);
            } else if (args[1].equalsIgnoreCase("remove")) {
                BirthdayManager.handleRemove(player);
            } else {
                BirthdayManager.sendHelp(player);
            }
            return true;
        }

        // /ak [Event]
        CalendarEvent event;
        if (args.length >= 1) {
            event = EventManager.get(args[0]);
            if (event == null) {
                sendUnknownEvent(player, args[0]);
                return true;
            }
        } else {
            event = EventManager.defaultEvent();
            if (event == null) {
                player.sendMessage(LanguageManager.getMessage("messages.no_events"));
                return true;
            }
        }

        AdventInventory.open(player, event);
        return true;
    }

    private void sendUnknownEvent(CommandSender sender, String given) {
        String ids = EventManager.allConfigured().stream().map(CalendarEvent::getId).collect(Collectors.joining(", "));
        sender.sendMessage(LanguageManager.getMessage("messages.unknown_event")
                .replace("%event%", given).replace("%events%", ids));
    }

    /** Tag zwischen 1 und max, sonst -1. */
    private static int parseDay(String value, int max) {
        try {
            int day = Integer.parseInt(value);
            return (day >= 1 && day <= max) ? day : -1;
        } catch (NumberFormatException e) {
            return -1;
        }
    }

    private static String label(CalendarEvent ev) {
        return ev != null ? ev.getId() : LanguageManager.getString("messages.admin.all_events");
    }

    private void runAsync(Runnable task) {
        Bukkit.getScheduler().runTaskAsynchronously(Adventskalender.getInstance(), task);
    }

    /** Sendet die Antwort im Main-Thread. */
    private void reply(CommandSender sender, String message) {
        Bukkit.getScheduler().runTask(Adventskalender.getInstance(), () -> sender.sendMessage(message));
    }

    // ------------------------------------------------------------------ Tab-Completion

    private static List<String> filter(Collection<String> options, String prefix) {
        return options.stream()
                .filter(opt -> opt.toLowerCase().startsWith(prefix.toLowerCase()))
                .collect(Collectors.toList());
    }

    private static List<String> eventIds() {
        return EventManager.allConfigured().stream().map(CalendarEvent::getId).collect(Collectors.toList());
    }

    private static List<String> targets() {
        List<String> options = new ArrayList<>();
        options.add("global");
        Bukkit.getOnlinePlayers().forEach(p -> options.add(p.getName()));
        return options;
    }

    private static List<String> dayOptions(int max) {
        List<String> days = new ArrayList<>();
        for (int i = 1; i <= max; i++) days.add(String.valueOf(i));
        return days;
    }

    @Override
    public List<String> onTabComplete(CommandSender s, Command c, String a, String[] args) {
        boolean admin = s.hasPermission("adventskalender.admin");

        if (args.length == 1) {
            List<String> options = new ArrayList<>(EventManager.all().stream().map(CalendarEvent::getId).toList());
            if (BirthdayManager.isEnabled() && s.hasPermission("adventskalender.birthday")) options.add("birthday");
            if (admin) options.add("admin");
            return filter(options, args[0]);
        }

        if (args[0].equalsIgnoreCase("birthday")) {
            if (args.length == 2) return filter(Arrays.asList("set", "claim", "remove"), args[1]);
            return Collections.emptyList();
        }

        if (!admin || !args[0].equalsIgnoreCase("admin")) return Collections.emptyList();

        if (args.length == 2) return filter(Arrays.asList("reload", "test", "reset", "resetday", "birthday"), args[1]);

        if (args[1].equalsIgnoreCase("birthday")) {
            if (args.length == 3) return filter(Arrays.asList("set", "remove", "reset"), args[2]);
            if (args.length == 4) return filter(targets().stream().filter(t -> !t.equals("global")).collect(Collectors.toList()), args[3]);
            return Collections.emptyList();
        }

        String sub = args[1].toLowerCase();
        String last = args[args.length - 1];
        CalendarEvent ev = EventManager.getAny(args[2]);

        switch (sub) {
            case "test": {
                if (args.length == 3) {
                    List<String> options = new ArrayList<>(eventIds());
                    options.add(0, "reset");
                    options.addAll(dayOptions(MAX_DAYS));
                    return filter(options, last);
                }
                if (args.length == 4 && ev != null) {
                    List<String> options = new ArrayList<>(dayOptions(ev.getDays()));
                    options.add(0, "reset");
                    return filter(options, last);
                }
                break;
            }
            case "reset": {
                if (args.length == 3) {
                    List<String> options = new ArrayList<>(eventIds());
                    options.addAll(targets());
                    return filter(options, last);
                }
                if (args.length == 4 && ev != null) return filter(targets(), last);
                break;
            }
            case "resetday": {
                if (args.length == 3) {
                    List<String> options = new ArrayList<>(eventIds());
                    options.addAll(targets());
                    return filter(options, last);
                }
                if (args.length == 4) {
                    return ev != null ? filter(targets(), last) : filter(dayOptions(MAX_DAYS), last);
                }
                if (args.length == 5 && ev != null) return filter(dayOptions(ev.getDays()), last);
                break;
            }
            default:
                break;
        }
        return Collections.emptyList();
    }
}