/*
 * Copyright 2008-2009 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"

// Sigmod includes
#include <sigmod/Rules.h>

// KDE includes
#include <KIntNumInput>

// Qt includes
#include <QtCore/QFile>
#include <QtGui/QCheckBox>
#include <QtGui/QVBoxLayout>
#include <QtUiTools/QUiLoader>

using namespace Sigmod;
using namespace Sigmodr::Widgets;

RulesUI::RulesUI(Rules* rules, QWidget* parent) :
        ObjectUI(parent)
{
    setObjects(rules, new Rules(*rules));
}

void RulesUI::initGui()
{
    QFile file(":/gui/rules.ui");
    file.open(QFile::ReadOnly);
    QWidget *formWidget = QUiLoader().load(&file, this);
    file.close();
    ui_genders = formWidget->findChild<QCheckBox*>("varGenders");
    ui_breeding = formWidget->findChild<QCheckBox*>("varBreeding");
    ui_criticalDomains = formWidget->findChild<QCheckBox*>("varCriticalDomains");
    ui_splitSpecial = formWidget->findChild<QCheckBox*>("varSplitSpecial");
    ui_splitSpecialDV = formWidget->findChild<QCheckBox*>("varSplitSpecialDV");
    ui_effortValues = formWidget->findChild<QCheckBox*>("varEffortValues");
    ui_maxEV = formWidget->findChild<KIntNumInput*>("varMaxEV");
    ui_maxEVPerStat = formWidget->findChild<KIntNumInput*>("varMaxEVPerStat");
    ui_boxes = formWidget->findChild<KIntNumInput*>("varBoxes");
    ui_boxSize = formWidget->findChild<KIntNumInput*>("varBoxSize");
    ui_maxParty = formWidget->findChild<KIntNumInput*>("varMaxParty");
    ui_maxFight = formWidget->findChild<KIntNumInput*>("varMaxFight");
    ui_maxPlayers = formWidget->findChild<KIntNumInput*>("varMaxPlayers");
    ui_maxMoves = formWidget->findChild<KIntNumInput*>("varMaxMoves");
    ui_maxLevel = formWidget->findChild<KIntNumInput*>("varMaxLevel");
    ui_maxHeldItems = formWidget->findChild<KIntNumInput*>("varMaxHeldItems");
    ui_maxNatures = formWidget->findChild<KIntNumInput*>("varMaxNatures");
    ui_maxAbilities = formWidget->findChild<KIntNumInput*>("varMaxAbilities");
    ui_maxStages = formWidget->findChild<KIntNumInput*>("varMaxStages");
    ui_maxMoney = formWidget->findChild<KIntNumInput*>("varMaxMoney");
    ui_maxTotalWeight = formWidget->findChild<KIntNumInput*>("varMaxTotalWeight");
    connect(ui_genders, SIGNAL(toggled(bool)), this, SLOT(gendersChanged(bool)));
    connect(ui_breeding, SIGNAL(toggled(bool)), this, SLOT(breedingChanged(bool)));
    connect(ui_criticalDomains, SIGNAL(toggled(bool)), this, SLOT(criticalDomainsChanged(bool)));
    connect(ui_splitSpecial, SIGNAL(toggled(bool)), this, SLOT(splitSpecialChanged(bool)));
    connect(ui_splitSpecialDV, SIGNAL(toggled(bool)), this, SLOT(splitSpecialDVChanged(bool)));
    connect(ui_effortValues, SIGNAL(toggled(bool)), this, SLOT(effortValuesChanged(bool)));
    connect(ui_maxEV, SIGNAL(valueChanged(int)), this, SLOT(maxEVChanged(int)));
    connect(ui_maxEVPerStat, SIGNAL(valueChanged(int)), this, SLOT(maxEVPerStatChanged(int)));
    connect(ui_boxes, SIGNAL(valueChanged(int)), this, SLOT(boxesChanged(int)));
    connect(ui_boxSize, SIGNAL(valueChanged(int)), this, SLOT(boxSizeChanged(int)));
    connect(ui_maxParty, SIGNAL(valueChanged(int)), this, SLOT(maxPartyChanged(int)));
    connect(ui_maxFight, SIGNAL(valueChanged(int)), this, SLOT(maxFightChanged(int)));
    connect(ui_maxPlayers, SIGNAL(valueChanged(int)), this, SLOT(maxPlayersChanged(int)));
    connect(ui_maxMoves, SIGNAL(valueChanged(int)), this, SLOT(maxMovesChanged(int)));
    connect(ui_maxLevel, SIGNAL(valueChanged(int)), this, SLOT(maxLevelChanged(int)));
    connect(ui_maxHeldItems, SIGNAL(valueChanged(int)), this, SLOT(maxHeldItemsChanged(int)));
    connect(ui_maxNatures, SIGNAL(valueChanged(int)), this, SLOT(maxNaturesChanged(int)));
    connect(ui_maxAbilities, SIGNAL(valueChanged(int)), this, SLOT(maxAbilitiesChanged(int)));
    connect(ui_maxStages, SIGNAL(valueChanged(int)), this, SLOT(maxStagesChanged(int)));
    connect(ui_maxMoney, SIGNAL(valueChanged(int)), this, SLOT(maxMoneyChanged(int)));
    connect(ui_maxTotalWeight, SIGNAL(valueChanged(int)), this, SLOT(maxTotalWeightChanged(int)));
    QVBoxLayout* layout = new QVBoxLayout;
    layout->addWidget(formWidget);
    setLayout(layout);
}

void RulesUI::setGui()
{
    ui_genders->setCheckState(qobject_cast<Rules*>(modified())->genderAllowed() ? Qt::Checked : Qt::Unchecked);
    ui_breeding->setCheckState(qobject_cast<Rules*>(modified())->breedingAllowed() ? Qt::Checked : Qt::Unchecked);
    ui_breeding->setEnabled(qobject_cast<Rules*>(modified())->genderAllowed());
    ui_criticalDomains->setCheckState(qobject_cast<Rules*>(modified())->criticalDomains() ? Qt::Checked : Qt::Unchecked);
    ui_splitSpecial->setCheckState(qobject_cast<Rules*>(modified())->specialSplit() ? Qt::Checked : Qt::Unchecked);
    ui_splitSpecialDV->setEnabled(qobject_cast<Rules*>(modified())->specialSplit());
    ui_splitSpecialDV->setCheckState(qobject_cast<Rules*>(modified())->specialDVSplit() ? Qt::Checked : Qt::Unchecked);
    ui_effortValues->setCheckState(qobject_cast<Rules*>(modified())->effortValuesAllowed() ? Qt::Checked : Qt::Unchecked);
    ui_maxEV->setEnabled(qobject_cast<Rules*>(modified())->effortValuesAllowed());
    ui_maxEV->setValue(qobject_cast<Rules*>(modified())->maxTotalEV());
    ui_maxEVPerStat->setEnabled((0 < qobject_cast<Rules*>(modified())->maxTotalEV()) && qobject_cast<Rules*>(modified())->effortValuesAllowed());
    ui_maxEVPerStat->setMaximum(qobject_cast<Rules*>(modified())->maxTotalEV());
    ui_maxEVPerStat->setValue(qobject_cast<Rules*>(modified())->maxEVPerStat());
    ui_boxes->setValue(qobject_cast<Rules*>(modified())->numBoxes());
    ui_boxSize->setEnabled(0 < qobject_cast<Rules*>(modified())->numBoxes());
    ui_boxSize->setValue(qobject_cast<Rules*>(modified())->boxSize());
    ui_maxParty->setValue(qobject_cast<Rules*>(modified())->maxParty());
    ui_maxFight->setMaximum(qobject_cast<Rules*>(modified())->maxParty());
    ui_maxFight->setValue(qobject_cast<Rules*>(modified())->maxFight());
    ui_maxPlayers->setValue(qobject_cast<Rules*>(modified())->maxPlayers());
    ui_maxMoves->setValue(qobject_cast<Rules*>(modified())->maxMoves());
    ui_maxLevel->setValue(qobject_cast<Rules*>(modified())->maxLevel());
    ui_maxHeldItems->setValue(qobject_cast<Rules*>(modified())->maxHeldItems());
    ui_maxNatures->setValue(qobject_cast<Rules*>(modified())->maxNatures());
    ui_maxAbilities->setValue(qobject_cast<Rules*>(modified())->maxAbilities());
    ui_maxStages->setValue(qobject_cast<Rules*>(modified())->maxStages());
    ui_maxMoney->setValue(qobject_cast<Rules*>(modified())->maxMoney());
    ui_maxTotalWeight->setValue(qobject_cast<Rules*>(modified())->maxTotalWeight());
}

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

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

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

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

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

void RulesUI::splitSpecialChanged(const bool splitSpecial)
{
    qobject_cast<Rules*>(modified())->setSpecialSplit(splitSpecial);
    if (!splitSpecial)
        qobject_cast<Rules*>(modified())->setSpecialDVSplit(false);
}

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

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

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

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

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

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

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

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

void RulesUI::maxPlayersChanged(const int maxPlayers)
{
    qobject_cast<Rules*>(modified())->setMaxPlayers(maxPlayers);
}

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

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

void RulesUI::maxHeldItemsChanged(const int maxHeldItems)
{
    qobject_cast<Rules*>(modified())->setMaxHeldItems(maxHeldItems);
}

void RulesUI::maxNaturesChanged(const int maxNatures)
{
    qobject_cast<Rules*>(modified())->setMaxNatures(maxNatures);
}

void RulesUI::maxAbilitiesChanged(const int maxAbilities)
{
    qobject_cast<Rules*>(modified())->setMaxAbilities(maxAbilities);
}

void RulesUI::maxStagesChanged(const int maxStages)
{
    qobject_cast<Rules*>(modified())->setMaxStages(maxStages);
}

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

void RulesUI::maxTotalWeightChanged(const int maxTotalWeight)
{
    qobject_cast<Rules*>(modified())->setMaxTotalWeight(maxTotalWeight);
}