#include "mainwindow.h"
#include "ui_mainwindow.h"

#include <QMessageBox>
#include <QFileDialog>
#include <QSettings>

MainWindow::MainWindow(QWidget *parent) :
		QMainWindow(parent),
		ui(new Ui::MainWindow)
{
	ui->setupUi(this);
	ui->pbSave->setIcon(/*QIcon::fromTheme("documment-save",*/
										 QIcon(":/icons/icons/documment-save.png"));
	ui->pbReload->setIcon(QIcon::fromTheme("edit-undo", QIcon(":/icons/icons/edit-undo.png")));
	ui->pbAlAdd->setIcon(QIcon::fromTheme("list-add", QIcon(":/icons/icons/list-add.png")));
	ui->pbAlDel->setIcon(QIcon::fromTheme("list-remove", QIcon(":/icons/icons/list-remove.png")));
	ui->pbTrigAdd->setIcon(QIcon::fromTheme("list-add", QIcon(":/icons/icons/list-add.png")));
	ui->pbTrigDel->setIcon(QIcon::fromTheme("list-remove", QIcon(":/icons/icons/list-remove.png")));
	ui->pbTwAdd->setIcon(QIcon::fromTheme("list-add", QIcon(":/icons/icons/list-add.png")));
	ui->pbTwDel->setIcon(QIcon::fromTheme("list-remove", QIcon(":/icons/icons/list-remove.png")));
	ui->pbMapAdd->setIcon(QIcon::fromTheme("list-add", QIcon(":/icons/icons/list-add.png")));
	ui->pbMapDelete->setIcon(QIcon::fromTheme("list-remove", QIcon(":/icons/icons/list-remove.png")));
	ui->pbSplAdd->setIcon(QIcon::fromTheme("list-add", QIcon(":/icons/icons/list-add.png")));
	ui->pbSlpDel->setIcon(QIcon::fromTheme("list-remove", QIcon(":/icons/icons/list-remove.png")));
	ui->pbAnimAdd->setIcon(QIcon::fromTheme("list-add", QIcon(":/icons/icons/list-add.png")));
	ui->pbAnimDel->setIcon(QIcon::fromTheme("list-remove", QIcon(":/icons/icons/list-remove.png")));
	ui->pbImgAdd->setIcon(QIcon::fromTheme("list-add", QIcon(":/icons/icons/list-add.png")));
	ui->pbImgDel->setIcon(QIcon::fromTheme("list-remove", QIcon(":/icons/icons/list-remove.png")));
	ui->pbTwSplashEdit->setIcon(QIcon::fromTheme("edit", QIcon(":/icons/icons/edit.png")));
	ui->pbMapEdit->setIcon(QIcon::fromTheme("edit", QIcon(":/icons/icons/edit.png")));
	adloader = new Loader(this);
	adloader->load("data2.xml");

	animModel = new AnimationModel(adloader->animations.values());
	ui->lvAnimations->setModel((QAbstractItemModel * )animModel);
	connect(ui->lvAnimations->selectionModel(),SIGNAL(currentChanged(QModelIndex,QModelIndex)),this,SLOT(lvAnimations_select(QModelIndex, QModelIndex)));
	ui->lvAnimations->selectionModel()->setCurrentIndex(ui->lvAnimations->model()->index(0,0),QItemSelectionModel::ClearAndSelect);

	mapScene = new QGraphicsScene();
	ui->gvMap->setScene(mapScene);
	ui->gvMap->scale(10,10);

	mapModel = new MapModel(adloader->maps.values());
	ui->lvMaps->setModel((QAbstractItemModel * )mapModel);
	connect(ui->lvMaps->selectionModel(),SIGNAL(currentChanged(QModelIndex, QModelIndex)),this,SLOT(lvMaps_select(QModelIndex, QModelIndex)));
	ui->lvMaps->selectionModel()->setCurrentIndex(ui->lvMaps->model()->index(0,0),QItemSelectionModel::ClearAndSelect);

	alModel = new AlienModel(adloader->aliens.values());
	ui->lvAliens->setModel((QAbstractItemModel * )alModel);
	ui->cbAlImage->setModel((QAbstractItemModel * )animModel);
	connect(ui->lvAliens->selectionModel(),SIGNAL(currentChanged(QModelIndex, QModelIndex)),this,SLOT(lvAliens_select(QModelIndex, QModelIndex)));
	ui->lvAliens->selectionModel()->setCurrentIndex(ui->lvAliens->model()->index(0,0),QItemSelectionModel::ClearAndSelect);

	splModel = new SplashModel(adloader->splashes.values());
	ui->lvSplashes->setModel((QAbstractItemModel * )splModel);
	ui->cbSplImage->setModel((QAbstractItemModel * )animModel);
	connect(ui->lvSplashes->selectionModel(),SIGNAL(currentChanged(QModelIndex, QModelIndex)),this,SLOT(lvSplashes_select(QModelIndex, QModelIndex)));
	ui->lvSplashes->selectionModel()->setCurrentIndex(ui->lvSplashes->model()->index(0,0),QItemSelectionModel::ClearAndSelect);

	twModel = new TowerModel(adloader->towers.values());
	ui->lvTowers->setModel((QAbstractItemModel * )twModel);
	ui->cbTwSplash->setModel((QAbstractItemModel * )splModel);
	ui->cbTwImage->setModel((QAbstractItemModel * )animModel);
	connect(ui->lvTowers->selectionModel(),SIGNAL(currentChanged(QModelIndex, QModelIndex)),this,SLOT(lvTowers_select(QModelIndex, QModelIndex)));
	ui->lvTowers->selectionModel()->setCurrentIndex(ui->lvTowers->model()->index(0,0),QItemSelectionModel::ClearAndSelect);

	trigModel = new TriggerModel(adloader->triggers.values());
	ui->lvTriggers->setModel((QAbstractItemModel * )trigModel);
	connect(ui->lvTriggers->selectionModel(),SIGNAL(currentChanged(QModelIndex, QModelIndex)),this,SLOT(lvTriggers_select(QModelIndex,QModelIndex)));
	ui->lvTriggers->selectionModel()->setCurrentIndex(ui->lvTriggers->model()->index(0,0),QItemSelectionModel::ClearAndSelect);
	ui->cbTrigChildAim->addItem(tr("no aim"),QVariant(srcTriggerType::noAim));
	ui->cbTrigChildAim->addItem(tr("random side"),QVariant(srcTriggerType::allSide));
	ui->cbTrigChildAim->addItem(tr("parent aim"),QVariant(srcTriggerType::parentAim));
	ui->cbTrigChildAim->addItem(tr("nearlest alien"),QVariant(srcTriggerType::nearlestAlien));
	ui->cbTrigType->addItem(tr("on destination"),QVariant(srcTriggerType::onDestination));
	ui->cbTrigType->addItem(tr("on alien in radius"),QVariant(srcTriggerType::onAlienInRadius));
	ui->cbTrigType->addItem(tr("on timer"),QVariant(srcTriggerType::onTimer));
	isSaved = true;
	QSettings sett("Alien_Defender","aliendefender");
	this->restoreGeometry(sett.value("session/geometry").toByteArray());
	this->restoreState(sett.value("session/mainwindow").toByteArray());
	ui->splitter->restoreState(sett.value("session/split1").toByteArray());
	ui->splitter_2->restoreState(sett.value("session/split2").toByteArray());
	ui->splitter_3->restoreState(sett.value("session/split3").toByteArray());
	ui->splitter_4->restoreState(sett.value("session/split4").toByteArray());
	ui->splitter_5->restoreState(sett.value("session/split5").toByteArray());
	ui->splitter_6->restoreState(sett.value("session/split6").toByteArray());
	ui->tabWidget->setCurrentIndex(sett.value("session/tab").toInt());
}


