package com.gmail.nossr50.skills;

import org.bukkit.block.Block;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.FoodLevelChangeEvent;
import org.bukkit.inventory.ItemStack;
import org.getspout.spoutapi.SpoutManager;
import org.getspout.spoutapi.player.SpoutPlayer;

import com.gmail.nossr50.mcMMO;
import com.gmail.nossr50.config.AdvancedConfig;
import com.gmail.nossr50.config.Config;
import com.gmail.nossr50.datatypes.PlayerProfile;
import com.gmail.nossr50.events.experience.McMMOPlayerLevelUpEvent;
import com.gmail.nossr50.locale.LocaleLoader;
import com.gmail.nossr50.spout.SpoutConfig;
import com.gmail.nossr50.spout.SpoutStuff;
import com.gmail.nossr50.util.Misc;
import com.gmail.nossr50.util.ModChecks;
import com.gmail.nossr50.util.Permissions;
import com.gmail.nossr50.util.Users;

public class SkillTools {
    static AdvancedConfig advancedConfig = AdvancedConfig.getInstance();
    public static int abilityLengthIncreaseLevel = advancedConfig.getAbilityLength();
    public static boolean abilitiesEnabled = Config.getInstance().getAbilitiesEnabled();

    public static void handleFoodSkills(Player player, SkillType skill, FoodLevelChangeEvent event, int baseLevel, int maxLevel, int rankChange) {
        int skillLevel = Users.getProfile(player).getSkillLevel(skill);
        int currentFoodLevel = player.getFoodLevel();
        int newFoodLevel = event.getFoodLevel();
        int foodChange = newFoodLevel - currentFoodLevel;

        for (int i = baseLevel; i <= maxLevel; i+= rankChange) {
            if (skillLevel >= i) {
                foodChange++;
            }
        }

        /* Make sure we don't go over the max value */
        newFoodLevel = currentFoodLevel + foodChange;
        if (newFoodLevel > 20) {
            event.setFoodLevel(20);
        }
        else {
            event.setFoodLevel(newFoodLevel);
        }
    }

    /**
     * Checks to see if the cooldown for an item or ability is expired.
     *
     * @param oldTime The time the ability or item was last used
     * @param cooldown The amount of time that must pass between uses
     * @param player The player whose cooldown is being checked
     * @return true if the cooldown is over, false otherwise
     */
    public static boolean cooldownOver(long oldTime, int cooldown, Player player) {
        long currentTime = System.currentTimeMillis();
        int adjustedCooldown = cooldown;

        //Reduced Cooldown Donor Perks
        if (Permissions.cooldownsHalved(player)) {
            adjustedCooldown = (int) (adjustedCooldown * 0.5);
        }
        else if (Permissions.cooldownsThirded(player)) {
            adjustedCooldown = (int) (adjustedCooldown * 0.66);
        }
        else if (Permissions.cooldownsQuartered(player)) {
            adjustedCooldown = (int) (adjustedCooldown * 0.75);
        }

        if (currentTime - oldTime >= (adjustedCooldown * Misc.TIME_CONVERSION_FACTOR)) {
            return true;
        }

        return false;
    }

    /**
     * Calculate the time remaining until the cooldown expires.
     *
     * @param deactivatedTimeStamp Time of deactivation
     * @param cooldown The length of the cooldown
     * @return the number of seconds remaining before the cooldown expires
     */
    public static int calculateTimeLeft(long deactivatedTimeStamp, int cooldown, Player player) {
        int adjustedCooldown = cooldown;

        //Reduced Cooldown Donor Perks
        if (Permissions.cooldownsHalved(player)) {
            adjustedCooldown = (int) (adjustedCooldown * 0.5);
        }
        else if (Permissions.cooldownsThirded(player)) {
            adjustedCooldown = (int) (adjustedCooldown * 0.66);
        }
        else if (Permissions.cooldownsQuartered(player)) {
            adjustedCooldown = (int) (adjustedCooldown * 0.75);
        }

        return (int) (((deactivatedTimeStamp + (adjustedCooldown * Misc.TIME_CONVERSION_FACTOR)) - System.currentTimeMillis()) / Misc.TIME_CONVERSION_FACTOR);
    }

    /**
     * Sends a message to the player when the cooldown expires.
     *
     * @param player The player to send a message to
     * @param profile The profile of the player
     * @param ability The ability to watch cooldowns for
     */
    public static void watchCooldown(Player player, PlayerProfile profile, AbilityType ability) {
        if (player == null || profile == null || ability == null)
            return;

        if (!profile.getAbilityInformed(ability) && cooldownOver(profile.getSkillDATS(ability) * Misc.TIME_CONVERSION_FACTOR, ability.getCooldown(), player)) {
            profile.setAbilityInformed(ability, true);
            player.sendMessage(ability.getAbilityRefresh());
        }
    }

