package net.uomc.mineshaft;

import net.uomc.mineshaft.crafting.Crafting;
import net.uomc.mineshaft.resources.Resource;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.stream.Collectors;

import javax.security.auth.login.LoginException;

import org.apache.commons.collections4.map.LinkedMap;
import org.json.JSONException;
import org.json.JSONObject;

import com.mouldycheerio.dbot.CustomBot;
import com.mouldycheerio.dbot.commands.AvatarCommand;
import com.mouldycheerio.dbot.commands.CommandDetails;
import com.mouldycheerio.dbot.commands.DetailedCommand;
import com.mouldycheerio.dbot.commands.ProfileCommand;
import com.mouldycheerio.dbot.commands.ServerInfoCommand;
import com.mouldycheerio.dbot.commands.cooldowns.CooldownCommand;
import com.mouldycheerio.dbot.logging.FullLogger;
import com.mouldycheerio.dbot.starboard.StarboardController;
import com.mouldycheerio.dbot.util.PeelingUtils;

import net.dv8tion.jda.api.entities.Member;
import net.uomc.mineshaft.resources.ResourceManager;

public class Mineshaft extends CustomBot {

    private StarboardController starboardController;
    private FullLogger logger;
    private ResourceManager resourceManager;
    private Pickaxes pickaxes;
    private Crafting crafting;
    private MineCommand mineCommand;

    public Mineshaft(JSONObject config) throws LoginException, JSONException, IOException, InterruptedException {
        super(config);

        pickaxes = new Pickaxes(this);
        crafting = new Crafting(this);
        getCommandController().addCommand(crafting);

        getCommandController().addCommand(new ProfileCommand());
        getCommandController().addCommand(new AvatarCommand());
        getCommandController().addCommand(new ServerInfoCommand());

        starboardController = new StarboardController(this);

        resourceManager = new ResourceManager(this);

        getCommandController().addCommand(new DailyCommand(this));
        getCommandController().addCommand(new EnchantCommand(this));
        getCommandController().addCommand(new FurnaceCommand(this));
        getCommandController().addCommand(new PickaxeCommand(this));

        mineCommand = new MineCommand(this);
        getCommandController().addCommand(mineCommand);
        getCommandController().addCommand(new FishCommand(this));
        getCommandController().addCommand(new RobCommand(this));


        getCommandController().removeCommand("help");
        getCommandController().addCommand(CommandDetails.from("help"), (e, b, args) -> {
            String title = "Mineshaft";
            StringBuilder notes = new StringBuilder();
            notes.append("It's time to go mining!\n\n");
            notes.append("**Mine** ores with `m!mine`, or **fish** with `m!fish`\n");
            notes.append("Upgrade your **pickaxe** and find new ores `m!pickaxe`\n");
            notes.append("**Craft** new items `m!craft`\n");
            notes.append("Fight other players! `m!pvp`\n");
            notes.append("Share your resources `m!give`\n");
            notes.append("Become the **top** valuable player `m!top`\n");
            notes.append("\nGet free **daily** ores with `m!daily`\n");

            sendMessage(e, title, notes.toString());
        });

        getCommandController().addCommand(CommandDetails.from("patchnotes,changelog"), (e, b, args) -> {
            // TODO update when changes
            String title = "Patch Notes";
            StringBuilder notes = new StringBuilder();
            notes.append("### v0.3.1\n");
            notes.append("- Added furnace crafting recipe\n");
            notes.append("- Added `m!daily` to get daily commands\n");
            notes.append("- Balanced amount of ores needed to upgrade pickaxe\n");
            notes.append("- Fix obsidian not spawning\n");
            notes.append("- Added `m!cooldowns`\n");
            notes.append("### v0.3\n");
            notes.append("- Added items for all ores `m!inventory`\n");
            notes.append("- Added pickaxe levels `m!pickaxe`\n");
            notes.append("    - Pickaxe can be upgraded, giving access to better ores (`m!pickaxe upgrade`)\n");
            notes.append("- Added enchanting `m!enchant`\n");
            notes.append("    - Your pickaxe can be enchanted by spending lapis and xp\n");
            notes.append("    - Owning bookshelves gives you a discount on the amount of levels it costs to enchant\n");
            notes.append("- Added crafting `m!craft`\n");
            notes.append("    - Enchanting table and books can now be crafted!\n");
            notes.append("- Fishing now drops books\n");
            notes.append("- Rob has been relaced with `m!kill`\n");
            notes.append("    - Killing a player will drop some of their items\n");
            notes.append("- Added obsidian\n");
            notes.append("- Removed `m!flip`, this will be added in a future update (with a new mechanic)\n");

            sendMessage(e, title, notes.toString());
        });

        getCommandController().addCommand(CommandDetails.from("cooldowns,cd"), (e, b, args) -> {
            StringBuilder cooldowns = new StringBuilder();
            b.getCommandController().getCommands().entrySet().stream().map((x) -> x.getValue())
                    .filter(c -> c instanceof CooldownCommand)
                    .map(c -> (CooldownCommand) c)
                    .sorted((c1, c2) -> {
                        return Long.compareUnsigned(c1.getCooldownController().getNextTime(e.getMember(), c1.getName()),
                                c2.getCooldownController().getNextTime(e.getMember(), c2.getName()));
                    })
                    .forEach(c -> {
                        long nextCooldownTime = ((CooldownCommand) c).getCooldownController()
                                .getNextTime(e.getMember(), ((CooldownCommand) c).getName());
                        if (nextCooldownTime == 0)
                            return;
                        String timeLeft = PeelingUtils.formatTimeRelative(nextCooldownTime);

                        if (System.currentTimeMillis() > nextCooldownTime) {
                            return;
                        }

                        cooldowns.append("**");
                        cooldowns.append(((CooldownCommand) c).getName());
                        cooldowns.append("**\t");
                        cooldowns.append(timeLeft);
                        cooldowns.append("\n");
                    });
            if (cooldowns.length() == 0) {
                cooldowns.append("You have no active cooldowns");
            }

            b.sendMessage(e, "Active cooldowns", cooldowns.toString());
        });

        logger = new FullLogger(this);
    }

