#include "qtclasses.h"

EndpointWidgetEvent::EndpointWidgetEvent(QEvent::Type type, int idx) : QEvent(type){
	this->idx = idx;
}

bool ExtendedCheckBox::event(QEvent* ev) {
	if (ev->type() == QEvent::User) {
		//todo: still prone to bugs; whack-a-mole to come
		this->blockSignals(true);
		if (this->isEnabled()) {
			this->setCheckState(Qt::Checked);
			this->setDisabled(true);
		} else {
			this->setDisabled(false);
			this->setCheckState(Qt::Unchecked);
		}
		this->blockSignals(false);
		return true;		
	} 
	// Make sure the rest of events are handled
	return QCheckBox::event(ev);
}

EndpointWidget::EndpointWidget(uint64_t idx, EndpointHandler* eph, QWidget *parent) : QWidget(parent){
	//todo: based on qgridlayout, name+mute should be its own widget, same with channels
	this->idx = idx;
	this->eph = eph;
	this->eph->setFrontVisibilityInfo(EndpointState::ENDPOINT_ACTIVE, idx);
	layout = new QGridLayout(this);
	//this->setLayout(layout);
	log_debugcpp("epw main layout parent: "<< layout->parent());
	if (parent == nullptr) { log_debugcpp("owo?"); }

	defaultRolesCheckBoxes = {
		{Roles::ROLE_ALL, new ExtendedCheckBox(this)},
		{Roles::ROLE_CONSOLE, new ExtendedCheckBox(this)},
		{Roles::ROLE_MULTIMEDIA, new ExtendedCheckBox(this)},
		{Roles::ROLE_COMMUNICATIONS, new ExtendedCheckBox(this)}
	};

	/*
	 * Mute, main slider and label setup
	 */
	muteButton = new QCheckBox(this);
	mainLabel = new QLabel(QString::fromStdWString(eph->getName()), this);
	mainSlider = new QSlider(Qt::Horizontal, this);

	if (this->eph->getState() != EndpointState::ENDPOINT_ACTIVE) {
		layout->addWidget(mainLabel, 0, 0);	
		layout->addItem(new QSpacerItem(1, 1, QSizePolicy::Minimum, QSizePolicy::Minimum), 1, 0);
		return;
	}
	
	//muteButton->setStyleSheet("background-color: #A3C1DA; color: red");
	mainSlider->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
	mainSlider->setFocusPolicy(Qt::StrongFocus);
	mainSlider->setTickPosition(QSlider::TicksBothSides);
	mainSlider->setTickInterval(5);
	mainSlider->setSingleStep(1);
	mainSlider->setRange(0,100);
	
	muteButton->setCheckState((eph->getMute()  == false ? Qt::Unchecked : Qt::Checked));
	muteButton->setText(eph->getMute() ? STRING_UNMUTE : STRING_MUTE);
	float volume = eph->getVolume(AudioChannel::CHANNEL_MAIN) * 100;
	mainSlider->setValue((int)volume);
	log_debugcpp("ENDPOINT SET WITH VOLUME " << volume);

	//tip: would need to be new widget with layout in it
	//mainMuteLayout = new QGridLayout();
	layout->addWidget(mainLabel, 0, 0, Qt::AlignLeft | Qt::AlignBottom);
	layout->addWidget(muteButton, 0, 1, Qt::AlignLeft | Qt::AlignBottom);
	layout->addWidget(mainSlider, 0, 2, 1, 2);

	//TODO:0 = mute and muted, change volume = unmuted are client side tricks = 2 callbacks, one for volume, one for mute state. Implement as an user selectable option?
	connect<void(QSlider::*)(int), void(EndpointWidget::*)(int)>(mainSlider, &QSlider::valueChanged, this,&EndpointWidget::updateMainVolume);
	connect<void(QCheckBox::*)(int), void(EndpointWidget::*)(int)>(muteButton, &QCheckBox::stateChanged, this, (&EndpointWidget::updateMute));
	 

/*
 * Channel sliders setup
 */
	for(uint32_t i = 0; i < eph->getChannelCount(); i++){
		QSlider* tmp = new QSlider(Qt::Horizontal);
		QLabel* tmpLb = new QLabel("");
		tmp->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
		tmp->setTickInterval(5);
		tmp->setSingleStep(1);
		tmp->setRange(0,100);

		volume = eph->getVolume(i) * 100;
		tmp->setValue((int) volume);
		tmpLb->setText(QString::number(volume));
		this->channelSliders.push_back(tmp);
		this->channelLabels.push_back(tmpLb);
		layout->addWidget(tmp, 2, i);
		layout->addWidget(tmpLb, 3, i);
		//TODO: check if there's a need to prevent deadlocks; probably this will eventually turn into its own func
		//this causes channel bar desync when back -> front. blocksignals below fix it. huh.
		connect(tmp, &QSlider::valueChanged, [this, i](int newValue){
			this->eph->setVolume(osh->getGuid(), i, newValue);
			this->channelLabels.at(i)->setText(QString::number(newValue));
		});
	}

	/*
	 * Role ExtendedCheckBoxes setup
	 */
	
	uint8_t assignedRoles = eph->getRoles();
	defaultRolesCheckBoxes.at(Roles::ROLE_ALL)->setCheckState(assignedRoles == Roles::ROLE_ALL ? Qt::Checked : Qt::Unchecked);
	//todo duditas de &
	defaultRolesCheckBoxes.at(Roles::ROLE_ALL)->setDisabled(assignedRoles == Roles::ROLE_ALL ? true : false);
	defaultRolesCheckBoxes.at(Roles::ROLE_ALL)->setText(STRING_ROLE_ALL);

	defaultRolesCheckBoxes.at(Roles::ROLE_CONSOLE)->setCheckState(assignedRoles & Roles::ROLE_CONSOLE ? Qt::Checked : Qt::Unchecked);
	defaultRolesCheckBoxes.at(Roles::ROLE_CONSOLE)->setDisabled(assignedRoles & Roles::ROLE_CONSOLE ? true : false);
	defaultRolesCheckBoxes.at(Roles::ROLE_CONSOLE)->setText(STRING_ROLE_CONSOLE);

	defaultRolesCheckBoxes.at(Roles::ROLE_MULTIMEDIA)->setCheckState(assignedRoles & Roles::ROLE_MULTIMEDIA ? Qt::Checked : Qt::Unchecked);
	defaultRolesCheckBoxes.at(Roles::ROLE_MULTIMEDIA)->setDisabled(assignedRoles & Roles::ROLE_MULTIMEDIA ? true : false);
	defaultRolesCheckBoxes.at(Roles::ROLE_MULTIMEDIA)->setText(STRING_ROLE_MULTIMEDIA);

	defaultRolesCheckBoxes.at(Roles::ROLE_COMMUNICATIONS)->setCheckState(assignedRoles & Roles::ROLE_COMMUNICATIONS ? Qt::Checked : Qt::Unchecked);
	defaultRolesCheckBoxes.at(Roles::ROLE_COMMUNICATIONS)->setDisabled(assignedRoles & Roles::ROLE_COMMUNICATIONS ? true : false);
	defaultRolesCheckBoxes.at(Roles::ROLE_COMMUNICATIONS)->setText(STRING_ROLE_COMMUNICATIONS);

	connect(defaultRolesCheckBoxes.at(Roles::ROLE_ALL), &QCheckBox::stateChanged,[this] {
		this->eph->setRoles(Roles::ROLE_ALL);
	});
	connect(defaultRolesCheckBoxes.at(Roles::ROLE_CONSOLE), &QCheckBox::stateChanged,[this] {
		this->eph->setRoles(Roles::ROLE_CONSOLE);
	});
	connect(defaultRolesCheckBoxes.at(Roles::ROLE_MULTIMEDIA), &QCheckBox::stateChanged,[this] {
		this->eph->setRoles(Roles::ROLE_MULTIMEDIA);
	});
	
	connect(defaultRolesCheckBoxes.at(Roles::ROLE_COMMUNICATIONS), &QCheckBox::stateChanged,[this] {
		this->eph->setRoles(Roles::ROLE_COMMUNICATIONS);
	});	
	
	layout->addWidget(defaultRolesCheckBoxes.at(Roles::ROLE_ALL), 5, 0);
	layout->addWidget(defaultRolesCheckBoxes.at(Roles::ROLE_CONSOLE), 5, 1);
	layout->addWidget(defaultRolesCheckBoxes.at(Roles::ROLE_MULTIMEDIA), 5, 2);
	layout->addWidget(defaultRolesCheckBoxes.at(Roles::ROLE_COMMUNICATIONS), 5, 3);

/* ----------------------------------------------------------- */
	
	/*
	 * EndpointVolume Polling time
	 */
	timer = new QTimer();
	connect(timer, &QTimer::timeout, [this, eph](){
		//if (memcmp(osh->callbackInfo[idx]->caller, osh->getGuid(), sizeof(NGuid)) == 0) return; CHECK IF THIS PROGRAM GENERATED THE FUNSIES IS NO LONGER IN USE FOR NOW.
		const float roundingFactor = 0.005;
		mainSlider->blockSignals(true);
		muteButton->blockSignals(true);
		mainSlider->setValue((int)((eph->getCallbackInfo()->mainVolume + roundingFactor) * 100));
		muteButton->setCheckState((eph->getCallbackInfo()->muted == false ? Qt::Unchecked : Qt::Checked));
		muteButton->setText(eph->getCallbackInfo()->muted ? STRING_UNMUTE : STRING_MUTE);
		for(uint32_t i = 0; i < eph->getCallbackInfo()->channels; i++){
			this->channelSliders.at(i)->blockSignals(true);
			this->channelSliders.at(i)->setValue((int)((eph->getCallbackInfo()->channelVolumes[i] + roundingFactor) * 100));
			this->channelLabels.at(i)->setText(QString::number((int)((eph->getCallbackInfo()->channelVolumes[i] + roundingFactor) * 100)));
			this->channelSliders.at(i)->blockSignals(false);
		}
		//memcpy(osh->callbackInfo[idx]->caller, osh->getGuid(), sizeof(NGuid));

		//TODO: el default = objcopy frees?
		eph->getCallbackInfo()->caller = osh->getGuid();
		mainSlider->blockSignals(false);
		muteButton->blockSignals(false);
	});
	timer->start(10);
	
	//todo parent?
	layout->addItem(new QSpacerItem(1, 1, QSizePolicy::Minimum, QSizePolicy::Minimum), 1, 0);
	layout->addItem(new QSpacerItem(1, 1, QSizePolicy::Minimum, QSizePolicy::Minimum), 4, 0);
	layout->addItem(new QSpacerItem(1, 1, QSizePolicy::Minimum, QSizePolicy::MinimumExpanding), 6, 0);
	layout->addItem(new QSpacerItem(1, 1, QSizePolicy::Minimum, QSizePolicy::MinimumExpanding), 6, 1);
	log_debugcpp("ENDPOINT_WIDGETED");
}