MainWindow::~MainWindow()
{
	delete ui;
}


void MainWindow::changeEvent(QEvent *e)
{
	QMainWindow::changeEvent(e);
	switch (e->type()) {
	case QEvent::LanguageChange:
		ui->retranslateUi(this);
		break;
	default:
		break;
	}
}


void MainWindow::on_cbAlArmor_toggled(bool checked)
{
	int id = adloader->aliens.values().at(ui->lvAliens->currentIndex().row()).id;
	ui->sbAlArmor->setEnabled(checked);
	if (checked) adloader->aliens[id].armor = ui->sbAlArmor->value();
	else adloader->aliens[id].armor = 0;
	isSaved = false;
}


void MainWindow::on_cbAlRegeneration_toggled(bool checked)
{
	int id = adloader->aliens.values().at(ui->lvAliens->currentIndex().row()).id;
	ui->sbAlregeneration->setEnabled(checked);
	if (checked) adloader->aliens[id].regeneration = ui->sbAlregeneration->value();
	else adloader->aliens[id].regeneration = 0;
	isSaved = false;
}


void MainWindow::lvAnimations_select(QModelIndex index, QModelIndex)
{
	if (index.isValid())
	{
		ui->lwImages->clear();
		refresh_lwImages(adloader->animations.values().at(index.row()).pathes);
	}
}


void MainWindow::lvAliens_select(QModelIndex index, QModelIndex)
{
	if (index.isValid())
	{
		tbAlien al = adloader->aliens.values().at(index.row());
		ui->leAlName->setText(al.name);
		ui->sbAlHealth->setValue(al.health);
		ui->sbAlArmor->setValue(al.armor);
		if (al.armor > 0) ui->cbAlArmor->setChecked(true);
		else ui->cbAlArmor->setChecked(false);
		ui->sbAlSpeed->setValue(al.speed);
		ui->sbAlPrise->setValue(al.prise);
		ui->sbAlregeneration->setValue(al.regeneration);
		if (al.regeneration > 0) ui->cbAlRegeneration->setChecked(true);
		else ui->cbAlRegeneration->setChecked(false);
		ui->sbAlScore->setValue(al.score);
		ui->cbAlIsFly->setChecked(al.isFlying);
	}
}


void MainWindow::lvMaps_select(QModelIndex index, QModelIndex)
{
	if (index.isValid())
	{
		tbMap map = adloader->maps.values().at(index.row());
		ui->leMapName->setText(map.name);
		ui->sbMapHei->setValue(map.size.height());
		ui->sbMapWid->setValue(map.size.width());
		ui->sbMapPlayers->setValue(map.maxPlayers);
		Map m(map.data,map.size,map.name,map.maxPlayers,map.imgType);
		QPixmap pix(map.size);
		QPainter p(&pix);
		p.fillRect(m.rect(),Qt::white);
		for (int i=0; i<m.cells().size(); i++) {
			for (int j=0; j<m.cells().at(i).size(); j++) {
				QPen pen;
				pen.setColor(Qt::white);
				int cel = m.cells().at(i).at(j);
				if (cel == Map::Wall)
					pen.setColor(Qt::black);
				if (cel >= Map::Free || (cel <= Map::PlayerTower && cel !=Map::Wall))
					pen.setColor(QColor(qAbs(cel+2)*345%255,(qAbs(cel+2)*721)%255,(qAbs(cel+2)*75)%255,200));
				p.setPen(pen);
				p.drawPoint(i,j);
			}
		}
		p.end();
		mapScene->clear();
		mapScene->addPixmap(pix);
		ui->gvMap->centerOn(0,0);
		//ui->gvMap->resetCachedContent();
		//ui->pbMapEdit->setIcon(QIcon(pix));
	}
}


