/*
 * Copyright (c) 2012 Maciej Niedzielski
 * Licensed under the simplified BSD license.
 * See Documentation/Licenses/BSD-simplified.txt for more information.
 */

/*
 * Copyright (c) 2014 Kevin Smith and Remko Tronçon
 * Licensed under the GNU General Public License v3.
 * See Documentation/Licenses/GPLv3.txt for more information.
 */

#include <cassert>

#include <boost/lexical_cast.hpp>

#include <Swift/QtUI/UserSearch/QtSuggestingJIDInput.h>
#include <Swift/Controllers/HighlightManager.cpp>
#include <Swift/QtUI/QtHighlightEditor.h>
#include <Swift/QtUI/QtSwiftUtil.h>
#include <Swift/QtUI/QtSettingsProvider.h>

#include <QTreeWidgetItem>

namespace Swift {

QtHighlightEditor::QtHighlightEditor(QtSettingsProvider* settings, QWidget* parent)
	: QWidget(parent), settings_(settings)
{
	ui_.setupUi(this);

	//itemModel_ = new QtHighlightRulesItemModel(this);
	//ui_.treeView->setModel(itemModel_);
	//ui_.ruleWidget->setModel(itemModel_);
//
	//for (int i = 0; i < QtHighlightRulesItemModel::NumberOfColumns; ++i) {
		//switch (i) {
			//case QtHighlightRulesItemModel::ApplyTo:
			//case QtHighlightRulesItemModel::Sender:
			//case QtHighlightRulesItemModel::Keyword:
			//case QtHighlightRulesItemModel::Action:
				//ui_.treeView->showColumn(i);
				//break;
			//default:
				//ui_.treeView->hideColumn(i);
				//break;
		//}
	//}
//
	//setHighlightManager(NULL); // setup buttons for empty rules list
//
	connect(ui_.listWidget, SIGNAL(currentRowChanged(int)), SLOT(onCurrentRowChanged(int)));

	connect(ui_.newButton, SIGNAL(clicked()), SLOT(onNewButtonClicked()));
	connect(ui_.deleteButton, SIGNAL(clicked()), SLOT(onDeleteButtonClicked()));
	connect(ui_.moveUpButton, SIGNAL(clicked()), SLOT(onMoveUpButtonClicked()));
	connect(ui_.moveDownButton, SIGNAL(clicked()), SLOT(onMoveDownButtonClicked()));

	connect(ui_.buttonBox->button(QDialogButtonBox::Apply), SIGNAL(clicked()), SLOT(onApplyButtonClick()));
	connect(ui_.buttonBox->button(QDialogButtonBox::Cancel), SIGNAL(clicked()), SLOT(onCancelButtonClick()));
	connect(ui_.buttonBox->button(QDialogButtonBox::Ok), SIGNAL(clicked()), SLOT(onOkButtonClick()));

	ui_.lineEdit->setVisible(false);
	ui_.horizontalLayout_2->addWidget(new QtSuggestingJIDInput(this, settings));

	setWindowTitle(tr("Highlight Rules"));
}

QtHighlightEditor::~QtHighlightEditor()
{
}

void QtHighlightEditor::show()
{
	//if (itemModel_->rowCount(QModelIndex())) {
		//selectRow(0);
	//}
	QWidget::show();
	QWidget::activateWindow();
}

std::string formatNaturalDescription(const HighlightRule& rule)
{
	return "(null)";
}

void QtHighlightEditor::setHighlightManager(HighlightManager* highlightManager)
{
	highlightManager_ = highlightManager;

	ui_.listWidget->clear();

	foreach(const HighlightRule &rule, highlightManager_->getRules()) {
		QListWidgetItem *item = new QListWidgetItem();
		item->setText(P2QSTRING(formatNaturalDescription(rule)));
		ui_.listWidget->addItem(item);
	}

	//itemModel_->setHighlightManager(highlightManager);
	//ui_.newButton->setEnabled(highlightManager != NULL);
//
	//ui_.ruleWidget->setEnabled(false);
	//ui_.deleteButton->setEnabled(false);
	//ui_.moveUpButton->setEnabled(false);
	//ui_.moveDownButton->setEnabled(false);
}

void QtHighlightEditor::onNewButtonClicked()
{
	int row = getSelectedRow() + 1;
	QListWidgetItem *item = new QListWidgetItem();
	item->setText("New rule");
	ui_.listWidget->insertItem(row, item);
	selectRow(row);
}

void QtHighlightEditor::onDeleteButtonClicked()
{
	delete ui_.listWidget->takeItem(getSelectedRow());
}

void QtHighlightEditor::onMoveUpButtonClicked()
{
	//int row = getSelectedRow();
	//assert(row > 0);
//
	//ui_.ruleWidget->save();
	//ui_.ruleWidget->setActiveIndex(QModelIndex());
	//itemModel_->swapRows(row, row - 1);
	//selectRow(row - 1);
}

void QtHighlightEditor::onMoveDownButtonClicked()
{
	//int row = getSelectedRow();
	//assert(row < itemModel_->rowCount(QModelIndex()) - 1);
//
	//ui_.ruleWidget->save();
	//ui_.ruleWidget->setActiveIndex(QModelIndex());
	//if (itemModel_->swapRows(row, row + 1)) {
		//selectRow(row + 1);
	//}
}

void QtHighlightEditor::onCurrentRowChanged(int currentRow)
{
	//ui_.ruleWidget->save();
	//ui_.ruleWidget->setActiveIndex(index);
//
	//ui_.ruleWidget->setEnabled(index.isValid());

	ui_.deleteButton->setEnabled(currentRow != -1);
	ui_.moveUpButton->setEnabled(currentRow != -1 && currentRow != 0);
	ui_.moveDownButton->setEnabled(currentRow != -1 && currentRow != (ui_.listWidget->count()-1));
}

void QtHighlightEditor::onApplyButtonClick()
{
	close();
}

void QtHighlightEditor::onCancelButtonClick()
{
	close();
}

void QtHighlightEditor::onOkButtonClick()
{
	close();
}

void QtHighlightEditor::selectRow(int row)
{
	for (int i = 0; i < ui_.listWidget->count(); ++i) {
		ui_.listWidget->item(i)->setSelected(i == row);
	}
	onCurrentRowChanged(row);
}

/** Return index of selected row or -1 if none is selected */
int QtHighlightEditor::getSelectedRow() const
{
	for (int i = 0; i < ui_.listWidget->count(); ++i) {
		if (ui_.listWidget->item(i)->isSelected()) {
			return i;
		}
	}
	return -1;
}

HighlightRule QtHighlightEditor::ruleFromDialog()
{
	HighlightRule rule;

	return rule;
}

void QtHighlightEditor::ruleToDialog(const HighlightRule& rule)
{
	ui_.checkBox->setChecked(rule.getMatchChat());
	ui_.checkBox_2->setChecked(rule.getMatchMUC());

	std::vector<std::string> senders = rule.getSenders();
	if (senders.empty()) {
		ui_.checkBox_3->setChecked(false);
		ui_.lineEdit->setEnabled(false);
		ui_.lineEdit->setText("");
	} else {
		ui_.checkBox_3->setChecked(true);
		ui_.lineEdit->setEnabled(true);
		ui_.lineEdit->setText(P2QSTRING(senders[0]));
	}

	std::vector<std::string> keywords = rule.getKeywords();
	if (keywords.empty()) {
		ui_.checkBox_4->setChecked(false);
		ui_.lineEdit_2->setEnabled(false);
		ui_.lineEdit_2->setText("");
	} else {
		ui_.checkBox_4->setChecked(true);
		ui_.lineEdit_2->setEnabled(true);
		ui_.lineEdit_2->setText(P2QSTRING(keywords[0]));
	}

	ui_.nickIsKeyword->setChecked(rule.getNickIsKeyword());
	ui_.matchWholeWords_2->setChecked(rule.getMatchWholeWords());
	ui_.matchCase_2->setChecked(rule.getMatchCase());

	const HighlightAction &action = rule.getAction();

	if (action.highlightText()) {
		if (action.getTextColor().empty() && action.getTextBackground().empty()) {
			ui_.radioButton_2->setChecked(true);
		} else {
			ui_.radioButton_7->setChecked(true);
		}
	} else {
		ui_.radioButton->setChecked(true);
	}

	if (action.playSound()) {
		if (action.getSoundFile().empty()) {
			ui_.radioButton_5->setChecked(true);
		} else {
			ui_.radioButton_6->setChecked(true);
		}
	} else {
		ui_.radioButton_4->setChecked(true);
	}
}

}