#include "Channel.h"
#include <stdio.h>

#define MAX_BUFFER_LENGTH 100

void Channel :: init_channel() {
	maxBufferLength = MAX_BUFFER_LENGTH;
	transferRate = MAX_BUFFER_LENGTH;
}

Channel :: Channel() {
	init_channel();
}

Channel :: Channel(const char* name) {
	set_name(name);
	init_channel();
}

bool Channel :: set_maxBufferLength(unsigned int maxBufferLength) {
	if(maxBufferLength <= MAX_BUFFER_LENGTH) {
		this->maxBufferLength = maxBufferLength;
		return true;
	}
	return false;
}

unsigned int Channel :: get_maxBufferLength() {
	return maxBufferLength;
}

unsigned int Channel :: get_avlInputBufferUp() {
	return maxBufferLength-lInputMsgBufferUp.size();
}

unsigned int Channel :: get_avlOutputBufferUp() {
	return maxBufferLength-lOutputMsgBufferUp.size();
}

unsigned int Channel :: get_avlInputBufferDown() {
	return maxBufferLength-lInputMsgBufferDown.size();
}

unsigned int Channel :: get_avlOutputBufferDown() {
	return maxBufferLength-lOutputMsgBufferDown.size();
}

bool Channel :: set_transferRate(unsigned int transferRate) {
	if(transferRate <= MAX_BUFFER_LENGTH) {
		this->transferRate = transferRate;
		return true;
	}
	return false;
}

unsigned int Channel :: get_transferRate() {
	return transferRate;
}



bool Channel :: add_msgAtBegin (list<Message*>* buffer, Message* message) {
	try {
		buffer->push_front(message);
	}
	catch(bad_alloc& error) {
		delete message;
		return false;
	}
	return true;
}

bool Channel :: del_msgAtBegin (list<Message*>* buffer) {
	try {
		buffer->pop_front();
	}
	catch(bad_alloc& error) {
		return false;
	}
	return true;
}

bool Channel :: add_msgAtEnd (list<Message*>* buffer, Message* message) {
	try {
		buffer->push_back(message);
	}
	catch(bad_alloc& error) {
		delete message;
		return false;
	}
	return true;
}

bool del_msgAtEnd (list<Message*>* buffer) {
	try {
		buffer->pop_back();
	}
	catch(bad_alloc& error) {
		return false;
	}
	return true;
}

bool Channel :: send_MsgUp(Message* message) {
	if(message != NULL) {
		if(transferRate == 0) {
			//TODO: at the moment only one packet (in the front) gets deleted if buffer is full. However, the whole message (instruction+value) should be deleted in case of a full buffer
			if(lOutputMsgBufferUp.size() == maxBufferLength) {
				del_msgAtBegin(&lOutputMsgBufferUp);
			}
			return add_msgAtEnd(&lOutputMsgBufferUp, message);
		}
		else {
			if(lInputMsgBufferUp.size() == maxBufferLength) { 
				//TODO: at the moment only one packet (in the front) gets deleted if buffer is full. However, the whole message (instruction+value) should be deleted in case of a full buffer
				del_msgAtBegin(&lInputMsgBufferUp);
			}
			return add_msgAtEnd(&lInputMsgBufferUp, message);
		}
	}
  // FIXME
  return false;
}

bool Channel :: send_MsgUp(float msg) {
	Message* message = new Message(msg);
	return send_MsgUp(message);
}

bool Channel :: send_MsgUp(int msg) {
	Message* message = new Message(msg);
	return send_MsgUp(message);
}

bool Channel :: get_MsgUp(float* msg) {
	if(isThereFloatMsgUp()) {
		float tempMsg;
		if(lOutputMsgBufferUp.front()->getMsg(&tempMsg)) {
			*msg = tempMsg;
			del_msgAtBegin(&lOutputMsgBufferUp);
			return true;
		}
	}
	return false;
}

bool Channel :: get_MsgUp(int* msg) {
	if(isThereIntMsgUp()) {
		int tempMsg;
		if(lOutputMsgBufferUp.front()->getMsg(&tempMsg)) {
			*msg = tempMsg;
			del_msgAtBegin(&lOutputMsgBufferUp);
			return true;
		}
	}
	return false;
}