void MainWindow::lvTowers_select(QModelIndex index, QModelIndex)
{
	if (index.isValid())
	{
		tbTower tw = adloader->towers.values().at(index.row());
		ui->sbTwBuildTime->setValue(tw.buildTime);
		ui->sbTwCost->setValue(tw.cost);
		ui->sbTwExpByDam->setValue(tw.expByDamage);
		if (tw.expByDamage > 0)
			ui->cbTwExpByDam->setChecked(true);
		else
			ui->cbTwExpByDam->setChecked(false);
		ui->sbTwExpByKill->setValue(tw.expByKill);
		if (tw.expByKill > 0)
			ui->cbTwExpByKill->setChecked(true);
		else
			ui->cbTwExpByKill->setChecked(false);
		ui->sbTwExpByShot->setValue(tw.expByShot);
		if (tw.expByShot > 0)
			ui->cbTwExpByShot->setChecked(true);
		else
			ui->cbTwExpByShot->setChecked(false);
		ui->leTwName->setText(tw.name);
		ui->sbTwRadius->setValue(tw.radius);
		ui->sbTwReload->setValue(tw.reload);
		ui->cbTwSplash->setCurrentIndex(adloader->splashes.keys().indexOf(tw.splashId));
	}
}


void MainWindow::lvSplashes_select(QModelIndex index, QModelIndex)
{
	if (index.isValid())
	{
		tbSplash spl = adloader->splashes.values().at(index.row());
		ui->sbSplLifeTime->setValue(spl.lifetime);
		ui->sbSplSpeed->setValue(spl.speed);
		ui->cbSplAutoControl->setChecked(spl.autoControl);
		ui->leSplName->setText(spl.name);
	}
}


void MainWindow::lvTriggers_select(QModelIndex index, QModelIndex)
{
	if (index.isValid())
	{
		tbTrigger trig = adloader->triggers.values().at(index.row());
		ui->sbTrigCount->setValue(trig.count);
		if (trig.count > 0)
			ui->cbTrigCount->setChecked(true);
		else
			ui->cbTrigCount->setChecked(false);
		ui->sbTrigDamage->setValue(trig.damage);
		if (trig.damage > 0)
			ui->cbTrigDamage->setChecked(true);
		else
			ui->cbTrigDamage->setChecked(false);
		ui->sbTrigDamRadius->setValue(trig.radius);
		if (trig.radius > 0)
			ui->cbTrigDamRad->setChecked(true);
		else
			ui->cbTrigDamRad->setChecked(false);
		ui->sbTrigChance->setValue(trig.chance);
		if (trig.chance == 100)
			ui->cbTrigChance->setChecked(false);
		else
			ui->cbTrigChance->setChecked(true);
		ui->sbTrigRandomRadius->setValue(trig.randomPosRadius);
		if (trig.randomPosRadius > 0)
			ui->cbTrigRandRadius->setChecked(true);
		else
			ui->cbTrigRandRadius->setChecked(false);

		ui->sbTrigTimer->setValue(trig.timer);
		switch (trig.type)
		{
		case srcTriggerType::onDestination :
			ui->cbTrigType->setCurrentIndex(0);
			break;
		case srcTriggerType::onAlienInRadius :
			ui->cbTrigType->setCurrentIndex(1);
			break;
		case srcTriggerType::onTimer :
			ui->cbTrigType->setCurrentIndex(2);
			break;
		}
		if (trig.type != srcTriggerType::onTimer)
		{
			ui->lbTrigTimer->setVisible(false);
			ui->sbTrigTimer->setVisible(false);
		} else {
			ui->lbTrigTimer->setVisible(true);
			ui->sbTrigTimer->setVisible(true);
		}
		switch (trig.childAim)
		{
		case srcTriggerType::noAim :
			ui->cbTrigChildAim->setCurrentIndex(0);
			break;
		case srcTriggerType::allSide :
			ui->cbTrigChildAim->setCurrentIndex(1);
			break;
		case srcTriggerType::parentAim :
			ui->cbTrigChildAim->setCurrentIndex(2);
			break;
		case srcTriggerType::nearlestAlien :
			ui->cbTrigChildAim->setCurrentIndex(3);
			break;
		}
		ui->leTrigName->setText(trig.name);
	}
}


