#include "MainWindow.h"
#include "ui_MainWindow.h"

#include <QFileDialog>
#include <QFile>

#include "header/strategies/ScanConversion.h"
#include "header/strategies/Rejection.h"
#include "header/FileHelper.h"

#define OUT_WIDTH	1000
#define OUT_HEIGHT	1000

MainWindow* MainWindow::_instance;

MainWindow::MainWindow(QWidget *parent)
	: QMainWindow(parent)
	, ui(new Ui::MainWindow)
	, _settings("hasis", "kernel tester")
{
	_instance = this;
	ui->setupUi(this);

	_CLContext = _openCLHelper.getContext();
	CLQueue = _openCLHelper.createCommandQueue(_CLContext,
											   _openCLHelper
											   .getDevicesByContext(
												_CLContext)[0]);

	registerStrategies();
	_strategy = Q_NULLPTR;
}

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


void MainWindow::browse(QLineEdit *edit)
{
	QFileDialog dialog;
	dialog.setFileMode(QFileDialog::Directory);
	dialog.setOption(QFileDialog::ShowDirsOnly);
	if (dialog.exec() == QDialog::Rejected)
		return;
	edit->setText(dialog.selectedFiles()[0]);
}

void MainWindow::abort()
{
	addToConsole("Operation is aborted!");
}

void MainWindow::addToConsole(QString message)
{
	ui->rtb_console->append(">>>  " + message);
}

bool MainWindow::checkPath(QString path, QString pathName)
{
	QDir temp(path);
	if(!temp.exists() || path == "")
	{
		addToConsole(pathName + " directory is not valid");
		abort();
		return false;
	}
	return true;
}

void MainWindow::registerStrategies()
{
	REGISTER_STRATEGY(ScanConversion)
	REGISTER_STRATEGY(Rejection)
}

void MainWindow::pushBackStrategy(const QString strategyName, const QString kernelFolder)
{
	int id = QMetaType::type(strategyName.toStdString().data());
	if (id == QMetaType::UnknownType)
	{
		addToConsole("scenario is not registered");
		throw;
	}

	_strategy =
				static_cast<IProcessStrategy*>(
					QMetaType::metaObjectForType(id)->newInstance(
						Q_ARG(const Context, _CLContext),
						Q_ARG(const QString, kernelFolder)
						));

	addToConsole("Strategy was created");
}


void MainWindow::on_btn_browseInput_clicked()
{
	browse(ui->tb_inpDir);
}

void MainWindow::on_btn_browseOutput_clicked()
{
	browse(ui->tb_outpDir);
}

void MainWindow::on_btn_browseMatlabOutput_clicked()
{
	browse(ui->tb_matlabOutp);
}

void MainWindow::on_btn_browseWorkingDir_clicked()
{
	browse(ui->tb_workingDir);
}

