/*
 * This program is free software: you can redistribute it and/or modify it under the terms of the
 * GNU General Public License as published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
 * even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with this program. If
 * not, see <http://www.gnu.org/licenses/>.
 */
package com.l2jserver.gameserver.network.clientpackets.skill;

import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;

import com.l2jserver.Config;
import com.l2jserver.gameserver.SingleTaskQueue;
import com.l2jserver.gameserver.datatables.SkillTable;
import com.l2jserver.gameserver.datatables.SkillTreeTable;
import com.l2jserver.gameserver.model.L2EnchantSkillLearn;
import com.l2jserver.gameserver.model.L2ItemInstance;
import com.l2jserver.gameserver.model.L2ShortCut;
import com.l2jserver.gameserver.model.L2Skill;
import com.l2jserver.gameserver.model.L2EnchantSkillLearn.EnchantSkillDetail;
import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
import com.l2jserver.gameserver.network.SystemMessageId;
import com.l2jserver.gameserver.network.SystemMessageId2;
import com.l2jserver.gameserver.network.clientpackets.L2GameClientPacket;
import com.l2jserver.gameserver.network.serverpackets.ExBrExtraUserInfo;
import com.l2jserver.gameserver.network.serverpackets.ExEnchantSkillInfo;
import com.l2jserver.gameserver.network.serverpackets.ExEnchantSkillInfoDetail;
import com.l2jserver.gameserver.network.serverpackets.ExEnchantSkillResult;
import com.l2jserver.gameserver.network.serverpackets.InventoryUpdate;
import com.l2jserver.gameserver.network.serverpackets.ItemList;
import com.l2jserver.gameserver.network.serverpackets.ShortCutInit;
import com.l2jserver.gameserver.network.serverpackets.ShortCutRegister;
import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
import com.l2jserver.gameserver.network.serverpackets.UserInfo;
import com.l2jserver.util.StringUtil;
import com.l2jserver.util.Rnd;

/**
 * based on previous version by -Wooden-
 *
 * @author Probe
 *
 */
public final class RequestExEnchantSkill extends L2GameClientPacket
{

    private static final String _C__D0_07_REQUESTEXENCHANTSKILL = "[C] D0:07 RequestExEnchantSkill";
    protected static final Logger _log = Logger.getLogger(RequestAquireSkill.class.getName());
    protected static final Logger _logEnchant = Logger.getLogger("enchant");
    private int _skillId;
    private int _skillLvl;

    @Override
    protected void readImpl()
    {
        _skillId = readD();
        _skillLvl = readD();
    }

    @Override
    protected void runImpl()
    {
        L2PcInstance player = getClient().getActiveChar();
        if (player == null)
        {
            return;
        }

        if (player.isInCombat())
        {
            return;
        }

        // requires to have 3rd class quest completed
        if (player.getClassId().level() < 3)
        {
            player.sendPacket(SystemMessageId2.YOU_CANNOT_USE_SKILL_ENCHANT_IN_THIS_CLASS);
            return;
        }

        if (player.getLevel() < 76)
        {
            player.sendPacket(SystemMessageId2.YOU_CANNOT_USE_SKILL_ENCHANT_ON_THIS_LEVEL);
            return;
        }

        if (!player.isAllowedToEnchantSkills())
        {
            player.sendPacket(SystemMessageId2.YOU_CANNOT_USE_SKILL_ENCHANT_ATTACKING_TRANSFORMED_BOAT);
            return;
        }

        SingleTaskQueue.getInstance().addTask(new Task(player, _skillId, _skillLvl));
    }

    @Override
    public String getType()
    {
        return _C__D0_07_REQUESTEXENCHANTSKILL;
    }

    static class Task implements Runnable
    {

        private final L2PcInstance player;
        private final int skillId;
        private final int skillLvl;

        Task(final L2PcInstance player, final int skillId, final int skillLvl)
        {
            this.player = player;
            this.skillId = skillId;
            this.skillLvl = skillLvl;
        }

        @Override
        public void run()
        {
            L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);

            if (skill == null)
            {
                return;
            }

            boolean linked = false;
            L2Skill _linkedSkill = null;

            if (player.getLinkedSkills() != null && !player.getLinkedSkills().isEmpty())
            {
                for (L2Skill linkedSkill : player.getLinkedSkills())
                {
                    if (linkedSkill.getId() == skillId)
                    {
                        linked = true;
                        _linkedSkill = linkedSkill;
                        break;
                    }
                }
            }

            final int costMultiplier = skill.getEnchantCostMultiplier();
            final int reqItemId = SkillTreeTable.NORMAL_ENCHANT_BOOK;

            final L2EnchantSkillLearn s = SkillTreeTable.getInstance().getSkillEnchantmentBySkillId(skillId);

            if (s == null)
            {
                return;
            }

            EnchantSkillDetail esd = s.getEnchantSkillDetail(skillLvl);

            if (esd == null)
            {
                return;
            }

            if (player.getSkillLevel(skillId) != esd.getMinSkillLevel())
            {
                return;
            }

            int requiredSp = esd.getSpCost(player.getClassId().isMage()) * costMultiplier * SkillTreeTable.NORMAL_ENCHANT_COST_MULTIPLIER;
            final int requiredAdena = (int) (esd.getAdenaCost() * costMultiplier * Config.RATE_ADENA_ENCHANT_SKILL);
            final int enchantMode = esd.getEnchantMode();
            final int rate = SkillTreeTable.getInstance().getEnchantSkillRate(player, skillLvl, enchantMode);
            boolean enchantSuccess = false;
            int newLevel;