void MainWindow::closeEvent(QCloseEvent *event)
{
	QSettings sett("Alien_Defender","aliendefender");
	sett.setValue("session/geometry",this->saveGeometry());
	sett.setValue("session/mainwindow",this->saveState());
	sett.setValue("session/split1",ui->splitter->saveState());
	sett.setValue("session/split2",ui->splitter_2->saveState());
	sett.setValue("session/split3",ui->splitter_3->saveState());
	sett.setValue("session/split4",ui->splitter_4->saveState());
	sett.setValue("session/split5",ui->splitter_5->saveState());
	sett.setValue("session/split6",ui->splitter_6->saveState());
	sett.setValue("session/tab",ui->tabWidget->currentIndex());
	if (!isSaved)
	{
		QMessageBox msgBox;
		msgBox.setText(tr("Save changes?"));
		msgBox.setStandardButtons(QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel);
		msgBox.setDefaultButton(QMessageBox::Save);
		msgBox.setEscapeButton(QMessageBox::Discard);
		int ret = msgBox.exec();
		switch (ret)
		{
		case QMessageBox::Save :
			adloader->save("data2.xml");
			adloader->load("data2.xml");
			adloader->save("data2.xml");
			event->accept();
			break;
		case QMessageBox::Cancel :
			event->ignore();
			break;
		}
	} else {
		event->accept();
	}
}

void MainWindow::on_pbSave_clicked()
{
	adloader->save("data2.xml");
	adloader->load("data2.xml");
	adloader->save("data2.xml");
	isSaved = true;
}


void MainWindow::on_pbReload_clicked()
{
	QMessageBox msgBox;
	msgBox.setText(tr("All unsaved changes will be lost"));
	msgBox.setInformativeText(tr("Are you sure?"));
	msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
	msgBox.setDefaultButton(QMessageBox::Ok);
	int ret = msgBox.exec();
	if (ret == QMessageBox::Ok)
	{
		adloader->load("data2.xml");
		alModel->refresh(adloader->aliens.values());
		twModel->refresh(adloader->towers.values());
		splModel->refresh(adloader->splashes.values());
		trigModel->refresh(adloader->triggers.values());
		animModel->refresh(adloader->animations.values());
		mapModel->refresh(adloader->maps.values());
		ui->lvAnimations->setModel((QAbstractItemModel * )animModel);
		ui->lvAnimations->reset();
		ui->lvAnimations->selectionModel()->setCurrentIndex(ui->lvAnimations->model()->index(0,0),QItemSelectionModel::ClearAndSelect);
		ui->lvMaps->setModel((QAbstractItemModel * )mapModel);
		ui->lvMaps->reset();
		ui->lvMaps->selectionModel()->setCurrentIndex(ui->lvMaps->model()->index(0,0),QItemSelectionModel::ClearAndSelect);
		ui->lvAliens->setModel(alModel);
		ui->lvAliens->reset();
		ui->lvAliens->selectionModel()->setCurrentIndex(ui->lvAliens->model()->index(0,0),QItemSelectionModel::ClearAndSelect);
		ui->lvSplashes->setModel(splModel);
		ui->lvSplashes->reset();
		ui->lvSplashes->selectionModel()->setCurrentIndex(ui->lvSplashes->model()->index(0,0),QItemSelectionModel::ClearAndSelect);
		ui->lvTowers->setModel(twModel);
		ui->cbTwSplash->setModel(splModel);
		ui->lvTowers->reset();
		ui->lvTowers->selectionModel()->setCurrentIndex(ui->lvTowers->model()->index(0,0),QItemSelectionModel::ClearAndSelect);
		ui->lvTriggers->setModel(trigModel);
		ui->lvTriggers->reset();
		ui->lvTriggers->selectionModel()->setCurrentIndex(ui->lvTriggers->model()->index(0,0),QItemSelectionModel::ClearAndSelect);
		isSaved = true;
	}
}


void MainWindow::on_sbAlHealth_valueChanged(double value)
{
	int id = adloader->aliens.values().at(ui->lvAliens->currentIndex().row()).id;
	adloader->aliens[id].health = value;
	isSaved = false;
}


void MainWindow::on_sbAlArmor_valueChanged(double value)
{
	int id = adloader->aliens.values().at(ui->lvAliens->currentIndex().row()).id;
	adloader->aliens[id].armor = value;
	isSaved = false;
}


void MainWindow::on_sbAlregeneration_valueChanged(double value)
{
	int id = adloader->aliens.values().at(ui->lvAliens->currentIndex().row()).id;
	adloader->aliens[id].regeneration = value;
	isSaved = false;
}


void MainWindow::on_sbAlSpeed_valueChanged(double value)
{
	int id = adloader->aliens.values().at(ui->lvAliens->currentIndex().row()).id;
	adloader->aliens[id].speed = value;
	isSaved = false;
}


void MainWindow::on_sbAlPrise_valueChanged(int val)
{
	int id = adloader->aliens.values().at(ui->lvAliens->currentIndex().row()).id;
	adloader->aliens[id].prise = val;
	isSaved = false;
}


void MainWindow::on_sbAlScore_valueChanged(int val)
{
	int id = adloader->aliens.values().at(ui->lvAliens->currentIndex().row()).id;
	adloader->aliens[id].score = val;
	isSaved = false;
}


void MainWindow::on_cbAlIsFly_toggled(bool checked)
{
	int id = adloader->aliens.values().at(ui->lvAliens->currentIndex().row()).id;
	adloader->aliens[id].isFlying = checked;
	isSaved = false;
}


void MainWindow::on_leAlName_editingFinished()
{
	int id = adloader->aliens.values().at(ui->lvAliens->currentIndex().row()).id;
	adloader->aliens[id].name = ui->leAlName->text();
	alModel->refresh(adloader->aliens.values());
	ui->lvAliens->setModel((QAbstractItemModel * )alModel);
	isSaved = false;
}