bool Channel :: isThereFloatMsgUp() {
	if(lOutputMsgBufferUp.size() > 0 ) {
		if(lOutputMsgBufferUp.front() != NULL) {
			return lOutputMsgBufferUp.front()->isMsgFloat();
		}
	}
	return false;
}

bool Channel :: isThereIntMsgUp() {
	if(lOutputMsgBufferUp.size() > 0 ) {
		if(lOutputMsgBufferUp.front() != NULL) {
			return lOutputMsgBufferUp.front()->isMsgInt();
		}
	}
	return false;
}

bool Channel :: send_MsgDown(Message* message) {
	if(message != NULL) {
		if(transferRate == 0) {
			if(lOutputMsgBufferDown.size() == maxBufferLength) { 
				del_msgAtBegin(&lOutputMsgBufferDown);
			}
			return add_msgAtEnd(&lOutputMsgBufferDown, message);
		}
		else {
			if(lInputMsgBufferDown.size() == maxBufferLength) { 
				del_msgAtBegin(&lInputMsgBufferDown);
			}
			return add_msgAtEnd(&lInputMsgBufferDown, message);
		}
	}
  //FIXME
  return false;
}

bool Channel :: send_MsgDown(float msg) {
	Message* message = new Message(msg);
	return send_MsgDown(message);
}

bool Channel :: send_MsgDown(int msg) {
	Message* message = new Message(msg);
	return send_MsgDown(message);
}

bool Channel :: get_MsgDown(float* msg) {
	if(isThereFloatMsgDown()) {
		float tempMsg;
		if(lOutputMsgBufferDown.front()->getMsg(&tempMsg)) {
			*msg = tempMsg;
			del_msgAtBegin(&lOutputMsgBufferDown);
			return true;
		}
	}
	return false;
}

bool Channel :: get_MsgDown(int* msg) {
	if(isThereIntMsgDown()) {
		int tempMsg;
		if(lOutputMsgBufferDown.front()->getMsg(&tempMsg)) {
			*msg = tempMsg;
			del_msgAtBegin(&lOutputMsgBufferDown);
			return true;
		}
	}
	return false;
}

bool Channel :: isThereFloatMsgDown() {
	if(lOutputMsgBufferDown.size() > 0 ) {
		if(lOutputMsgBufferDown.front() != NULL) {
			return lOutputMsgBufferDown.front()->isMsgFloat();
		}
	}
	return false;
}

bool Channel :: isThereIntMsgDown() {
	if(lOutputMsgBufferDown.size() > 0 ) {
		if(lOutputMsgBufferDown.front() != NULL) {
			return lOutputMsgBufferDown.front()->isMsgInt();
		}
	}
	return false;
}

bool Channel :: transferMsgs(list<Message*>* dest_buffer, list<Message*>* src_buffer) {	
	unsigned int NumOfMsgsToMove;

	if(transferRate <= src_buffer->size()) {
		NumOfMsgsToMove = transferRate;
	}
	else {
		NumOfMsgsToMove = src_buffer->size();
	}

	if(NumOfMsgsToMove <= maxBufferLength-dest_buffer->size()) {
		for(unsigned int i=0; i<NumOfMsgsToMove; i++) {	
			if(add_msgAtEnd(dest_buffer, src_buffer->front())) {
				if(!del_msgAtBegin(src_buffer)) {
					return false;
				}
			}
			else {
				return false;
			}
		}
		return true;
	}
	return false;
}

bool Channel :: trigger() {
	bool flag_worked = transferMsgs(&lOutputMsgBufferUp, &lInputMsgBufferUp) && transferMsgs(&lOutputMsgBufferUp, &lInputMsgBufferUp);
	printf("Channel %s: in_up %zu, out_up %zu, in_dn %zu, out_dn %zu,\n", name, lInputMsgBufferUp.size(), lOutputMsgBufferUp.size(), lInputMsgBufferDown.size(), lOutputMsgBufferDown.size());
	return flag_worked;
}