#include "rule-editor.h"

#include "highlighter.h"
#include "ruleset-parser/rule.h"

#include "rule-editor.moc"

//#include <QtGui>

#include <ui_rule-editor.h>

#include <QFileInfo>


RuleEditor::RuleEditor(QWidget *parent)
	: QDialog(parent)
{
	ui = new Ui::RuleEditor();
	ui->setupUi(this);

	highlighter = new RuleSetHighlighter(ui->editor->document(),ui->regexEditor);

	connect(ui->regexEditor, SIGNAL(textChanged(const QString &)), highlighter, SLOT(rehighlight()));

        createPropertiesEditor();
	createValidators();

	connectSlots();
}

void RuleEditor::connectSlots()
{
	connect(ui->pb_new_prop, SIGNAL(pressed()), this, SLOT(addProperty()));
	connect(ui->pb_del_prop, SIGNAL(pressed()), this, SLOT(deleteProperty()));
}

void RuleEditor::createPropertiesEditor()
{
	ui->optionsTable->setColumnCount(2);
	ui->optionsTable->setRowCount(1);
	QStringList labels;
	labels << tr("IDMEF Path") << tr("value");
	ui->optionsTable->setHorizontalHeaderLabels( labels );
	ui->optionsTable->setColumnWidth(0, ui->optionsTable->width() * 45 / 100);
	ui->optionsTable->setColumnWidth(1, ui->optionsTable->width() * 45 / 100);
}

void RuleEditor::createValidators()
{
        QValidator *validator = new QIntValidator(0, INT_MAX, this);

        ui->le_id->setValidator(validator);
        ui->le_revision->setValidator(validator);
        ui->le_goto->setValidator(validator);
        ui->le_optgoto->setValidator(validator);
}

void RuleEditor::clear()
{
	ui->editor->clear();
	ui->regexEditor->clear();
	setCurrentRegexFile("");

	clearOptions();

        ui->optionsTable->clearContents();
        ui->optionsTable->setRowCount(0);
}

void RuleEditor::clearOptions()
{
	ui->cb_id->setCheckState(Qt::Unchecked);
	ui->le_id->setEnabled(false);
	ui->le_id->clear();
	ui->cb_revision->setCheckState(Qt::Unchecked);
	ui->le_revision->setEnabled(false);
	ui->le_revision->clear();
	ui->cb_last->setCheckState(Qt::Unchecked);
	ui->cb_silent->setCheckState(Qt::Unchecked);
	ui->cb_chained->setCheckState(Qt::Unchecked);
	ui->cb_goto->setCheckState(Qt::Unchecked);
	ui->le_goto->setEnabled(false);
	ui->le_goto->clear();
	ui->cb_optgoto->setCheckState(Qt::Unchecked);
	ui->le_optgoto->setEnabled(false);
	ui->le_optgoto->clear();
}

void RuleEditor::setCurrentRegexFile(const QString &fileName)
{
	curRegexFile = fileName;
	//textEdit->document()->setModified(false);
	setWindowModified(false);

	QString shownName;
	if (curRegexFile.isEmpty())
		shownName = "untitled";
	else
		shownName = strippedName(curRegexFile);

	setWindowTitle(tr("%1[*] - %2").arg(shownName).arg(tr("lmledit")));
}

void RuleEditor::setRule(const Rule *r)
{
        Q_ASSERT(r != NULL);

        //std::cout << "Loading rule: " << r << "\n";

	ui->regexEditor->setText(r->regex());

        const QStringList logSamples = r->logSamples();
        for (int i=0; i<logSamples.size(); i++) {
                ui->editor->append( logSamples.at(i) );
        }

        ui->optionsTable->clearContents();
        ui->optionsTable->setRowCount(0);
        QList<QString> options = r->options();
        for (int index=0; index<options.size(); index++) {
                addOption(options.at(index), r->getOption(options.at(index)));
        }

        if ( r->hasRuleOption("id") )
                setRuleId( r->getRuleOption("id") );
        if ( r->hasRuleOption("last") )
                setLast( (r->getRuleOption("last")=="1") ? true : false );
        if ( r->hasRuleOption("revision") )
                setRevision( r->getRuleOption("revision") );
        if ( r->hasRuleOption("silent") )
                setSilent( (r->getRuleOption("silent")=="1") ? true : false );
        if ( r->hasRuleOption("chained") )
                setChained( (r->getRuleOption("chained")=="1") ? true : false );
        if ( r->hasRuleOption("goto") )
                setGoto( r->getRuleOption("goto") );
        if ( r->hasRuleOption("optgoto") )
                setOptGoto( r->getRuleOption("optgoto") );
}