void MainWindow::customEvent(QEvent* ev) {
	if (ev->type() == (QEvent::Type)CustomQEvent::EndpointWidgetObsolete) {
		this->removeEndpointWidget((EndpointWidgetEvent*)ev);
		return;		
	} 
	// Make sure the rest of events are handled
	return QMainWindow::customEvent(ev);
}

void MainWindow::removeEndpointWidget(EndpointWidgetEvent* ev){
	uint64_t i = ev->idx; 
	this->ews.at(i)->setParent(nullptr);
	this->layout->removeWidget(ews.at(i));
	uint64_t saisu = ews.size();
	//delete ews.at(index);
	while ((i + 1) < ews.size()) {
		ews.at(i) = ews.at(i + 1);
		ews.at(i)->updateEndpointHandlerFrontInfo(i);
		i++;
	}
	ews.pop_back();
	return;		
}


void EndpointWidget::updateMute(int checked){
	bool muted = (checked == 2 ? true : false);
	this->eph->setMute(osh->getGuid(), muted);
	this->muteButton->setText(this->eph->getMute() ? STRING_UNMUTE : STRING_MUTE); 
}

void EndpointWidget::updateMainVolume(int newValue){
	this->eph->setVolume(osh->getGuid(), AudioChannel::CHANNEL_MAIN, newValue);
}