void MainWindow::on_pbAlAdd_clicked()
{
	int i = 1;
	while (adloader->aliens.contains(i)) i++;
	tbAlien al;
	al.id = i;
	al.name = tr("Alien");
	al.health = 1;
	al.prise = 0;
	al.score = 1;
	al.speed = 1;
	adloader->aliens.insert(al.id,al);
	int index = adloader->aliens.keys().indexOf(i);
	alModel->refresh(adloader->aliens.values());
	ui->lvAliens->setModel((QAbstractItemModel * )alModel);
	ui->lvAliens->reset();
	ui->lvAliens->selectionModel()->setCurrentIndex(ui->lvAliens->model()->index(index,0),QItemSelectionModel::ClearAndSelect);
	isSaved = false;
}


void MainWindow::on_pbAlDel_clicked()
{
	if (adloader->aliens.size() < 2) return;
	QMessageBox msgBox;
	int id = adloader->aliens.keys().at(ui->lvAliens->currentIndex().row());
	for (int i=0; i<adloader->waveParts.size(); i++)
	{
		if (adloader->waveParts.values().at(i).alienId == id)
		{
			msgBox.setText(tr("You can not delete alien %1 id=%2").arg(adloader->aliens.value(id).name).arg(id));
			msgBox.setInformativeText(tr("It used in wawe %1").arg(adloader->waveParts.values().at(i).waveId));
			msgBox.setStandardButtons(QMessageBox::Ok);
			msgBox.exec();
			return;
		}
	}
	msgBox.setText(tr("Delete alien %1 id=%2").arg(adloader->aliens.value(id).name).arg(id));
	msgBox.setInformativeText(tr("Are you sure?"));
	msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
	msgBox.setDefaultButton(QMessageBox::Ok);
	int ret = msgBox.exec();
	if (ret == QMessageBox::Ok)
	{
		adloader->aliens.remove(id);
		alModel->refresh(adloader->aliens.values());
		ui->lvAliens->setModel((QAbstractItemModel * )alModel);
		ui->lvAliens->reset();
		ui->lvAliens->selectionModel()->setCurrentIndex(ui->lvAliens->model()->index(0,0),QItemSelectionModel::ClearAndSelect);
		isSaved = false;
	}
}


void MainWindow::on_leTwName_editingFinished()
{
	int id = adloader->towers.values().at(ui->lvTowers->currentIndex().row()).id;
	adloader->towers[id].name = ui->leTwName->text();
	twModel->refresh(adloader->towers.values());
	ui->lvTowers->setModel((QAbstractItemModel * )twModel);
	isSaved = false;
}


void MainWindow::on_sbTwBuildTime_valueChanged(int val)
{
	int id = adloader->towers.values().at(ui->lvTowers->currentIndex().row()).id;
	adloader->towers[id].buildTime = val;
	isSaved = false;
}


void MainWindow::on_sbTwCost_valueChanged(int val)
{
	int id = adloader->towers.values().at(ui->lvTowers->currentIndex().row()).id;
	adloader->towers[id].cost = val;
	isSaved = false;
}


void MainWindow::on_cbTwSplash_currentIndexChanged(int index)
{
	if (index > 0)
	{
		int id = adloader->towers.values().at(ui->lvTowers->currentIndex().row()).id;
		adloader->towers[id].splashId = adloader->splashes.values().at(index).id;
		isSaved = false;
	}
}

void MainWindow::on_sbTwReload_valueChanged(int val)
{
	int id = adloader->towers.values().at(ui->lvTowers->currentIndex().row()).id;
	adloader->towers[id].reload = val;
	isSaved = false;
}


void MainWindow::on_sbTwRadius_valueChanged(double val)
{
	int id = adloader->towers.values().at(ui->lvTowers->currentIndex().row()).id;
	adloader->towers[id].radius = val;
	isSaved = false;
}


void MainWindow::on_sbTwExpByShot_valueChanged(double val)
{
	int id = adloader->towers.values().at(ui->lvTowers->currentIndex().row()).id;
	adloader->towers[id].expByShot = val;
	isSaved = false;
}


void MainWindow::on_cbTwExpByShot_toggled(bool checked)
{
	int id = adloader->towers.values().at(ui->lvTowers->currentIndex().row()).id;
	ui->sbTwExpByShot->setEnabled(checked);
	if (checked) adloader->towers[id].expByShot = ui->sbTwExpByShot->value();
	else adloader->towers[id].expByShot = 0;
	isSaved = false;
}


void MainWindow::on_sbTwExpByDam_valueChanged(double val)
{
	int id = adloader->towers.values().at(ui->lvTowers->currentIndex().row()).id;
	adloader->towers[id].expByDamage = val;
	isSaved = false;
}


void MainWindow::on_cbTwExpByDam_toggled(bool checked)
{
	int id = adloader->towers.values().at(ui->lvTowers->currentIndex().row()).id;
	ui->sbTwExpByDam->setEnabled(checked);
	if (checked) adloader->towers[id].expByDamage = ui->sbTwExpByDam->value();
	else adloader->towers[id].expByDamage = 0;
	isSaved = false;
}


void MainWindow::on_sbTwExpByKill_valueChanged(double val)
{
	int id = adloader->towers.values().at(ui->lvTowers->currentIndex().row()).id;
	adloader->towers[id].expByKill = val;
	isSaved = false;
}