    /**
     * Process activating abilities & readying the tool.
     *
     * @param player The player using the ability
     * @param skill The skill the ability is tied to
     */
    public static void activationCheck(Player player, SkillType skill) {
        if (Config.getInstance().getAbilitiesOnlyActivateWhenSneaking() && !player.isSneaking()) {
            return;
        }

        PlayerProfile profile = Users.getProfile(player);
        AbilityType ability = skill.getAbility();
        ToolType tool = skill.getTool();
        ItemStack inHand = player.getItemInHand();

        if (ModChecks.isCustomTool(inHand) && !ModChecks.getToolFromItemStack(inHand).isAbilityEnabled()) {
            return;
        }

        /* Check if any abilities are active */
        if (profile == null) {
            return;
        }

        if (!profile.getAbilityUse()) {
            return;
        }

        for (AbilityType x : AbilityType.values()) {
            if (profile.getAbilityMode(x)) {
                return;
            }
        }

        /* Woodcutting & Axes need to be treated differently.
         * Basically the tool always needs to ready and we check to see if the cooldown is over when the user takes action
         */
        if (ability.getPermissions(player) && tool.inHand(inHand) && !profile.getToolPreparationMode(tool)) {
            if (skill != SkillType.WOODCUTTING && skill != SkillType.AXES) {
                if (!profile.getAbilityMode(ability) && !cooldownOver(profile.getSkillDATS(ability) * Misc.TIME_CONVERSION_FACTOR, ability.getCooldown(), player)) {
                    player.sendMessage(LocaleLoader.getString("Skills.TooTired", new Object[] { calculateTimeLeft(profile.getSkillDATS(ability) * Misc.TIME_CONVERSION_FACTOR, ability.getCooldown(), player) }));
                    return;
                }
            }

            if (Config.getInstance().getAbilityMessagesEnabled()) {
                player.sendMessage(tool.getRaiseTool());
            }

            profile.setToolPreparationATS(tool, System.currentTimeMillis());
            profile.setToolPreparationMode(tool, true);
        }
    }

    /**
     * Monitors various things relating to skill abilities.
     *
     * @param player The player using the skill
     * @param profile The profile of the player
     * @param curTime The current system time
     * @param skill The skill being monitored
     */
    public static void monitorSkill(Player player, PlayerProfile profile, long curTime, SkillType skill) {
        final int FOUR_SECONDS = 4000;

        ToolType tool = skill.getTool();
        AbilityType ability = skill.getAbility();

        if (profile == null) {
            return;
        }

        if (profile.getToolPreparationMode(tool) && curTime - (profile.getToolPreparationATS(tool) * Misc.TIME_CONVERSION_FACTOR) >= FOUR_SECONDS) {
            profile.setToolPreparationMode(tool, false);

            if (Config.getInstance().getAbilityMessagesEnabled()) {
                player.sendMessage(tool.getLowerTool());
            }
        }

        if (ability.getPermissions(player)) {
            if (profile.getAbilityMode(ability) && (profile.getSkillDATS(ability) * Misc.TIME_CONVERSION_FACTOR) <= curTime) {
                if (ability == AbilityType.BERSERK) {
                    player.setCanPickupItems(true);
                }

                profile.setAbilityMode(ability, false);
                profile.setAbilityInformed(ability, false);
                player.sendMessage(ability.getAbilityOff());

                Misc.sendSkillMessage(player, ability.getAbilityPlayerOff(player));
            }
        }
    }

