#include <vector>
using namespace std;

// Estrutura para descrever o estado de uma chave
struct KeyState {
	int key_number;		// Número da chave
	bool state;			// Estado da chave
	int when;			// Horário em que a chave mudou de estado (em milissegundos)
};


// Funções Externas. Precisam ser implementadas em outros arquivos.
extern bool OpenConnection(void);		// Abre a conexão (retorna false se falhar)
extern void CloseConnection(void);		// Fecha a conexão
extern bool ReadKey(int key);			// Lê o estado da tecla "key"
extern void Init(void);					// Inicia o hardware (interrup, timer, etc).
extern void SendKeyState(KeyState *e);	// Envia o estado de uma tecla pelo canal


// Período das interrupções do temporizador (10 ms)
const int c_clock_tick_period = 10;

// Contador global de tempo. Incrementado de 'c_clock_tick_period'
// após cada interrupção
volatile int time_counter = 0;

// Flag do temporizador.
// A rotina da interrupção passa este flag para 'true'. O laço principal
// (função main) retorna este flag para 'false'
volatile bool clock_tick = false;


// Este vetor é a fila de mensagens que aguardam para serem transmitidas
// pelo canal de comunicação.
vector<KeyState> MessageQueue;


//------------------------------------------------------------------------
// Função DebounceKeys
//   Periodicamente lê o estado das teclas. Se uma tecla mudar de estado
//   e permanecer neste estado por 20 ms, insere uma mensagem no
//   pipe "MessageQueue".
//------------------------------------------------------------------------
void DebounceKeys(void)
{
	const int c_number_of_keys = 3;

	// Período de leitura das chaves (20ms)
	const int c_debounce_period  = 20;

	// Temporizador de leitura das chaves. As chaves são lidas quando este
	// valor chegar a zero.
	static int debounce_timer = c_debounce_period;

	// Registrador de debounce. Cada elemento do vetor representa uma chave.
	// Os 4 bits menos significativos de cada elemento armazenam as 4 últimas
	// leituras das chaves.
	static int key_status[c_number_of_keys];
	static bool init = true;
	if (init == true) {
		memset( key_status, 0, sizeof(key_status) );
		init = false;
	}

	// Contando o tempo para verificar as teclas
	debounce_timer -= c_clock_tick_period;

	// Está na hora de verificar as teclas? (1 vez a cada 20 ms)
	if ( debounce_timer <= 0) {

		// Reinicia o contador para a próxima verificação
		debounce_timer = c_debounce_period;

		// Verifica cada uma das teclas
		for (int i=0; i<c_number_of_keys; i++) {

			// Lê a tecla
			bool key = ReadKey(i);
			key_status[i] |= key;

			// Verifica se a tecla mudou de estado e se o novo
			// estado já estabilizou (key_status[i] contém "0011" ou "1100").
			if ( (key_status[i] == 0x3) ||
				 (key_status[i] == 0xC) ) {

				// Insere a tecla na fila de transmissão
				KeyState e;
				e.key_number = i;
				e.state = key;
				e.when = time_counter;
				MessageQueue.push_back(e);
			}

			// Deixa o registrador preparado para receber a próxima amostra
			key_status[i] <<= 1;
			key_status[i] &= 0xF;
		}
	}
}



//------------------------------------------------------------------------
// Função CommChannel
//   Controla o canal de comunicação e envia as mensagens de estado das
//   teclas a medida que são recebidas da thread DebounceKeys.
//------------------------------------------------------------------------
void CommChannel(void)
{
	// Tempo entre tentativas de conexão (2 minutos)
	const int c_connect_retry = 2 * 60 * 1000;

	// Tempo máximo que a conexão fica ociosa (3 minutos)
	const int c_connect_max_idle = 3 * 60 * 1000;

	// Temporizador para controle da conexão
	static int connection_timer = 0;

	// Estado da conexão
	enum eConnectionStatus { not_connected, trying, connected, waiting_try_again };
	static eConnectionStatus m_constatus = not_connected;


	// Máquina de estados da conexão.
	switch (m_constatus) {
		case not_connected:
			// Permanece sem conexão enquanto não houver mensagem para transmitir
			if (MessageQueue.empty() == false) {
				m_constatus = trying;
			}
			break;

		case trying:
			// Tenta abrir uma conexão
			if (OpenConnection() == true) {
				m_constatus = connected;
			} else {
				// Não conseguiu conectar. Aguarda para tentar novamente
				connection_timer = c_connect_retry;
				m_constatus = waiting_try_again;
			}
			break;

		case connected:
			// Conexão estabelecida
			if (MessageQueue.size() != 0) {
				// Envia as mensagens que estão aguardando na fila
				for (unsigned int i=0; i<MessageQueue.size(); i++) {
					KeyState e = MessageQueue[i];
					SendKeyState(&e);
				}
				MessageQueue.clear();

				// Transmitiu todas as mensagens. Aguardando para
				// desconectar se nenhuma mensagem nova for recebida
				connection_timer = c_connect_max_idle;
			} else {
				// Não há mensagens para enviar.
				// Contando o tempo da conexão ociosa.
				connection_timer -= c_clock_tick_period;
			}

			if ( connection_timer <= 0 ) {
				// Conexão passou muito tempo ociosa.
				CloseConnection();
				m_constatus = not_connected;
			}
			break;

		case waiting_try_again:
			// Não conseguiu conectar. Contando o tempo para tentar novamente
			connection_timer -= c_clock_tick_period;
			if (connection_timer <= 0) {
				// Inicia uma nova tentativa de conexão
				m_constatus = trying;
			}
			break;

	}
}


//------------------------------------------------------------------------
// main
//   Laço principal do programa.
//------------------------------------------------------------------------
int main (void)
{
	Init();			// Inicia o hardware

	// Laço principal
	while (1) {

		// Aguarda uma interrupção do temporizador
		while (clock_tick == false);

		// Incrementa o temporizador global
		time_counter += c_clock_tick_period;

		// Dá a cada tarefa uma chance de executar
		DebounceKeys();
		CommChannel();

		// Desliga o indicador e retorna ao início do loop
		// para aguardar a próxima interrupção
		clock_tick = false;
	}
}