void MainWindow::on_cbTwExpByKill_toggled(bool checked)
{
	int id = adloader->towers.values().at(ui->lvTowers->currentIndex().row()).id;
	ui->sbTwExpByKill->setEnabled(checked);
	if (checked) adloader->towers[id].expByKill = ui->sbTwExpByKill->value();
	else adloader->towers[id].expByKill = 0;
	isSaved = false;
}


void MainWindow::on_pbTwAdd_clicked()
{
	int i = 1;
	while (adloader->towers.contains(i)) i++;
	tbTower tw;
	tw.id = i;
	tw.name = tr("Tower");
	tw.splashId = adloader->splashes.keys().at(0);
	tw.buildTime = 1;
	tw.cost = 1;
	tw.radius = 1;
	tw.reload = 1;
	adloader->towers.insert(tw.id,tw);
	int index = adloader->towers.keys().indexOf(i);
	twModel->refresh(adloader->towers.values());
	ui->lvTowers->setModel((QAbstractItemModel * )twModel);
	ui->lvTowers->reset();
	ui->lvTowers->selectionModel()->setCurrentIndex(ui->lvTowers->model()->index(index,0),QItemSelectionModel::ClearAndSelect);
	isSaved = false;
}


void MainWindow::on_pbTwDel_clicked()
{
	if (adloader->towers.size() < 2) return;
	QMessageBox msgBox;
	int id = adloader->towers.keys().at(ui->lvTowers->currentIndex().row());
	for (int i=0; i<adloader->levTowers.size(); i++)
	{
		if (adloader->levTowers.values().at(i).towerId == id)
		{
			msgBox.setText(tr("You can not delete tower %1 id=%2").arg(adloader->towers.value(id).name).arg(id));
			msgBox.setInformativeText(tr("It used in level %1").arg(adloader->levTowers.values().at(i).levelId));
			msgBox.setStandardButtons(QMessageBox::Ok);
			msgBox.exec();
			return;
		}
	}
	msgBox.setText(tr("Delete tower %1 id=%2").arg(adloader->towers.value(id).name).arg(id));
	msgBox.setInformativeText(tr("Are you sure?"));
	msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
	msgBox.setDefaultButton(QMessageBox::Ok);
	int ret = msgBox.exec();
	if (ret == QMessageBox::Ok)
	{
		adloader->towers.remove(id);
		twModel->refresh(adloader->towers.values());
		ui->lvTowers->setModel((QAbstractItemModel * )twModel);
		ui->lvTowers->reset();
		ui->lvTowers->selectionModel()->setCurrentIndex(ui->lvTowers->model()->index(0,0),QItemSelectionModel::ClearAndSelect);
		isSaved = false;
	}
}

void MainWindow::on_leSplName_editingFinished()
{
	int id = adloader->splashes.values().at(ui->lvSplashes->currentIndex().row()).id;
	adloader->splashes[id].name = ui->leSplName->text();
	splModel->refresh(adloader->splashes.values());
	ui->lvSplashes->setModel((QAbstractItemModel * )splModel);
	ui->cbTwSplash->setModel((QAbstractItemModel * )splModel);
	isSaved = false;
}


void MainWindow::on_sbSplSpeed_valueChanged(double val)
{
	int id = adloader->splashes.values().at(ui->lvSplashes->currentIndex().row()).id;
	adloader->splashes[id].speed = val;
	isSaved = false;
}


void MainWindow::on_cbSplAutoControl_toggled(bool checked)
{
	int id = adloader->splashes.values().at(ui->lvSplashes->currentIndex().row()).id;
	adloader->splashes[id].autoControl = checked;
	isSaved = false;
}


void MainWindow::on_sbSplLifeTime_valueChanged(int val)
{
	int id = adloader->splashes.values().at(ui->lvSplashes->currentIndex().row()).id;
	adloader->splashes[id].lifetime = val;
	isSaved = false;
}


void MainWindow::on_pbSplAdd_clicked()
{
	int i = 1;
	while (adloader->splashes.contains(i)) i++;
	tbSplash spl;
	spl.id = i;
	spl.name = tr("Splash");
	spl.lifetime = 1;
	spl.speed = 1;
	adloader->splashes.insert(spl.id,spl);
	int index = adloader->splashes.keys().indexOf(i);
	splModel->refresh(adloader->splashes.values());
	ui->lvSplashes->setModel((QAbstractItemModel * )splModel);
	ui->lvSplashes->reset();
	ui->lvSplashes->selectionModel()->setCurrentIndex(ui->lvSplashes->model()->index(index,0),QItemSelectionModel::ClearAndSelect);
	ui->cbTwSplash->setModel((QAbstractItemModel * )splModel);
	isSaved = false;
}