    /**
     * Check the XP of a skill.
     *
     * @param skillType The skill to check
     * @param player The player whose skill to check
     * @param profile The profile of the player whose skill to check
     */
    public static void xpCheckSkill(SkillType skillType, Player player, PlayerProfile profile) {
        int skillups = 0;

        if (profile.getSkillXpLevel(skillType) >= profile.getXpToLevel(skillType)) {

            while (profile.getSkillXpLevel(skillType) >= profile.getXpToLevel(skillType)) {
                if ((skillType.getMaxLevel() >= profile.getSkillLevel(skillType) + 1) && (Misc.getPowerLevelCap() >= Users.getPlayer(player).getPowerLevel() + 1)) {
                    profile.removeXP(skillType, profile.getXpToLevel(skillType));
                    skillups++;
                    profile.skillUp(skillType, 1);

                    McMMOPlayerLevelUpEvent eventToFire = new McMMOPlayerLevelUpEvent(player, skillType);
                    mcMMO.p.getServer().getPluginManager().callEvent(eventToFire);
                }
                else {
                    profile.addLevels(skillType, 0);
                }
            }

            String capitalized = Misc.getCapitalized(skillType.toString());

            /* Spout Stuff */
            if (mcMMO.spoutEnabled) {
                SpoutPlayer spoutPlayer = SpoutManager.getPlayer(player);

                if (spoutPlayer != null && spoutPlayer.isSpoutCraftEnabled()) {
                    SpoutStuff.levelUpNotification(skillType, spoutPlayer);

                    /* Update custom titles */
                    if (SpoutConfig.getInstance().getShowPowerLevel()) {
                        spoutPlayer.setTitle(LocaleLoader.getString("Spout.Title", new Object[] {spoutPlayer.getName(), Users.getPlayer(player).getPowerLevel()} ));
                    }
                }
                else {
                    player.sendMessage(LocaleLoader.getString(capitalized + ".Skillup", new Object[] {String.valueOf(skillups), profile.getSkillLevel(skillType)}));
                }
            }
            else {
                player.sendMessage(LocaleLoader.getString(capitalized + ".Skillup", new Object[] {String.valueOf(skillups), profile.getSkillLevel(skillType)}));
            }
        }

        if (mcMMO.spoutEnabled) {
            SpoutPlayer spoutPlayer = (SpoutPlayer) player;

            if (spoutPlayer != null && spoutPlayer.isSpoutCraftEnabled()) {
                if (SpoutConfig.getInstance().getXPBarEnabled()) {
                    profile.getSpoutHud().updateXpBar();
                }
            }
        }
    }

    /**
     * Check XP of all skills.
     *
     * @param player The player to check XP for.
     * @param profile The profile of the player whose skill to check
     */
    public static void xpCheckAll(Player player, PlayerProfile profile) {
        for (SkillType skillType : SkillType.values()) {
            //Don't want to do anything with this one
            if (skillType == SkillType.ALL || skillType.isChildSkill()) {
                continue;
            }

            xpCheckSkill(skillType, player, profile);
        }
    }

    /**
     * Get the skill represented by the given string
     *
     * @param skillName The name of the skill
     * @return the SkillType if it exists, null otherwise
     */
    public static SkillType getSkillType(String skillName) {
        for (SkillType x : SkillType.values()) {
            if (x.toString().equals(skillName.toUpperCase())) {
                return x;
            }
        }

        return null;
    }

    /**
     * Checks if the given string represents a valid skill
     *
     * @param skillname The name of the skill to check
     * @return true if this is a valid skill, false otherwise
     */
    public static boolean isSkill(String skillName) {
        if (getSkillType(skillName) != null) {
            return true;
        }

        return false;
    }

    public static boolean isLocalizedSkill(String skillName) {
        for (SkillType skill : SkillType.values()) {
            if (skillName.equalsIgnoreCase(LocaleLoader.getString(Misc.getCapitalized(skill.toString() + ".SkillName")))) {
                return true;
            }
        }

        return false;
    }

    public static String translateLocalizedSkill(String skillName) {
        for (SkillType skill : SkillType.values()) {
            if (skillName.equalsIgnoreCase(LocaleLoader.getString(Misc.getCapitalized(skill.toString() + ".SkillName")))) {
                return skill.toString();
            }
        }

        return null;
    }

    public static String localizeSkillName(SkillType skill) {
        return Misc.getCapitalized(LocaleLoader.getString(Misc.getCapitalized(skill.toString()) + ".SkillName"));
    }

    /**
     * Check if the player has any combat skill permissions.
     *
     * @param player The player to check permissions for
     * @return true if the player has combat skills, false otherwise
     */
    public static boolean hasCombatSkills(Player player) {
        if (Permissions.axes(player)
                || Permissions.archery(player)
                || Permissions.swords(player)
                || Permissions.taming(player)
                || Permissions.unarmed(player)) {
            return true;
        }

        return false;
    }

    /**
     * Check if the player has any gathering skill permissions.
     *
     * @param player The player to check permissions for
     * @return true if the player has gathering skills, false otherwise
     */
    public static boolean hasGatheringSkills(Player player) {
        if (Permissions.excavation(player)
                || Permissions.fishing(player)
                || Permissions.herbalism(player)
                || Permissions.mining(player)
                || Permissions.woodcutting(player)) {
            return true;
        }

        return false;
    }