/*
 * void EndpointWidget::updateVolume(uint32_t channel, float newValue){
 * 	//this->blockSignals(true);
 * 	int newVal = newValue * 100;
 * 	if (channel == (uint32_t)AudioChannel::CHANNEL_MAIN) {
 * 		//TIP: Above
 * 		//this->mainSlider->blockSignals(true);
 * 	
 * 		if(this->mainSlider->value() != newVal) {
 * 			this->mainSlider->blockSignals(true);
 * 			this->mainSlider->setValue(newVal);
 * 			this->mainSlider->blockSignals(false);
 * 		}
 * 		return;
 * 	}
 * 
 * 	for (size_t i = 0; i < sizeof(uint32_t) * 8 && i < channelSliders.size(); ++i) {
 * 		if (((channel >> i) & 1) && this->channelSliders.at(i)->value() != newVal) {
 * 			//this->channelSliders.at(i)->blockSignals(true);
 * 			
 * 			this->channelSliders.at(i)->setValue(newVal);
 * 			this->channelLabels.at(i)->setText(QString::number((int)(newValue * 100)));
 * 			
 * 			//this->channelSliders.at(i)->blockSignals(false);
 * 		}
 * 	}
 * 
 * 	//this->blockSignals(false);
 * }
 */

EndpointHandler* EndpointWidget::getEndpointHandler(){
	return this->eph;
}

