/*
* This file is part of project OpenEmbroidery. It's copyrighted by
* the contributors recorded in the version control history of the file.
* Original project location https://code.electrolab.fr/openEmbroidery/openEmbroidery_software
*
* SPDX-License-Identifier: CECILL-2.1
* License-Filename: Licence_CeCILL_V2.1-en.txt
*/

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "main.h"
#include "machine.h"
#include <QSerialPortInfo>
#include <QDebug>

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow),
    machine(new Machine(100, 10))
{
	ui->setupUi(this);
	statusBar()->insertWidget(0, &status, 1);
	addTab();
	ui->tabWidget->removeTab(0);
	connect(machine.get(), &Machine::connectionChanged, this, &MainWindow::on_machineConnectionChanged);
	connect(machine.get(), &Machine::stateChanged, this, &MainWindow::on_machineStateChanged);
}

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

OE_root* MainWindow::getCurrentRoot()
{
	QWidget* widget = ui->tabWidget->currentWidget();
	return static_cast<OE_root*>(widget->property("OEroot").value<void*>());
}


void MainWindow::keyPressEvent(QKeyEvent* event)
{
	getCurrentRoot()->display->keyPressEvent(event);
}

void MainWindow::keyReleaseEvent(QKeyEvent* event)
{
	getCurrentRoot()->display->keyReleaseEvent(event);
}

void MainWindow::addTab()
{
	QWidget* newtab = new QWidget();
	newtab->setObjectName(QStringLiteral("newtab"));
	QGridLayout * newGridLayout = new QGridLayout(newtab);
	newGridLayout->setSpacing(6);
	newGridLayout->setContentsMargins(11, 11, 11, 11);
	newGridLayout->setObjectName(QStringLiteral("newGridLayout"));
	newGridLayout->setHorizontalSpacing(0);
	newGridLayout->setContentsMargins(0, 0, 0, 0);
	OE_interfaceDisplay* newOpenGLWidget = new OE_interfaceDisplay(newtab);
	newOpenGLWidget->setObjectName(QStringLiteral("newOpenGLWidget"));
	newOpenGLWidget->setMouseTracking(true);
	newOpenGLWidget->setAcceptDrops(true);
	newGridLayout->addWidget(newOpenGLWidget, 0, 0, 1, 1);
	int newIndex = ui->tabWidget->addTab(newtab, QString("newtab"));
	ui->tabWidget->setTabText(ui->tabWidget->indexOf(newtab), QApplication::translate("MainWindow", "Design", nullptr));

	OE_root* newRoot = new OE_root();
	newRoot->document = new OE_document();
	newRoot->interfaceDisplay = newOpenGLWidget;
	newRoot->interfaceDisplay->setDocument(newRoot->document);
	newRoot->display = newRoot->interfaceDisplay;
	newRoot->controller = new OE_controller(newRoot->display, newRoot->document);
	newRoot->controller->initNewDocument();
	newRoot->display->setController(newRoot->controller);
	QVariant rootPointerProperty(QVariant::fromValue(static_cast<void*>(newRoot)));
	ui->tabWidget->widget(newIndex)->setProperty("OEroot", rootPointerProperty);

	ui->tabWidget->setCurrentIndex(newIndex);
	update();
}

OE_interfaceDisplay* MainWindow::getItfDisplay()
{
	QWidget* widget = ui->tabWidget->currentWidget();
	OE_root* root = static_cast<OE_root*>(widget->property("OEroot").value<void*>());
	return root->interfaceDisplay;
}

void MainWindow::sendKeyPulse(Qt::Key key, Qt::KeyboardModifiers modifiers)
{
	QKeyEvent fakeKeyPress(QKeyEvent::Type::KeyPress, key, modifiers);
	getItfDisplay()->key(&fakeKeyPress);
	QKeyEvent fakeKeyRelease(QKeyEvent::Type::KeyRelease, key, modifiers);
	getItfDisplay()->key(&fakeKeyRelease);
}

void MainWindow::on_tabWidget_tabCloseRequested(int index)
{
	// TODO some brain and warn if loss of data
	if (ui->tabWidget->count() == 1)
		addTab();
	QWidget* widget = ui->tabWidget->widget(index);
	OE_root* root = static_cast<OE_root*>(widget->property("OEroot").value<void*>());
	delete root->document;
	delete root->controller;
	delete root;
	ui->tabWidget->removeTab(index);
}

void MainWindow::on_actionNew_triggered()
{
	addTab();
}

void MainWindow::on_actionClose_triggered()
{
	on_tabWidget_tabCloseRequested(ui->tabWidget->currentIndex());
}

void MainWindow::on_actionOpen_triggered()
{ // TODO real call to a load function, not a fake key event
	sendKeyPulse(Qt::Key_O, Qt::KeyboardModifier::ControlModifier);
}

void MainWindow::on_actionSave_triggered()
{ // TODO real call to a save function, not a fake key event
	sendKeyPulse(Qt::Key_S, Qt::KeyboardModifier::ControlModifier);
}