void MainWindow::on_btn_test_clicked()
{
	if (!checkPath(ui->tb_inpDir->text(), "Input"))
		return;

	if (!checkPath(ui->tb_outpDir->text(), "Output"))
		return;

	if (!checkPath(ui->tb_workingDir->text(), "Working"))
		return;

	QDir inputDir(ui->tb_inpDir->text());
	QDir outputDir(ui->tb_outpDir->text());
	QDir workingDir(ui->tb_workingDir->text());

	if(ui->cb_kernelName->currentIndex() < 0)
	{
		addToConsole("Please select a kernel to test");
		abort();
		return;
	}

	if(_strategy)
		_strategy->finalize();
	pushBackStrategy(ui->cb_kernelName->currentText(), workingDir.path() + "/kernels");

	auto inputs = inputDir.entryList(QStringList() << "*.csv", QDir::Files);
	foreach(QString filename, inputs)
	{
		addToConsole("processing " + filename);
		auto dataPath = inputDir.path() + "/" + filename;
		auto paramPath = inputDir.path() + "/params/" + filename;

		_strategy->ReadParams(paramPath, &_scenGenOutput);


		QByteArray arr;
		quint64 width;
		quint64 height = 0;
		if (!FileHelper::ReadInputFile(arr, dataPath, &width, &height))
		{
			addToConsole("Some thing wnet wrong in input file");
			abort();
			return;
		}

		ImageFormat format;
		format.image_channel_order = CL_RGBA;
#ifdef USE_DBL
		format.image_channel_data_type = CL_UNSIGNED_INT16;
#else
		format.image_channel_data_type = CL_UNSIGNED_INT8;
#endif

		Image2D* inFrame = static_cast<Image2D*>(_openCLHelper
												 .frame2CLFrame(_CLContext, format, QVector<quint64>{width, height}, true));

		CLQueue.enqueueWriteImage(*inFrame, CL_TRUE, array<size_type, 3> {0, 0, 0},
								array<size_type, 3> {width, height, 1},
								width * sizeof (myflt),
								0,
								arr.data());

		update_field(&_scenGenOutput.outputWidth, OUT_WIDTH);
		update_field(&_scenGenOutput.outputHeight, OUT_HEIGHT);
		_strategy->cpuProcess(_scenGenOutput);
		auto outFrame = _strategy->processKernel(inFrame);

		char *out;
		out = (char*)malloc(OUT_WIDTH * OUT_WIDTH * sizeof (char) * sizeof (myflt));
		CLQueue.enqueueReadImage(*outFrame,
							   CL_TRUE,
							   array<size_type, 3> {0, 0, 0},
							   array<size_type, 3> {OUT_WIDTH, OUT_HEIGHT, 1},
							   OUT_WIDTH * sizeof (myflt),
							   0,
							   out);

		FileHelper::WriteOutputFile(out, outputDir.path() + "/" + filename, OUT_WIDTH, OUT_HEIGHT);
		addToConsole(filename + " has been processed");
	}
}

void MainWindow::on_btn_save_clicked()
{
	_settings.setValue("inputDir", ui->tb_inpDir->text());
	_settings.setValue("outputDir", ui->tb_outpDir->text());
	_settings.setValue("matlabDir", ui->tb_matlabOutp->text());
	_settings.setValue("workingDir", ui->tb_workingDir->text());
}

void MainWindow::on_btn_load_clicked()
{
	ui->tb_inpDir->setText(_settings.value("inputDir").toString());
	ui->tb_outpDir->setText(_settings.value("outputDir").toString());
	ui->tb_matlabOutp->setText(_settings.value("matlabDir").toString());
	ui->tb_workingDir->setText(_settings.value("workingDir").toString());
}

void MainWindow::on_btn_compare_clicked()
{
	if (!checkPath(ui->tb_outpDir->text(), "Output"))
		return;

	if (!checkPath(ui->tb_matlabOutp->text(), "Matlab output"))
		return;

	QDir matlabDir(ui->tb_matlabOutp->text());
	QDir outputDir(ui->tb_outpDir->text());

	auto totalMax = 0U;
	auto outputs = outputDir.entryList(QStringList() << "*.csv", QDir::Files);
	foreach(QString filename, outputs)
	{
		addToConsole("Comaring " + filename);
		auto cppout = new myint[OUT_WIDTH * OUT_HEIGHT];
		auto matout = new myint[OUT_WIDTH * OUT_HEIGHT];
		quint64 w1, w2;
		quint64 h1 = 0, h2 = 0;

		FileHelper::ReadInputFile(cppout, outputDir.path() + "/" + filename, &w1, &h1);

		if(!QFile::exists(matlabDir.path() + "/" + filename))
		{
			addToConsole("matlab file for " + filename + " does not exist");
			continue;
		}
		FileHelper::ReadInputFile(matout, matlabDir.path() + "/" + filename, &w2, &h2);

		if (w1 != OUT_WIDTH || w2 != OUT_WIDTH)
		{
			addToConsole("Width mismatch");
			continue;
		}
		if (h1 != OUT_HEIGHT || h2 != OUT_HEIGHT)
		{
			addToConsole("Height mismatch");
			continue;
		}

		uint max = 0;
		for(int i = 0; i < w1; i++)
		{
			for(int j = 0; j < h1; j++)
			{
				if(abs(cppout[j * w1 + i] - matout[j * w1 + i]) > max)
				{
					max = abs(cppout[j * w1 + i] - matout[j * w1 + i]);
				}
			}
		}

		if(max > totalMax)
			totalMax = max;
		addToConsole(QString::number(max));
		addToConsole("*************************\r\n");
	}

	addToConsole("Compare done, total max: " + QString::number(totalMax));
}