/*
 * Copyright 2008 Ben Boeckel <MathStuf@gmail.com>
 * 
 * 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/>.
 */

// Header include
#include "AbilityEffectUI.h"

// Pokemod includes
#include "../pokemod/Ability.h"
#include "../pokemod/AbilityEffect.h"
#include "../pokemod/Pokemod.h"
#include "../pokemod/Type.h"

AbilityEffectUI::AbilityEffectUI(AbilityEffect* effect, QWidget* parent) :
        ObjectUI(parent),
        m_lastEffect(-1),
        m_lastTrigger(-1)
{
    setupUi(this);
    QMetaObject::connectSlotsByName(this);
    setObjects(effect, new AbilityEffect(*effect));
    init();
}

AbilityEffectUI::~AbilityEffectUI()
{
}

void AbilityEffectUI::initGui()
{
    varEffect->addItems(AbilityEffect::EffectStr);
    varTrigger->addItems(AbilityEffect::TriggerStr);
}

void AbilityEffectUI::refreshGui()
{
}

void AbilityEffectUI::setGui()
{
    const bool resetEffects = (static_cast<AbilityEffect*>(modified())->effect() == m_lastEffect);
    const bool resetTrigger = (static_cast<AbilityEffect*>(modified())->trigger() == m_lastTrigger);
    varChance->setValue(static_cast<AbilityEffect*>(modified())->chance());
    varEffect->setCurrentIndex(static_cast<AbilityEffect*>(modified())->effect());
    m_lastEffect = static_cast<AbilityEffect*>(modified())->effect();
    if (resetEffects)
    {
        varValue1->clear();
        varValue1->setEnabled(true);
        varValue2->clear();
        varValue2->setEnabled(true);
        varValue3->setEnabled(true);
        switch (m_lastEffect)
        {
            case AbilityEffect::E_Stats:
                for (int i = Pokemod::ST_No_HP_Start; i < Pokemod::ST_End_Battle; ++i)
                {
                    if ((Pokemod::ST_SpecialDefense == i) && !static_cast<const Pokemod*>(original()->pokemod())->rules()->specialSplit())
                        continue;
                    varValue1->addItem(Pokemod::StatGSCStr[i], varValue1->count());
                }
                break;
            case AbilityEffect::E_Status:
                varValue1->addItems(Pokemod::StatusStr);
                for (int i = 0; i < Pokemod::STS_End; ++i)
                    varValue1->setItemData(i, i);
                break;
            case AbilityEffect::E_Ability:
                for (int i = 0; i < static_cast<const Pokemod*>(original()->pokemod())->abilityCount(); ++i)
                {
                    const Ability* ability = static_cast<const Pokemod*>(original()->pokemod())->ability(i);
                    varValue1->addItem(ability->name(), ability->id());
                }
                break;
            case AbilityEffect::E_AccuracyPowerTrade:
                varValue1->addItems(AbilityEffect::PowerAccuracyStr);
                for (int i = 0; i < AbilityEffect::PA_End; ++i)
                    varValue1->setItemData(i, i);
                break;
            case AbilityEffect::E_ItemEffect:
                varValue1->addItems(AbilityEffect::ItemStr);
                for (int i = 0; i < AbilityEffect::IT_End; ++i)
                    varValue1->setItemData(i, i);
                break;
            case AbilityEffect::E_Type:
                for (int i = 0; i < static_cast<const Pokemod*>(original()->pokemod())->typeCount(); ++i)
                {
                    const Type* type = static_cast<const Pokemod*>(original()->pokemod())->type(i);
                    varValue1->addItem(type->name(), type->id());
                }
                break;
            case AbilityEffect::E_Weather:
                varValue1->addItems(Pokemod::WeatherStr);
                for (int i = 0; i < Pokemod::W_End_All; ++i)
                    varValue1->setItemData(i, i);
                break;
            default:
                varValue1->setEnabled(false);
                break;
        }
        switch (m_lastEffect)
        {
            case AbilityEffect::E_Stats:
                varValue2->addItems(Pokemod::BattleMemberStr);
                for (int i = 0; i < Pokemod::BM_End; ++i)
                    varValue2->setItemData(i, i);
                break;
            case AbilityEffect::E_Status:
            case AbilityEffect::E_Weather:
                varValue2->addItems(AbilityEffect::CauseStr);
                for (int i = 0; i < AbilityEffect::C_End; ++i)
                    varValue2->setItemData(i, i);
                break;
            case AbilityEffect::E_Ability:
                varValue2->addItems(AbilityEffect::TriggerStr);
                for (int i = 0; i < AbilityEffect::T_End; ++i)
                    varValue2->setItemData(i, i);
                break;
            case AbilityEffect::E_Type:
                varValue2->addItems(AbilityEffect::BoostStr);
                for (int i = 0; i < AbilityEffect::B_End; ++i)
                    varValue2->setItemData(i, i);
                break;
            default:
                varValue2->setEnabled(false);
                break;
        }
        switch (m_lastEffect)
        {
            case AbilityEffect::E_DamageToHP:
            case AbilityEffect::E_PreventDamage:
            case AbilityEffect::E_AutoHeal:
            case AbilityEffect::E_DealDamage:
            case AbilityEffect::E_Wilds:
            case AbilityEffect::E_AccuracyPowerTrade:
            case AbilityEffect::E_Type:
            case AbilityEffect::E_FastHatch:
                varValue3->setRange(0, 100);
                break;
            case AbilityEffect::E_Stats:
                varValue3->setRange(-12, 12);
                break;
            default:
                varValue3->setEnabled(false);
                break;
        }
    }
    varValue1->setCurrentIndex(varValue1->findData(static_cast<AbilityEffect*>(modified())->value1()));
    varValue2->setCurrentIndex(varValue2->findData(static_cast<AbilityEffect*>(modified())->value2()));
    varValue3->setValue(static_cast<AbilityEffect*>(modified())->value3());
    varTrigger->setCurrentIndex(static_cast<AbilityEffect*>(modified())->trigger());
    m_lastTrigger = static_cast<AbilityEffect*>(modified())->trigger();
    if (resetTrigger)
    {
        varTriggerValue1->clear();
        varTriggerValue1->setEnabled(true);
        varTriggerValue2->setEnabled(true);
        switch (m_lastTrigger)
        {
            case AbilityEffect::T_Weather:
                varTriggerValue1->addItems(Pokemod::WeatherStr);
                for (int i = 0; i < Pokemod::W_End_All; ++i)
                    varTriggerValue1->setItemData(i, i);
                break;
            case AbilityEffect::T_Type:
                for (int i = 0; i < static_cast<const Pokemod*>(original()->pokemod())->typeCount(); ++i)
                {
                    const Type* type = static_cast<const Pokemod*>(original()->pokemod())->type(i);
                    varTriggerValue1->addItem(type->name(), type->id());
                }
                break;
            case AbilityEffect::T_HPBoundary:
                varTriggerValue1->addItems(AbilityEffect::SideStr);
                for (int i = 0; i < AbilityEffect::S_End; ++i)
                    varTriggerValue1->setItemData(i, i);
                break;
            case AbilityEffect::T_StatChange:
                for (int i = Pokemod::ST_No_HP_Start; i < Pokemod::ST_End_Battle; ++i)
                {
                    if ((Pokemod::ST_SpecialDefense == i) && !static_cast<const Pokemod*>(original()->pokemod())->rules()->specialSplit())
                        continue;
                    varTriggerValue1->addItem(Pokemod::StatGSCStr[i], varValue1->count());
                }
                break;
            case AbilityEffect::T_Status:
                varTriggerValue1->addItems(Pokemod::StatusStr);
                for (int i = 0; i < Pokemod::STS_End; ++i)
                    varTriggerValue1->setItemData(i, i);
                break;
            default:
                varTriggerValue1->setEnabled(false);
                break;
        }
        varTriggerValue2->setEnabled(m_lastEffect == AbilityEffect::T_HPBoundary);
    }
    varTriggerValue1->setCurrentIndex(varTriggerValue1->findData(static_cast<AbilityEffect*>(modified())->triggerValue1()));
    varTriggerValue2->setValue(static_cast<AbilityEffect*>(modified())->triggerValue2());
}