void MainWindow::on_actionLine_triggered()
{ // TODO real call to a save function, not a fake key event
	sendKeyPulse(Qt::Key_L, Qt::KeyboardModifier::NoModifier);
}

void MainWindow::on_actionUndo_triggered()
{
	sendKeyPulse(Qt::Key_Z, Qt::KeyboardModifier::ControlModifier);
}

void MainWindow::on_actionRedo_triggered()
{
	sendKeyPulse(Qt::Key_Z, Qt::KeyboardModifier::ControlModifier|Qt::KeyboardModifier::ShiftModifier);
}

void MainWindow::on_actionBirail_triggered()
{
	sendKeyPulse(Qt::Key_B, Qt::KeyboardModifier::NoModifier);
}

void MainWindow::on_actionPattern1_triggered() { sendKeyPulse(Qt::Key_1, Qt::KeyboardModifier::KeypadModifier); }
void MainWindow::on_actionPattern2_triggered() { sendKeyPulse(Qt::Key_2, Qt::KeyboardModifier::KeypadModifier); }
void MainWindow::on_actionPattern3_triggered() { sendKeyPulse(Qt::Key_3, Qt::KeyboardModifier::KeypadModifier); }
void MainWindow::on_actionPattern4_triggered() { sendKeyPulse(Qt::Key_4, Qt::KeyboardModifier::KeypadModifier); }
void MainWindow::on_actionPattern5_triggered() { sendKeyPulse(Qt::Key_5, Qt::KeyboardModifier::KeypadModifier); }
void MainWindow::on_actionPattern6_triggered() { sendKeyPulse(Qt::Key_6, Qt::KeyboardModifier::KeypadModifier); }
void MainWindow::on_actionPattern7_triggered() { sendKeyPulse(Qt::Key_7, Qt::KeyboardModifier::KeypadModifier); }
void MainWindow::on_actionPattern8_triggered() { sendKeyPulse(Qt::Key_8, Qt::KeyboardModifier::KeypadModifier); }
void MainWindow::on_actionPattern9_triggered() { sendKeyPulse(Qt::Key_9, Qt::KeyboardModifier::KeypadModifier); }

void MainWindow::on_tabWidget_currentChanged(int index)
{
	if (index >= 0)
	{ // Discard previous modifiers on that widget
		QKeyEvent fakeKey(QKeyEvent::Type::KeyRelease, Qt::Key_Escape, Qt::KeyboardModifier::NoModifier);
		getItfDisplay()->key(&fakeKey);
	}
}

void MainWindow::on_actionCloseCurve_triggered()
{
	sendKeyPulse(Qt::Key_C, Qt::KeyboardModifier::NoModifier);
}

void MainWindow::on_actionReverse_curve_R_triggered()
{
	sendKeyPulse(Qt::Key_R, Qt::KeyboardModifier::NoModifier);
}

void MainWindow::on_actionFill_triggered()
{
	sendKeyPulse(Qt::Key_F, Qt::KeyboardModifier::NoModifier);
}

void MainWindow::on_actionConnectToMachine_triggered(bool checked)
{
	QString msg;
	//msg += checked ? QString::fromUtf8("[ Connected  ] ") : QString::fromUtf8("[Disconnected] ");
	//msg += QString("Seq %1. Status %2. Space %3/%4. Pos (%5, %6). Point %7. tSensor %8")
	//         .arg(42,5).arg(7).arg(800,5).arg(1016,-5).arg(24,5).arg(32,-5).arg(301,4).arg(123);
	//status.setText(msg);
	if (checked)
	{
		QList<QSerialPortInfo> ports = QSerialPortInfo::availablePorts();
		if (ports.size())
		{
			machine->connectPort(ports.front().portName());
			for (const QSerialPortInfo& port : ports)
			{
				qDebug() << port.portName() << ". " << port.description() << ". " << port.manufacturer() << ". "
				         << port.vendorIdentifier() << ". " << port.productIdentifier();
			}
		}
	}
	else
	{
		machine->disconnectPort();
	}
}
void MainWindow::on_machineConnectionChanged(bool connected)
{
	if (!connected)
	{
		QString msg = status.text().replace("[ Connected  ]", "[Disconnected]");
		status.setText(msg);
	}
	ui->actionMachineRun->setEnabled(connected);
	ui->actionMachineLoad->setEnabled(connected);
}
void MainWindow::on_machineStateChanged(Machine::SlaveInfo info)
{
	QString msg;
	msg = QString("[ Connected  ] Seq %1. Status %2. Space %3/%4. Pos (%5, %6). Point %7")
	        .arg(info.sequence,5)
	        .arg(info.status)
	        .arg(info.spaceSize-info.freeSpace,5).arg(info.spaceSize,-5)
	        .arg(info.posX,5).arg(info.posY,-5)
	        .arg(info.nPoint,4);
	status.setText(msg);
	printf("%s\n",msg.toStdString().c_str());
}

void MainWindow::on_actionMachineRun_triggered()
{
	if (machine)
		machine->startMove();
}

void MainWindow::on_actionMachineLoad_triggered()
{
	if (machine)
	{
		getCurrentRoot()->controller->sendInstPoint(machine.get());
	}
}