void EndpointWidget::updateEndpointHandlerFrontInfo(uint64_t index){
	this->eph->setFrontVisibilityInfo(EndpointState::ENDPOINT_ACTIVE, index);	
}


void EndpointWidget::setIndex(uint64_t idx){
	this->idx = idx;
}

uint64_t EndpointWidget::getIndex(){
	return idx;
}

MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent)  {
	// setWindowState(Qt::WindowFullScreen);
	//	setCentralWidget(centralWidget);

	/*
	 * Registering needed custom events
	 */
	QEvent::registerEventType(CustomQEvent::EndpointWidgetObsolete);
	
	widget = new QWidget();
	layout = new QGridLayout();
	trayIcon = new QSystemTrayIcon();
    trayIconMenu = new QMenu();
	trayIconMenuQuit = new QAction(STRING_QUIT);
	
	changeDefaultCheckboxEnablement = new QEvent(QEvent::User);
	changeDefaultCheckboxEnablement->setAccepted(true);
	
	widget->setLayout(layout);
	setCentralWidget(widget);
	//layout->addWidget(pintas, 0, 0);
	setWindowTitle(STRING_TITLE);
	
	reloadEndpointWidgets();

	/*
	 * Tray Icon code
	 */
	trayIconMenu->addSeparator();
    trayIconMenu->addAction(trayIconMenuQuit);
	connect(trayIconMenuQuit, &QAction::triggered, qApp, &QCoreApplication::quit);
	trayIcon->setIcon(QIcon(":/assets/notificationAreaIcon.png"));
	setWindowIcon(QIcon(":/assets/notificationAreaIcon.png"));
	//TODO: Extend qsystemtrayicon to change mouse click?
	//show before setting tooltip required; smells like bug to me!
	trayIcon->show();
	trayIcon->setToolTip(STRING_TITLE);
	trayIcon->setContextMenu(trayIconMenu);
	connect(trayIcon, &QSystemTrayIcon::activated, this, &MainWindow::trayIconActivated);
	
	/*
	 * Set of function callback definitons for EndpointSituationCallback
	 */
	osh->setChangeFrontDefaultsFunction([this](Roles role, std::wstring endpointId) {
		for (auto epw : this->ews) {
			/*
			 * Is this the new default endpoint?
			 */
		 	if (epw->getEndpointHandler()->getId() == endpointId) {
				//not necessary to keep endpointState flags up to date right now, but updating it will allow for later config files / profiles
				epw->defaultRolesCheckBoxes.at(role)->blockSignals(true);
				epw->getEndpointHandler()->assignRoles(role);
				epw->defaultRolesCheckBoxes.at(role)->blockSignals(false);				
				QCoreApplication::instance()->postEvent(epw->defaultRolesCheckBoxes.at(role), changeDefaultCheckboxEnablement);
				//epw->defaultRolesCheckBoxes.at(role)->postEnableChange();
				/*
				 * And were you THE default?
				 */
				if (epw->getEndpointHandler()->getRoles() == Roles::ROLE_ALL) {
					QCoreApplication::instance()->postEvent(epw->defaultRolesCheckBoxes.at(Roles::ROLE_ALL), changeDefaultCheckboxEnablement);
				}
			  /*
			   * Are you the dethroned king?
			   */
			} else if (epw->getEndpointHandler()->getRoles() & role) {
				    /*
					 * And were you THE default up until now?
					 */
					if (epw->getEndpointHandler()->getRoles() == Roles::ROLE_ALL) {
						QCoreApplication::instance()->postEvent(epw->defaultRolesCheckBoxes.at(Roles::ROLE_ALL), changeDefaultCheckboxEnablement);
					}
					
					epw->defaultRolesCheckBoxes.at(role)->blockSignals(true);
					//Same as before. ini-san will come...
					epw->getEndpointHandler()->removeRoles(role);
					epw->defaultRolesCheckBoxes.at(role)->blockSignals(false);
					QCoreApplication::instance()->postEvent(epw->defaultRolesCheckBoxes.at(role), changeDefaultCheckboxEnablement);
					
				}
			}
		});

	osh->setRemoveEndpointWidgetFunction([this](uint64_t index) {
		EndpointWidgetEvent removeObsoleteEndpointWidget((QEvent::Type)CustomQEvent::EndpointWidgetObsolete, index);
		removeObsoleteEndpointWidget.setAccepted(true);
		QCoreApplication::instance()->postEvent(this, &removeObsoleteEndpointWidget);
	});

	/*
	 * osh->setReviseEndpointShowingFunction([this](std::wstring endpointId, Roles role){
	 * 	
	 * 	
	 * });
	 */

}