    public StarboardController getStarboardController() {
        return starboardController;
    }

    public FullLogger getLogger() {
        return logger;
    }

    public ResourceManager getResourceManager() {
        return resourceManager;
    }

    public long getItem(Member member, MineshaftItem item) {
        return resourceManager.getResource(member, item.toString());
    }

    public Resource getItem(MineshaftItem item) {
        return resourceManager.getResource(item.toString());
    }

    public void setItem(Member member, MineshaftItem item, long amount) {
        resourceManager.setResource(member, item.toString(), amount);
    }

    public void addItem(Member member, MineshaftItem item, long amount){
        resourceManager.addResource(member, item.toString(), amount);
    }

    public void addItems(Member member, Map<MineshaftItem, Long> items) {
        resourceManager.addResources(member, items.entrySet().stream()
                .collect(Collectors.toMap(
                        e -> e.getKey().toString(),
                        Map.Entry::getValue
                        ))
                );
    }

    public Map<MineshaftItem, Long> sumItems(Map<MineshaftItem, Long> items1, Map<MineshaftItem, Long> items2) {
        Map<MineshaftItem, Long> items = new HashMap<>(items1);
        items2.forEach((k, v) -> {
            if (items.containsKey(k)) {
                items.put(k, items.get(k) + v);
            } else {
                items.put(k, v);
            }
        });
        return items;
    }

    public void removeItem(Member member, MineshaftItem item, long amount) {
        resourceManager.addResource(member, getItem(item).getName(), -amount);
    }

    public void removeItems(Member member, Map<MineshaftItem, Long> items) {
        addItems(member, items.entrySet().stream().collect(Collectors.toMap(
                        Map.Entry::getKey,
                        e -> -e.getValue()
            )));
    }

    public String createItemList(Map<MineshaftItem, Long> items) {
        LinkedHashMap<MineshaftItem, Long> itemsLinked = new LinkedHashMap<>(items);
        return resourceManager.createResourceList(itemsLinked.entrySet().stream()
                .collect(Collectors.toMap(
                        e -> e.getKey().toString(),
                        Map.Entry::getValue
                        ))
                );
    }

    public String createItemList(Map<MineshaftItem, Long> items, String format) {
        return Arrays.asList(
                createItemList(items).split("\n")).stream()
                .map(s -> String.format(format, s)).collect(Collectors.joining("\n"));
    }

    public String createItemList(Map<MineshaftItem, Long> items, String format, String join) {
        return Arrays.asList(
                createItemList(items).split("\n")).stream()
                .map(s -> String.format(format, s)).collect(Collectors.joining(join));
    }

    public Map<MineshaftItem, Long> multiply(Map<MineshaftItem, Long> items, double amount) {
        return items.entrySet().stream().collect(Collectors.toMap(
                        e -> e.getKey(),
                        e -> (long) Math.floor(e.getValue() * amount)
                        ));
    }

    public Map<MineshaftItem, Long> getInventory(Member member) {
        Map<MineshaftItem, Long> inv = new HashMap<>();
        resourceManager.getResources().forEach(r -> {
            MineshaftItem item = MineshaftItem.valueOf(r.getName().toUpperCase());
            inv.put(item, r.get(member));
        });

        return inv;
    }

    public boolean hasItems(Member member, Map<MineshaftItem, Long> items) {
        return items.entrySet().stream().map(e -> {
            long a = getItem(member, e.getKey());
            return a >= e.getValue();
        }).reduce(Boolean.TRUE, Boolean::logicalAnd);
    }

    public Pickaxes getPickaxes() {
        return pickaxes;
    }

    public MineCommand getMineCommand() {
        return mineCommand;
    }

    public Map<MineshaftItem, Long> getMissingIngredients(Member member, Map<MineshaftItem, Long> items) {
        Map<MineshaftItem, Long> lacking = new HashMap<MineshaftItem, Long>();
        items.forEach((item, q) -> {
            if (getItem(member, item) < q) {
                lacking.put(item, q - getItem(member, item));
            }
        });

        return Collections.unmodifiableMap(lacking);
    }
}