#include "backlasses.h"
#include "contclasses.h"

void setConfigDirToDefaults() {    
    #define tryFileDir(dir, create) do {             \
		OverseerHandler::settingsPath = Environment::createSettingsPath(dir, create); \
        set = ini::UserSettings::createSettings(OverseerHandler::settingsPath.c_str(), create); \
        if(set) { \ 
            return;                                        \
		} else OverseerHandler::settingsPath.clear();			   \
    } while(0)
    #define tryOpenFileDir(dir) tryFileDir(dir, false)      
    #define tryCreateFileDir(dir) tryFileDir(dir, true)
    
    tryOpenFileDir(SettingsTargetDirectory::APP_PATH);  
    tryOpenFileDir(SettingsTargetDirectory::HOME_DIR);  
    tryCreateFileDir(SettingsTargetDirectory::HOME_DIR);  
    tryCreateFileDir(SettingsTargetDirectory::APP_PATH);  
    
	return;
	#undef tryOpenFileDir
	#undef tryCreateFileDir
	#undef tryFileDir
}

EndpointHandler::EndpointHandler(uint64_t idx, Flows flow) {
	//std::vector<Endpoint*> endpoints = osh->getPlaybackEndpoints().at(idx);
	this->idx = idx;
	this->flow = flow;
	this->ep = (flow == Flows::FLOW_PLAYBACK ? osh->getPlaybackEndpoints().at(idx) : osh->getCaptureEndpoints().at(idx));
		
	epc = new EndpointVolumeCallback(ep);
	this->callbackInfo.caller = osh->getGuid();
	//epName = ep->getName();
	this->setBackEndpointVolumeCallbackInfoContent(this->getState()); 
	osh->pushBackEndpointHandler(this, flow);
}

void OverseerHandler::pushBackEndpointHandler(EndpointHandler* eph, Flows flow) {
	if (eph == nullptr) return;
	if (flow == Flows::FLOW_PLAYBACK)
		this->playbackEndpointHandlers.push_back(eph);
	else
		this->captureEndpointHandlers.push_back(eph);
	return;
}

void EndpointHandler::setFrontVisibilityInfo(EndpointState state, uint64_t frontIdx){
	ephfv.visibility = state;
	ephfv.frontIdx = frontIdx;
}

uint64_t EndpointHandler::getFrontVisibilityIndex(){
	return ephfv.frontIdx;
}

EndpointState EndpointHandler::getFrontVisibilityState(){
	return ephfv.visibility;
}

Flows EndpointHandler::getFlow(){
	return ep->getFlow();
}

/* 	these two, currently unused. If I use them, I should feel bad.
 * Endpoint* EndpointHandler::getEndpoint() {
 * 	return this->ep;
 * }
 * 
 * EndpointVolumeCallback* EndpointHandler::getEndpointVolumeCallback() {
 * 	return this->epc;
 * }
 */

BackEndpointVolumeCallbackInfo* EndpointHandler::getCallbackInfo(){
	return &this->callbackInfo;
}

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 == AudioChannel::CHANNEL_MAIN)
		ep->setVolume(guid, channel, (float)value / 100);
	else ep->setVolume(guid, channel, (float)value / 100);
}

void EndpointHandler::setMute(NGuid guid, bool muted){
	ep->setMute(guid, muted);
}

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

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

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

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

size_t EndpointHandler::getState(){
	return ep->getState();
}

void EndpointHandler::setBackEndpointVolumeCallbackInfoContent(uint8_t state) {
	if(state == EndpointState::ENDPOINT_ACTIVE) {
		callbackInfo.muted = this->getMute();
		callbackInfo.mainVolume = this->getVolume(AudioChannel::CHANNEL_MAIN);
		callbackInfo.channels = this->getChannelCount();
		ep->setVolumeCallback(epc);
		callbackInfo.channelVolumes.resize(this->callbackInfo.channels);
		for(uint32_t i = 0; i < this->getChannelCount(); i++){
			callbackInfo.channelVolumes.at(i) = this->getVolume(i);
		}
	}
}	

void EndpointHandler::setState(uint8_t state){
	ep->setState(state);
	this->setBackEndpointVolumeCallbackInfoContent(state);
}

void EndpointHandler::setState(uint8_t state, uint64_t index){
	ep->setState(state);
	this->setFrontVisibilityInfo((EndpointState)state, index);	
	this->setBackEndpointVolumeCallbackInfoContent(state);
}

float EndpointHandler::getPeakVolume() {
	return ep->getPeakVolume();
}

uint8_t EndpointHandler::getRoles(){
	return ep->getRoles();
}

void EndpointHandler::setRoles(Roles newRole){
	ep->setRoles(newRole);
}