            if (player.getSp() >= requiredSp)
            {
                if (player.getAdena() >= requiredAdena)
                {
                    // only first lvl requires book
                    final boolean usesBook = skillLvl % 100 == 1; // 101, 201, 301 ...
                    final L2ItemInstance spb = player.getInventory().getItemByItemId(reqItemId);

                    if (Config.ES_SP_BOOK_NEEDED && usesBook)
                    {
                        // Haven't spellbook
                        if (spb == null)
                        {
                            player.sendPacket(SystemMessageId.YOU_DONT_HAVE_ALL_OF_THE_ITEMS_NEEDED_TO_ENCHANT_THAT_SKILL);
                            return;
                        }
                    }

                    player.getStat().removeSp(requiredSp);
                    player.reduceAdena("Consume", requiredAdena, player, false);

                    if (Config.ES_SP_BOOK_NEEDED && usesBook)
                    {
                        player.destroyItem("Consume", spb.getObjectId(), 1, player, true);
                    }

                    // ok. Destroy ONE copy of the book
                    if (Rnd.get(100) <= rate)
                    {
                        if (Config.LOG_SKILL_ENCHANTS)
                        {
                            final LogRecord record = new LogRecord(Level.INFO, "Success");
                            record.setParameters(new Object[] { player, skill, spb, rate });
                            record.setLoggerName("skill");
                            _logEnchant.log(record);
                        }

                        if (linked && _linkedSkill != null)
                        {
                            player.removeSkillLinked(_linkedSkill);
                        }

                        player.addSkill(skill, true, linked);

                        newLevel = skill.getLevel();

                        if (_log.isLoggable(Level.FINE))
                        {
                            _log.fine(StringUtil.concat("Learned skill ID: ", String.valueOf(skillId), " Level: ", String.valueOf(skillLvl), " for ", String.valueOf(requiredSp), " SP, "));
                        }

                        player.sendPacket(new UserInfo(player));
                        player.sendPacket(new ExBrExtraUserInfo(player));

                        final SystemMessage sm = new SystemMessage(SystemMessageId.YOU_HAVE_SUCCEEDED_IN_ENCHANTING_THE_SKILL_S1);
                        sm.addSkillName(skillId);
                        player.sendPacket(sm);
                        enchantSuccess = true;
                    }
                    else
                    {
                        newLevel = SkillTable.getSkillLevelCount(skill.getId());
                        skill = SkillTable.getInstance().getInfo(skillId, newLevel);

                        if (linked && _linkedSkill != null)
                        {
                            player.removeSkillLinked(_linkedSkill);
                        }

                        player.addSkill(skill, true, linked);

                        final int route = esd.getLevel() / 100;
                        newLevel = route * 100 + 1;
                        esd = s.getEnchantSkillDetail(newLevel);

                        requiredSp = esd.getSpCost(player.getClassId().isMage()) * costMultiplier * SkillTreeTable.NORMAL_ENCHANT_COST_MULTIPLIER;

                        player.sendSkillList();
                        player.sendPacket(SystemMessageId.YOU_HAVE_FAILED_TO_ENCHANT_THE_SKILL_S1);

                        if (Config.LOG_SKILL_ENCHANTS)
                        {
                            final LogRecord record = new LogRecord(Level.INFO, "Fail");
                            record.setParameters(new Object[] { player, skill, spb, rate });
                            record.setLoggerName("skill");
                            _logEnchant.log(record);
                        }
                    }
                    // update packets info as retail
                    player.sendPacket(new InventoryUpdate());
                    player.sendPacket(new ItemList(player, false));
                    player.sendPacket(new ShortCutInit(player));
                    player.sendPacket(ExEnchantSkillResult.valueOf(enchantSuccess));
                    player.sendPacket(new ExEnchantSkillInfo(skill));
                    player.sendPacket(new ExEnchantSkillInfoDetail(enchantMode, skillId, newLevel, requiredSp, rate));

                    player.sendSkillList();
                    updateSkillShortcuts();

                }
                else
                {
                    player.sendPacket(SystemMessageId.YOU_DONT_HAVE_ALL_OF_THE_ITEMS_NEEDED_TO_ENCHANT_THAT_SKILL);
                }
            }
            else
            {
                player.sendPacket(SystemMessageId.YOU_DONT_HAVE_ENOUGH_SP_TO_ENCHANT_THAT_SKILL);
            }
        }

        private void updateSkillShortcuts()
        {
            // update all the shortcuts to this skill
            final L2ShortCut[] allShortCuts = player.getSettingsManagement().getAllShortCuts();

            for (final L2ShortCut sc : allShortCuts)
            {
                if (sc.getId() == skillId && sc.getType() == L2ShortCut.TYPE_SKILL)
                {
                    final L2ShortCut newsc = new L2ShortCut(sc.getSlot(), sc.getPage(), sc.getType(), sc.getId(), player.getSkillLevel(skillId), 1);
                    player.sendPacket(new ShortCutRegister(newsc));
                    player.getSettingsManagement().registerShortCut(newsc);
                }
            }
        }
    }
}