#include "backlasses.h"
#include "qtclasses.h"
#include "contclasses.h"
//TODO: pragma once

//TODO: ?????
Overseer OverseerHandler::os;

EndpointHandler::EndpointHandler(uint64_t idx) {
	std::vector<Endpoint*> endpoints = osh->getPlaybackEndpoints();
	this->ep = endpoints.at(idx);
	epc = new EndpointCallback(ep);
	//epName = ep->getName();
	ep->setCallback(epc);
}

uint32_t EndpointHandler::getChannelCount(){
	return ep->getChannelCount();
}

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

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


/*
 * -1 for master volume
 */
void EndpointHandler::setVolume(NGuid* guid, int channel, int value){
	if (channel == ENDPOINT_MASTER_VOLUME)
		ep->setVolume(guid, channel, (float)value / 100);
	else ep->setVolume(guid, channel, (float)value / 100);
}

void EndpointHandler::setMute(NGuid* guid, bool muted){
	//Qt momento, de ahi el param?
	log_debugcpp("kinda handling the muting tbh");
	ep->setMute(guid, muted);
}

std::wstring EndpointHandler::getName(){
	return ep->getName();
}

float EndpointHandler::getVolume(int channel){
    return ep->getVolume(channel);
}

bool EndpointHandler::getMute(){
    return ep->getMute();
}

EndpointHandler::~EndpointHandler() {
	ep->removeCallback(epc);
	epc->Release();
	delete ep;
}

std::vector<Endpoint*> OverseerHandler::getPlaybackEndpoints() {
	return this->os.getPlaybackEndpoints();
}

/*
 * Overseer* OverseerHandler::getOverseer(){
 * 	return &os;
 * }
 */


std::vector<EndpointHandler*> OverseerHandler::getEndpointHandlers(){
	return endpointHandlers;
}

uint64_t OverseerHandler::getPlaybackEndpointsCount(){
	return this->os.getPlaybackEndpoints().size();
}

void OverseerHandler::reloadEndpointHandlers(){
	//std::vector<EndpointHandler*>* ephs = new std::vector<EndpointHandler*>;
	log_debugcpp(" VSize: " << this->getPlaybackEndpointsCount());
	
	for(uint64_t i = 0; i < this->getPlaybackEndpointsCount(); i++){
		log_debugcpp("Creating handler " << i);
		
		if(i < (this->endpointHandlers.size()) && 
		   this->endpointHandlers.at(i) != nullptr)
			delete endpointHandlers.at(i);
		
		EndpointHandler* eph = new EndpointHandler(i);
		log_debugcpp("Created handler " << i << ", adding to vector. " << " VSize: " << this->getPlaybackEndpointsCount());
		
		if (i >= this->endpointHandlers.size())
			endpointHandlers.push_back(eph);
		else endpointHandlers.at(i) = eph;
	}
	//setEndpointHandlers(ephs);
}


NGuid* OverseerHandler::getGuid() {
	return this->os.getGuid();
}

void OverseerHandler::setEndpointHandlers(std::vector<EndpointHandler*> ephs){
	this->endpointHandlers = ephs;
}


void OverseerHandler::setEndpointWidgets(std::vector<EndpointWidget*> ews){
	this->endpointWidgets = ews;
}

void OverseerHandler::updateMuteCallback(uint64_t idx, bool muted){
	epwMuteFunc f = &EndpointWidget::updateMute;
	std::invoke(f, endpointWidgets.at(idx), muted);
}

void OverseerHandler::updateMainVolumeCallback(uint64_t idx, float newVal){
	//int translatedNewVal = newVal * 100;
	log_debugcpp("mainvolcallback float: " << newVal);
	epwMainVolumeFunc f = &EndpointWidget::updateMainVolume;
	std::invoke(f, endpointWidgets.at(idx), newVal);
}