void MainWindow::closeEvent(QCloseEvent *event) {
	if (!event->spontaneous() || !isVisible()) return;
	
	if (trayIcon->isVisible()) {
		//todo: would be nice to show this to 1st time users; ini-san will come...
		//this->trayIcon->showMessage("ini file calling","tratarte como un gilipollas la primera vez", QSystemTrayIcon::Information);
	
	 hide();
	 event->ignore();
	}
}

void MainWindow::trayIconActivated(QSystemTrayIcon::ActivationReason reason) {
	switch (reason) {
	case QSystemTrayIcon::Trigger:
		this->showNormal();
		break;
	default:
        break;
    }
}

void MainWindow::reloadEndpointWidgets() {
	size_t i = 0;
	for (size_t epwIndex = 0; i < (osh->getEndpointHandlers().size()); i++) {
		if (osh->getEndpointHandlers().at(i)->getState() == EndpointState::ENDPOINT_ACTIVE){
			log_debugcpp("EPWidget creation");
			osh->getEndpointHandlers().at(i)->getCallbackInfo()->caller = osh->getGuid();
			EndpointWidget *epw = new EndpointWidget(epwIndex, osh->getEndpointHandlers().at(i), widget);
			epwIndex++;
			//alfinal estoes solopara inicializarlmao
			ews.push_back(epw);
			layout->addWidget(epw, i, 0);
		}
	}
	//todo:: tas aqui tirao, no me gustas y probablemente yo a ti tampoco
	layout->addItem(new QSpacerItem(1, 1, QSizePolicy::Minimum, QSizePolicy::MinimumExpanding), i, 0);
}