void MainWindow::on_pbSlpDel_clicked()
{
	if (adloader->splashes.size() < 2) return;
	QMessageBox msgBox;
	int id = adloader->splashes.keys().at(ui->lvSplashes->currentIndex().row());
	for (int i=0; i<adloader->towers.size(); i++)
	{
		if (adloader->towers.values().at(i).splashId == id)
		{
			msgBox.setText(tr("You can not delete splash %1 id=%2").arg(adloader->splashes.value(id).name).arg(id));
			msgBox.setInformativeText(tr("It used by tower %1 id=%2").arg(adloader->towers.values().at(i).name).arg(adloader->towers.values().at(i).id));
			msgBox.setStandardButtons(QMessageBox::Ok);
			msgBox.exec();
			return;
		}
	}
	for (int i=0; i<adloader->chains.size(); i++)
	{
		if (adloader->chains.values().at(i).childSplashId == id
			|| adloader->chains.values().at(i).parentSplashId == id)
		{
			msgBox.setText(tr("You can not delete splash %1 id=%2").arg(adloader->splashes.value(id).name).arg(id));
			msgBox.setInformativeText(tr("It used by chain in tower %1 id=%2").arg(adloader->towers.value(adloader->chains.values().at(i).towerId).name).arg(adloader->chains.values().at(i).towerId));
			msgBox.setStandardButtons(QMessageBox::Ok);
			msgBox.exec();
			return;
		}
	}
	msgBox.setText(tr("Delete splash %1 id=%2").arg(adloader->splashes.value(id).name).arg(id));
	msgBox.setInformativeText(tr("Are you sure?"));
	msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
	msgBox.setDefaultButton(QMessageBox::Ok);
	int ret = msgBox.exec();
	if (ret == QMessageBox::Ok)
	{
		adloader->splashes.remove(id);
		splModel->refresh(adloader->splashes.values());
		ui->lvSplashes->setModel((QAbstractItemModel * )splModel);
		ui->lvSplashes->reset();
		ui->lvSplashes->selectionModel()->setCurrentIndex(ui->lvSplashes->model()->index(0,0),QItemSelectionModel::ClearAndSelect);
		ui->cbTwSplash->setModel((QAbstractItemModel * )splModel);
		isSaved = false;
	}
}


void MainWindow::on_pbTwSplashEdit_clicked()
{
	int splIndex = adloader->splashes.keys().indexOf(adloader->towers.values().at(ui->lvTowers->currentIndex().row()).splashId);
	ui->lvSplashes->selectionModel()->setCurrentIndex(ui->lvSplashes->model()->index(splIndex,0),QItemSelectionModel::ClearAndSelect);
	ui->tabWidget->setCurrentWidget(ui->tabSplashes);
}


void MainWindow::on_cbTrigChance_toggled(bool checked)
{
	int id = adloader->triggers.values().at(ui->lvTriggers->currentIndex().row()).id;
	ui->sbTrigChance->setEnabled(checked);
	if (checked) adloader->triggers[id].chance = ui->sbTrigChance->value();
	else adloader->triggers[id].chance = 100;
	isSaved = false;
}


void MainWindow::on_sbTrigChance_valueChanged(int val)
{
	int id = adloader->triggers.values().at(ui->lvTriggers->currentIndex().row()).id;
	adloader->triggers[id].chance = val;
	isSaved = false;
}


void MainWindow::on_leTrigName_editingFinished()
{
	int id = adloader->triggers.values().at(ui->lvTriggers->currentIndex().row()).id;
	adloader->triggers[id].name = ui->leTrigName->text();
	trigModel->refresh(adloader->triggers.values());
	ui->lvTriggers->setModel((QAbstractItemModel * )trigModel);
	isSaved = false;
}


void MainWindow::on_sbTrigCount_valueChanged(int val)
{
	int id = adloader->triggers.values().at(ui->lvTriggers->currentIndex().row()).id;
	adloader->triggers[id].count = val;
	isSaved = false;
}


void MainWindow::on_sbTrigRandomRadius_valueChanged(double value)
{
	int id = adloader->triggers.values().at(ui->lvTriggers->currentIndex().row()).id;
	adloader->triggers[id].randomPosRadius = value;
	isSaved = false;
}


void MainWindow::on_cbTrigDelPar_toggled(bool checked)
{
	int id = adloader->triggers.values().at(ui->lvTriggers->currentIndex().row()).id;
	adloader->triggers[id].delParent = checked;
	isSaved = false;
}


void MainWindow::on_sbTrigTimer_valueChanged(int val)
{
	int id = adloader->triggers.values().at(ui->lvTriggers->currentIndex().row()).id;
	adloader->triggers[id].timer = val;
	isSaved = false;
}


void MainWindow::on_sbTrigDamage_valueChanged(double value)
{
	int id = adloader->triggers.values().at(ui->lvTriggers->currentIndex().row()).id;
	adloader->triggers[id].damage = value;
	isSaved = false;
}


void MainWindow::on_sbTrigDamRadius_valueChanged(double value)
{
	int id = adloader->triggers.values().at(ui->lvTriggers->currentIndex().row()).id;
	adloader->triggers[id].radius = value;
	isSaved = false;
}


void MainWindow::on_cbTrigDamRad_toggled(bool checked)
{
	int id = adloader->triggers.values().at(ui->lvTriggers->currentIndex().row()).id;
	ui->sbTrigDamRadius->setEnabled(checked);
	if (checked) adloader->triggers[id].radius = ui->sbTrigDamRadius->value();
	else adloader->triggers[id].radius = 0;
	isSaved = false;
}


void MainWindow::on_cbTrigDamage_toggled(bool checked)
{
	int id = adloader->triggers.values().at(ui->lvTriggers->currentIndex().row()).id;
	ui->sbTrigDamage->setEnabled(checked);
	if (checked) adloader->triggers[id].damage = ui->sbTrigDamage->value();
	else adloader->triggers[id].damage = 0;
	isSaved = false;
}


void MainWindow::on_cbTrigRandRadius_toggled(bool checked)
{
	int id = adloader->triggers.values().at(ui->lvTriggers->currentIndex().row()).id;
	ui->sbTrigRandomRadius->setEnabled(checked);
	if (checked) adloader->triggers[id].randomPosRadius = ui->sbTrigRandomRadius->value();
	else adloader->triggers[id].randomPosRadius = 0;
	isSaved = false;
}