void EndpointHandler::assignRoles(Roles newRole){
	ep->assignRoles(newRole);
}

void EndpointHandler::removeRoles(Roles newRole){
	ep->removeRoles(newRole);
}

void EndpointHandler::setAddSessionWidgetFunction(std::function<void(SessionHandler*)> addSessionWidget) {
	this->addSessionWidget = addSessionWidget;
}

void EndpointHandler::setRemoveSessionWidgetFunction(std::function<void(SessionHandler*)> removeSessionWidget) {
	this->removeSessionWidget = removeSessionWidget;
}

/*  sessions  */
size_t EndpointHandler::getSessionCount() {
	return ep->getSessionCount();
}

std::vector<Session*> EndpointHandler::getSessions(){
	return ep->getSessions();
}

std::vector<SessionHandler*> EndpointHandler::getSessionHandlers(){
	return this->sessionHandlers;
}

Endpoint* EndpointHandler::getEndpoint() {
	return this->ep;
}

void EndpointHandler::addSessionSendFront(Session* session) {
	ep->addSession(session);

  	SessionHandler* sessionHandler = new SessionHandler(this, session, (getSessionCount() - 1));
	sessionHandlers.push_back(sessionHandler);
	this->addSessionWidget(sessionHandler);
}

void EndpointHandler::sendSessionToFront(SessionHandler* sh) {
	this->addSessionWidget(sh);
}

void EndpointHandler::removeSessionFromFront(SessionHandler* sh) {
	this->removeSessionWidget(sh);
}

void EndpointHandler::deleteSessions() {
	ep->unregisterNewSessionNotification(ensc);
	ensc->Release();
	for (auto sh : sessionHandlers) {
		delete sh;
	}
	sessionHandlers.resize(0);
	ep->deleteSessions();
}

void EndpointHandler::createSessionHandlers() {
	ep->activateEndpointSessions();
	ensc = new EndpointNewSessionCallback(this);
	ep->registerNewSessionNotification(ensc);
	if (this->flow == Flows::FLOW_PLAYBACK) {
	 	for (int i = 0; i < this->getSessionCount(); i++) {
	  		SessionHandler* sessionHandler = new SessionHandler(this, this->getSessions().at(i),i);
			sessionHandlers.push_back(sessionHandler);
	  	}
	} 
}

EndpointHandler::~EndpointHandler() {
	ep->removeVolumeCallback(epc);
	ep->unregisterNewSessionNotification(ensc);
	epc->Release();
	delete ep;
}

OverseerHandler::OverseerHandler() {
	this->os = new Overseer();
}

void OverseerHandler::setSettingsPath(std::string path) {
	OverseerHandler::settingsPath = path;
}

std::string OverseerHandler::getSettingsPath(){
	return OverseerHandler::settingsPath;
}

void OverseerHandler::updateStartupConfig(bool onStartup) {
	Environment::updateStartupConfig(onStartup);
}

void OverseerHandler::setStartupConfig(bool onStartup) {
	Environment::setStartupConfig(onStartup);
}

void OverseerHandler::populateSystemValues() {
	Environment::populateSystemValues();
}

void OverseerHandler::openControlPanel() {
	Environment::openControlPanel();
}

ProcessedNativeEvent OverseerHandler::processTopLevelWindowMessage(void* msg) {
	return Environment::processTopLevelWindowMessage(msg);
}

bool OverseerHandler::isLightMode() {
	return Environment::isLightMode();
}

bool OverseerHandler::isToRunAtStartup() {
	return Environment::isToRunAtStartup();
}

uint32_t OverseerHandler::getAccentColor() {
	return Environment::getAccentColor();
}

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

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

std::vector<EndpointHandler*> OverseerHandler::getPlaybackEndpointHandlers(){
	return playbackEndpointHandlers;
}

std::vector<EndpointHandler*> OverseerHandler::getCaptureEndpointHandlers(){
	return captureEndpointHandlers;
}

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

uint64_t OverseerHandler::getCaptureEndpointsCount(){
	return this->os->getCaptureEndpoints().size();
}