void AbilityEffectUI::apply()
{
    *static_cast<AbilityEffect*>(original()) = *static_cast<AbilityEffect*>(modified());
    emit(changed(false));
}

void AbilityEffectUI::discard()
{
    *static_cast<AbilityEffect*>(modified()) = *static_cast<AbilityEffect*>(original());
    setGui();
    emit(changed(false));
}

void AbilityEffectUI::on_varChance_valueChanged(const Fraction& chance)
{
    static_cast<AbilityEffect*>(modified())->setChance(chance);
}

void AbilityEffectUI::on_varEffect_currentIndexChanged(const int effect)
{
    static_cast<AbilityEffect*>(modified())->setEffect(effect);
}

void AbilityEffectUI::on_varValue1_currentIndexChanged(const int value1)
{
    static_cast<AbilityEffect*>(modified())->setValue1(varValue1->itemData(value1).toInt());
}

void AbilityEffectUI::on_varValue2_currentIndexChanged(const int value2)
{
    static_cast<AbilityEffect*>(modified())->setValue2(varValue2->itemData(value2).toInt());
}

void AbilityEffectUI::on_varValue3_valueChanged(const int value3)
{
    static_cast<AbilityEffect*>(modified())->setValue3(value3);
}

void AbilityEffectUI::on_varTrigger_currentIndexChanged(const int trigger)
{
    static_cast<AbilityEffect*>(modified())->setTrigger(trigger);
}

void AbilityEffectUI::on_varTriggerValue1_currentIndexChanged(const int triggerValue1)
{
    static_cast<AbilityEffect*>(modified())->setTriggerValue1(varTriggerValue1->itemData(triggerValue1).toInt());
}

void AbilityEffectUI::on_varTriggerValue2_valueChanged(const Fraction& triggerValue2)
{
    static_cast<AbilityEffect*>(modified())->setTriggerValue2(triggerValue2);
}