    /**
     * Check if the player has any misc skill permissions.
     *
     * @param player The player to check permissions for
     * @return true if the player has misc skills, false otherwise
     */
    public static boolean hasMiscSkills(Player player) {
        if (Permissions.acrobatics(player) || Permissions.repair(player)) {
            return true;
        }

        return false;
    }

    /**
     * Handle tool durability loss from abilities.
     *
     * @param inHand The item to damage
     * @param durabilityLoss The durability to remove from the item
     */
    public static void abilityDurabilityLoss(ItemStack inHand, int durabilityLoss) {
        if (Config.getInstance().getAbilitiesDamageTools()) {
            if (inHand.containsEnchantment(Enchantment.DURABILITY)) {
                int level = inHand.getEnchantmentLevel(Enchantment.DURABILITY);
                if (Misc.getRandom().nextInt(level + 1) > 0) {
                    return;
                }
            }
            inHand.setDurability((short) (inHand.getDurability() + durabilityLoss));
        }
    }

    /**
     * Check to see if an ability can be activated.
     *
     * @param player The player activating the ability
     * @param type The skill the ability is based on
     */
    public static void abilityCheck(Player player, SkillType type) {
        PlayerProfile profile = Users.getProfile(player);
        ToolType tool = type.getTool();
        AbilityType ability = type.getAbility();

        profile.setToolPreparationMode(tool, false);

        /* Axes and Woodcutting are odd because they share the same tool.
         * We show them the too tired message when they take action.
         */
        if (type == SkillType.WOODCUTTING || type == SkillType.AXES) {
            if (!profile.getAbilityMode(ability) && !cooldownOver(profile.getSkillDATS(ability) * Misc.TIME_CONVERSION_FACTOR, ability.getCooldown(), player)) {
                player.sendMessage(LocaleLoader.getString("Skills.TooTired", new Object[] { calculateTimeLeft(profile.getSkillDATS(ability) * Misc.TIME_CONVERSION_FACTOR, ability.getCooldown(), player) }));
                return;
            }
        }

        int ticks = 2 + (profile.getSkillLevel(type) / abilityLengthIncreaseLevel);

        if (Permissions.activationTwelve(player)) {
            ticks = ticks + 12;
        }
        else if (Permissions.activationEight(player)) {
            ticks = ticks + 8;
        }
        else if (Permissions.activationFour(player)) {
            ticks = ticks + 4;
        }

        int maxTicks = ability.getMaxTicks();

        if (maxTicks != 0 && ticks > maxTicks) {
            ticks = maxTicks;
        }

        if (!profile.getAbilityMode(ability) && cooldownOver(profile.getSkillDATS(ability), ability.getCooldown(), player)) {
            player.sendMessage(ability.getAbilityOn());

            Misc.sendSkillMessage(player, ability.getAbilityPlayer(player));

            profile.setSkillDATS(ability, System.currentTimeMillis() + (ticks * Misc.TIME_CONVERSION_FACTOR));
            profile.setAbilityMode(ability, true);
            if (ability == AbilityType.BERSERK) {
                player.setCanPickupItems(false);
            }
        }
    }

    /**
     * Check to see if ability should be triggered.
     *
     * @param player The player using the ability
     * @param block The block modified by the ability
     * @param ability The ability to check
     * @return true if the ability should activate, false otherwise
     */
    public static boolean triggerCheck(Player player, Block block, AbilityType ability) {
        boolean activate = true;

        switch (ability) {
        case BERSERK:
        case GIGA_DRILL_BREAKER:
        case SUPER_BREAKER:
        case LEAF_BLOWER:
            if (!ability.blockCheck(block)) {
                activate = false;
                break;
            }

            if (!Misc.blockBreakSimulate(block, player, true)) {
                activate = false;
                break;
            }
            break;

        case GREEN_TERRA:
            if (!ability.blockCheck(block)) {
                activate = false;
                break;
            }
            break;

        default:
            activate = false;
            break;
        }

        return activate;
    }

    /**
     * Handle the processing of XP gain from individual skills.
     *
     * @param player The player that gained XP
     * @param profile The profile of the player gaining XP
     * @param type The type of skill to gain XP from
     * @param xp the amount of XP to gain
     */
    public static void xpProcessing(Player player, PlayerProfile profile, SkillType type, int xp) {
        if ((type.getMaxLevel() < profile.getSkillLevel(type) + 1) || (Misc.getPowerLevelCap() < Users.getPlayer(player).getPowerLevel() + 1)) {
            return;
        }

        Users.getPlayer(player).addXP(type, xp);
        xpCheckSkill(type, player, profile);
    }
}