void OverseerHandler::reloadEndpointHandlers(){
	//todo: add capture
	
	//std::vector<EndpointHandler*>* ephs = new std::vector<EndpointHandler*>;
	log_debugcpp("Playback VSize: " + std::to_string(this->getPlaybackEndpointsCount()));
	
	for(uint64_t i = 0; i < this->getPlaybackEndpointsCount(); i++){
		log_debugcpp("Creating Playback handler " + std::to_string(i));
				
		EndpointHandler* ephexx = new EndpointHandler(i, Flows::FLOW_PLAYBACK);
		//this->playbackEndpointHandlers.push_back(ephexx);
		log_debugcpp("Created Playback  handler " + std::to_string(i) + ", adding to vector. " + " VSize: " + std::to_string(this->playbackEndpointHandlers.size()));
		
	}

	log_debugcpp("Capture VSize: " +
				 std::to_string(this->getCaptureEndpointsCount()));
	
	for(uint64_t i = 0; i < this->getCaptureEndpointsCount(); i++){
		log_debugcpp("Creating Capture handler " + std::to_string(i));
		
		/*
		 * if(i < (this->captureEndpointHandlers.size()) && 
		 *    this->captureEndpointHandlers.at(i) != nullptr)
		 * 	delete captureEndpointHandlers.at(i);
		 */
		
		EndpointHandler* ephoo = new EndpointHandler(i, Flows::FLOW_CAPTURE);		
		//this->captureEndpointHandlers.push_back(ephoo);
		log_debugcpp("Created Capture handler " + std::to_string(i) + ", adding to vector. " + " VSize: " + std::to_string(this->captureEndpointHandlers.size()));

		/*
		 * if (i >= this->captureEndpointHandlers.size())
		 * 	captureEndpointHandlers.push_back(eph);
		 * else captureEndpointHandlers.at(i) = eph;
		 */
	}
	//setEndpointHandlers(ephs);
}

EndpointHandler* OverseerHandler::addEndpoint(std::wstring endpointId, /* out */ Flows *flow = nullptr){
	Flows localFlow;
	Endpoint* newEp = this->os->addEndpoint(endpointId, &localFlow);

	uint64_t ephIdx = (localFlow == Flows::FLOW_PLAYBACK ? this->getPlaybackEndpointsCount() : this->getCaptureEndpointsCount()) - 1;

	EndpointHandler* newEph = new EndpointHandler(ephIdx, localFlow);
	//	std::vector<EndpointHandler*> getPlaybackEndpointHandlers();
	//std::vector<EndpointHandler*> getCaptureEndpointHandlers();
	if (flow != nullptr) *flow = localFlow;
	return newEph;
}

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

/*
 * void OverseerHandler::setChangeFrontDefaultsFunction(std::function<void(Roles, std::wstring)> changeFrontDefaults){
 * 	this->changeFrontDefaults = changeFrontDefaults;
 * }
 * 
 * void OverseerHandler::changeFrontDefaultsCallback(Roles role, std::wstring endpointId) {
 * 	this->changeFrontDefaults(role, endpointId);
 * }
 */

void OverseerHandler::roleBucketEntryCallback(Roles role, std::wstring endpointId){
	this->roleBucketEntry(role, endpointId);
}

void OverseerHandler::setRoleBucketEntryFunction(std::function<void(Roles, std::wstring)> roleBucketEntry) {
	this->roleBucketEntry = roleBucketEntry;
}

void OverseerHandler::updateFrontEndpointName(Endpoint* ep) {
	//todo: reintroduce capture devices
	for (auto eph : playbackEndpointHandlers) {
		if (eph->getEndpoint() == ep) eph->getCallbackInfo()->updateName = true;
	}
}

void OverseerHandler::reviseEndpointShowing(std::wstring endpointId, EndpointState state) {
	std::vector<EndpointHandler*> allHandlers;
	allHandlers.insert(allHandlers.end(), this->captureEndpointHandlers.begin(), this->captureEndpointHandlers.end());
	allHandlers.insert(allHandlers.end(), this->playbackEndpointHandlers.begin(), this->playbackEndpointHandlers.end());
	EndpointHandler* eph = nullptr;
	for (auto loopEph : allHandlers) {
		if (loopEph->getId() == endpointId) {
			eph = loopEph;
			break;
		}
	}

	//debug
	Flows flow; 
	if (!eph) {
		if (state ^ EndpointState::ENDPOINT_ACTIVE) return;
		//flow = Flows::FLOW_CAPTURE;
		eph = osh->addEndpoint(endpointId, &flow);
	} else
		flow = eph->getFlow();

	//todo: mic done but disabled. Tab-kun will come...
	if (flow == Flows::FLOW_CAPTURE) return;

	if(eph && EndpointState::ENDPOINT_ACTIVE & state) {
		this->addEndpointWidget(eph);
	} else if (eph && eph->getFrontVisibilityState() == EndpointState::ENDPOINT_ACTIVE){
		this->removeEndpointWidget(eph->getFrontVisibilityIndex());
	}
	return;
}

void OverseerHandler::setAddEndpointWidgetFunction(std::function<void(EndpointHandler*)> addEndpointWidget){
	this->addEndpointWidget = addEndpointWidget;
}

void OverseerHandler::setRemoveEndpointWidgetFunction(std::function<void(uint64_t)> removeEndpointWidget){
	this->removeEndpointWidget = removeEndpointWidget;
}

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