/*
 * 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 "RulesUI.h"

// Pokemod includes
#include "../pokemod/Rules.h"

RulesUI::RulesUI(Rules* rules, QWidget* parent) :
        ObjectUI(parent)
{
    setupUi(this);
    QMetaObject::connectSlotsByName(this);
    setObjects(rules, new Rules(*rules));
    init();
}

RulesUI::~RulesUI()
{
}

void RulesUI::initGui()
{
    varMaxDV->addItems(Rules::DVStr);
}

void RulesUI::setGui()
{
    boxGenders->setChecked(static_cast<Rules*>(modified())->genderAllowed() ? Qt::Checked : Qt::Unchecked);
    varBreeding->setCheckState(static_cast<Rules*>(modified())->breedingAllowed() ? Qt::Checked : Qt::Unchecked);
    varHeldItems->setValue(static_cast<Rules*>(modified())->holdItems());
    boxCriticalDomains->setChecked(static_cast<Rules*>(modified())->criticalDomains() ? Qt::Checked : Qt::Unchecked);
    boxAllowAbilities->setChecked(static_cast<Rules*>(modified())->abilityAllowed() ? Qt::Checked : Qt::Unchecked);
    boxAllowNatures->setChecked(static_cast<Rules*>(modified())->natureAllowed() ? Qt::Checked : Qt::Unchecked);
    varBoxes->setValue(static_cast<Rules*>(modified())->numBoxes());
    varBoxSize->setEnabled(0 < static_cast<Rules*>(modified())->numBoxes());
    varBoxSize->setValue(static_cast<Rules*>(modified())->boxSize());
    varMaxParty->setValue(static_cast<Rules*>(modified())->maxParty());
    varMaxFight->setMaximum(static_cast<Rules*>(modified())->maxParty());
    varMaxFight->setValue(static_cast<Rules*>(modified())->maxFight());
    varMaxMoves->setValue(static_cast<Rules*>(modified())->maxMoves());
    varMaxLevel->setValue(static_cast<Rules*>(modified())->maxLevel());
    varMaxMoney->setValue(static_cast<Rules*>(modified())->maxMoney());
    boxHardCash->setChecked(static_cast<Rules*>(modified())->hardCash() ? Qt::Checked : Qt::Unchecked);
    boxSplitSpecial->setChecked(static_cast<Rules*>(modified())->specialSplit() ? Qt::Checked : Qt::Unchecked);
    varSplitSpecialDV->setCheckState(static_cast<Rules*>(modified())->specialDVSplit() ? Qt::Checked : Qt::Unchecked);
    varMaxDV->setCurrentIndex(static_cast<Rules*>(modified())->maxDVValue());
    boxHappiness->setChecked(static_cast<Rules*>(modified())->happiness() ? Qt::Checked : Qt::Unchecked);
    varFaintLoss->setValue(static_cast<Rules*>(modified())->happyFaintLoss());
    varLevelGain->setValue(static_cast<Rules*>(modified())->happyLevelGain());
    varNumSteps->setValue(static_cast<Rules*>(modified())->happySteps());
    boxEffortValues->setChecked(static_cast<Rules*>(modified())->effortValuesAllowed() ? Qt::Checked : Qt::Unchecked);
    varMaxEV->setValue(static_cast<Rules*>(modified())->maxTotalEV());
    varMaxEVPerStat->setEnabled(0 < static_cast<Rules*>(modified())->maxTotalEV());
    varMaxEVPerStat->setMaximum(static_cast<Rules*>(modified())->maxTotalEV());
    varMaxEVPerStat->setValue(static_cast<Rules*>(modified())->maxEVPerStat());
    varPokerus->setValue(static_cast<Rules*>(modified())->pokerusChance());
}

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

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

void RulesUI::on_boxGenders_toggled(const bool genders)
{
    static_cast<Rules*>(modified())->setGenderAllowed(genders);
}

void RulesUI::on_varBreeding_toggled(const bool breeding)
{
    static_cast<Rules*>(modified())->setBreedingAllowed(breeding);
}

void RulesUI::on_varHeldItems_valueChanged(const int heldItems)
{
    static_cast<Rules*>(modified())->setHoldItems(heldItems);
}

void RulesUI::on_boxCriticalDomains_toggled(const bool criticalDomains)
{
    static_cast<Rules*>(modified())->setCriticalDomains(criticalDomains);
}

void RulesUI::on_boxAllowAbilities_toggled(const bool allowAbilities)
{
    static_cast<Rules*>(modified())->setAbilityAllowed(allowAbilities);
}

void RulesUI::on_boxAllowNatures_toggled(const bool allowNatures)
{
    static_cast<Rules*>(modified())->setNatureAllowed(allowNatures);
}

void RulesUI::on_varBoxes_valueChanged(const int boxes)
{
    static_cast<Rules*>(modified())->setNumBoxes(boxes);
}

void RulesUI::on_varBoxSize_valueChanged(const int boxSize)
{
    static_cast<Rules*>(modified())->setBoxSize(boxSize);
}

void RulesUI::on_varMaxParty_valueChanged(const int maxParty)
{
    static_cast<Rules*>(modified())->setMaxParty(maxParty);
}

void RulesUI::on_varMaxFight_valueChanged(const int maxFight)
{
    static_cast<Rules*>(modified())->setMaxFight(maxFight);
}

void RulesUI::on_varMaxMoves_valueChanged(const int maxMoves)
{
    static_cast<Rules*>(modified())->setMaxMoves(maxMoves);
}

void RulesUI::on_varMaxLevel_valueChanged(const int maxLevel)
{
    static_cast<Rules*>(modified())->setMaxLevel(maxLevel);
}

void RulesUI::on_varMaxMoney_valueChanged(const int maxMoney)
{
    static_cast<Rules*>(modified())->setMaxMoney(maxMoney);
}

void RulesUI::on_boxHardCash_toggled(const bool hardCash)
{
    static_cast<Rules*>(modified())->setHardCash(hardCash);
}

void RulesUI::on_boxSplitSpecial_toggled(const bool splitSpecial)
{
    static_cast<Rules*>(modified())->setSpecialSplit(splitSpecial);
}

void RulesUI::on_varSplitSpecialDV_toggled(const bool splitSpecialDV)
{
    static_cast<Rules*>(modified())->setSpecialDVSplit(splitSpecialDV);
}

void RulesUI::on_varMaxDV_currentIndexChanged(const int maxDV)
{
    static_cast<Rules*>(modified())->setMaxDVValue(maxDV);
}

void RulesUI::on_boxHappiness_toggled(const bool happiness)
{
    static_cast<Rules*>(modified())->setHappiness(happiness);
}

void RulesUI::on_varFaintLoss_valueChanged(const int faintLoss)
{
    static_cast<Rules*>(modified())->setHappyFaintLoss(faintLoss);
}

void RulesUI::on_varLevelGain_valueChanged(const int levelGain)
{
    static_cast<Rules*>(modified())->setHappyLevelGain(levelGain);
}

void RulesUI::on_varNumSteps_valueChanged(const int numSteps)
{
    static_cast<Rules*>(modified())->setHappySteps(numSteps);
}

void RulesUI::on_boxEffortValues_toggled(const bool effortValues)
{
    static_cast<Rules*>(modified())->setEffortValuesAllowed(effortValues);
}

void RulesUI::on_varMaxEV_valueChanged(const int maxEV)
{
    static_cast<Rules*>(modified())->setMaxTotalEV(maxEV);
}

void RulesUI::on_varMaxEVPerStat_valueChanged(const int maxEVPerStat)
{
    static_cast<Rules*>(modified())->setMaxEVPerStat(maxEVPerStat);
}

void RulesUI::on_varPokerus_valueChanged(const Fraction& pokerusChance)
{
    static_cast<Rules*>(modified())->setPokerusChance(pokerusChance);
}