void MainWindow::on_cbTrigCount_toggled(bool checked)
{
	int id = adloader->triggers.values().at(ui->lvTriggers->currentIndex().row()).id;
	ui->sbTrigCount->setEnabled(checked);
	if (checked) adloader->triggers[id].count = ui->sbTrigCount->value();
	else adloader->triggers[id].count = 0;
	isSaved = false;
}


void MainWindow::on_pbTrigAdd_clicked()
{
	int i = 1;
	while (adloader->triggers.contains(i)) i++;
	tbTrigger trig;
	trig.id = i;
	trig.name = tr("Trigger");
	trig.count = 0;
	trig.damage = 0;
	trig.radius = 0;
	trig.timer = 10;
	trig.chance = 100;
	trig.delParent =true ;
	trig.childAim = srcTriggerType::noAim;
	trig.randomPosRadius = 0;
	trig.type = srcTriggerType::onDestination;
	adloader->triggers.insert(trig.id,trig);
	int index = adloader->triggers.keys().indexOf(i);
	trigModel->refresh(adloader->triggers.values());
	ui->lvTriggers->setModel((QAbstractItemModel * )trigModel);
	ui->lvTriggers->reset();
	ui->lvTriggers->selectionModel()->setCurrentIndex(ui->lvTriggers->model()->index(index,0),QItemSelectionModel::ClearAndSelect);
	isSaved = false;
}


void MainWindow::on_pbTrigDel_clicked()
{
	if (adloader->triggers.size() < 2) return;
	QMessageBox msgBox;
	int id = adloader->triggers.keys().at(ui->lvTriggers->currentIndex().row());
	for (int i=0; i<adloader->chains.size(); i++)
	{
		if (adloader->chains.values().at(i).triggerId == id)
		{
			msgBox.setText(tr("You can not delete trigger %1 id=%2").arg(adloader->triggers.value(id).name).arg(id));
			msgBox.setInformativeText(tr("It used by chain in tower %1 id=%2").arg(adloader->towers.value(adloader->chains.values().at(i).towerId).name).arg(adloader->chains.values().at(i).towerId));
			msgBox.setStandardButtons(QMessageBox::Ok);
			msgBox.exec();
			return;
		}
	}
	msgBox.setText(tr("Delete trigger %1 id=%2").arg(adloader->triggers.value(id).name).arg(id));
	msgBox.setInformativeText(tr("Are you sure?"));
	msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
	msgBox.setDefaultButton(QMessageBox::Ok);
	int ret = msgBox.exec();
	if (ret == QMessageBox::Ok)
	{
		adloader->triggers.remove(id);
		trigModel->refresh(adloader->triggers.values());
		ui->lvTriggers->setModel((QAbstractItemModel * )trigModel);
		ui->lvTriggers->reset();
		ui->lvTriggers->selectionModel()->setCurrentIndex(ui->lvTriggers->model()->index(0,0),QItemSelectionModel::ClearAndSelect);
		isSaved = false;
	}
}


void MainWindow::on_cbTrigType_currentIndexChanged(int index)
{
	int id = adloader->triggers.values().at(ui->lvTriggers->currentIndex().row()).id;
	adloader->triggers[id].type = (srcTriggerType::triggerType)ui->cbTrigType->itemData(index).toInt();
	if (adloader->triggers[id].type != srcTriggerType::onTimer)
	{
		ui->lbTrigTimer->setVisible(false);
		ui->sbTrigTimer->setVisible(false);
	} else {
		ui->lbTrigTimer->setVisible(true);
		ui->sbTrigTimer->setVisible(true);
		ui->sbTrigTimer->setValue(adloader->triggers[id].timer);
	}
	isSaved = false;
}


void MainWindow::on_cbTrigChildAim_currentIndexChanged(int index)
{
	int id = adloader->triggers.values().at(ui->lvTriggers->currentIndex().row()).id;
	adloader->triggers[id].childAim = (srcTriggerType::aimType)ui->cbTrigChildAim->itemData(index).toInt();
	isSaved = false;
}


void MainWindow::on_pbImgAdd_clicked()
{
	int id = adloader->animations.values().at(ui->lvAnimations->currentIndex().row()).id;
	QFileDialog fd;
	QStringList strl;
	fd.setNameFilter(tr("Images (*.png)"));
	fd.setFileMode(QFileDialog::ExistingFiles);
	QDir dir;
	if (fd.exec())
	{
		strl = fd.selectedFiles();
		for (int i=0; i<strl.size(); ++i)
		{
			strl[i] = dir.relativeFilePath(strl[i]);
		}
		adloader->animations[id].pathes.append(strl);
		refresh_lwImages(adloader->animations.value(id).pathes);
		isSaved = false;
	}
}


void MainWindow::refresh_lwImages(QStringList pathes)
{
	ui->lwImages->clear();
	for (int i=0; i<pathes.size(); ++i)
	{
		ui->lwImages->addItem(new QListWidgetItem(QIcon(pathes.at(i)),pathes.at(i)));
	}
}


void MainWindow::on_pbImgDel_clicked()
{
	int id = adloader->animations.values().at(ui->lvAnimations->currentIndex().row()).id;
	for (int i=0; i<ui->lwImages->selectedItems().size(); ++i)
		adloader->animations[id].pathes.removeOne(ui->lwImages->selectedItems().at(i)->text());
	refresh_lwImages(adloader->animations.value(id).pathes);
}