void RuleEditor::setRegex(const QString &s)
{
	ui->regexEditor->setText(s);
}

const QString RuleEditor::regex() const
{
	return ui->regexEditor->text();
}

void RuleEditor::setRuleId(const QString id)
{
        ui->cb_id->setCheckState(Qt::Checked);
        ui->le_id->setText(id);
        ui->le_id->setEnabled(true);
}

void RuleEditor::setLast(bool is_last)
{
        ui->cb_last->setCheckState( (is_last)?Qt::Checked:Qt::Unchecked);
}

void RuleEditor::setRevision(const QString t)
{
        ui->cb_revision->setCheckState(Qt::Checked);
        ui->le_revision->setEnabled(true);
        ui->le_revision->setText(t);
}

void RuleEditor::setSilent(bool is_set)
{
        ui->cb_silent->setCheckState( (is_set)?Qt::Checked:Qt::Unchecked);
}

void RuleEditor::setChained(bool is_set)
{
        ui->cb_chained->setCheckState( (is_set)?Qt::Checked:Qt::Unchecked);
}

void RuleEditor::setGoto(const QString t)
{
        ui->cb_goto->setCheckState(Qt::Checked);
        ui->le_goto->setEnabled(true);
        ui->le_goto->setText(t);
}

void RuleEditor::setOptGoto(const QString t)
{
        ui->cb_optgoto->setCheckState(Qt::Checked);
        ui->le_optgoto->setEnabled(true);
        ui->le_optgoto->setText(t);
}

void RuleEditor::addProperty()
{
        int rows = ui->optionsTable->rowCount();
        ui->optionsTable->setRowCount(rows+1);
}

void RuleEditor::deleteProperty()
{
        int row = ui->optionsTable->currentRow();

        if (row >= 0) {
                ui->optionsTable->removeRow(row);
        }
}

void RuleEditor::addOption(const QString &key, const QString &value)
{
        QTableWidgetItem *newItem;
        int rows = ui->optionsTable->rowCount();

        ui->optionsTable->setRowCount(rows+1);

        newItem = new QTableWidgetItem(key);
        ui->optionsTable->setItem(rows,0,newItem);

        newItem = new QTableWidgetItem(value);
        ui->optionsTable->setItem(rows,1,newItem);
}

QString RuleEditor::strippedName(const QString &fullFileName)
{
	return QFileInfo(fullFileName).fileName();
}

RuleEditor::operator Rule*()
{
	QString re = ui->regexEditor->text();
	Rule * rule = new Rule(re,re);

	// regex
	rule->setRegex(re);

	// log samples
	QStringList logs = ui->editor->toPlainText().split('\n');
	QStringListIterator it(logs);
	while (it.hasNext()) {
		rule->addLogSample(it.next().toLocal8Bit().constData());
	}

	// IDMEF values
	QTableWidgetItem * list_key, * list_value;
	QString key, value;
	for (int i = 0; i < ui->optionsTable->rowCount(); ++i) {
		list_key = ui->optionsTable->item(i,0);
		list_value = ui->optionsTable->item(i,1);
		if (list_key && list_value) {
			rule->addOption(list_key->text(),list_value->text());
		}
	}

	// options
	if (ui->cb_id->checkState() == Qt::Checked) {
		QString str_id = ui->le_id->text();
		//setId( str_id.toInt() );
		rule->setRuleOption("id",str_id);
	}
	if (ui->cb_last->checkState() == Qt::Checked)
		rule->setRuleOption("last","1");
	if (ui->cb_revision->checkState() == Qt::Checked)
		rule->setRuleOption("revision",ui->le_revision->text());
	if (ui->cb_silent->checkState() == Qt::Checked)
		rule->setRuleOption("silent","1");
	if (ui->cb_chained->checkState() == Qt::Checked)
		rule->setRuleOption("chained","1");
	if (ui->cb_goto->checkState() == Qt::Checked)
		rule->setRuleOption("goto",ui->le_goto->text());
	if (ui->cb_optgoto->checkState() == Qt::Checked)
		rule->setRuleOption("optgoto",ui->le_optgoto->text());

	return rule;
}