#define _CRT_SECURE_NO_WARNINGS
#include <locale.h>
#include <stdio.h>
#include <windows.h>
#include <math.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <time.h>
# define NUM_COMPUTADORES 4

using namespace std;


/* Estrutura da data */
typedef struct data {
	int ano;
	int mes;
	int dia;
	int hora;
	int min;
	int segundo;
} DATA;

/* EStrutura dos utilizadores */
typedef struct utilizadores
{
	int codigoUtilizador;
	char nome[100];
	char morada[150];
	char contacto[10];
	char dataRegisto[20];
	char nomeUtilizador[15];
	char password[15];
	int tipoUser;
	int logado;
	int tempo_total_utilizacao;
	int total_dinheiro_gasto;
} Utilizadores;

/* Estrutura dos computadores */
typedef struct computadores
{
	char nome[100];
	int codigoComputador;
	int estado;
	int tempoUtilizacao;
	int total_faturado;
} Computadores;

/* Estrutura das sessões */
typedef struct sessoes
{
	int estado;
	int codComputador;
	int codUtilizador;
	char dataInicio;
	int minutosUtilizacao;
	double preco;
	int pagamento;
}Sessoes;


/* Prototipos das funções */

// Menus
char menu_principal(Utilizadores *p, data *h, computadores *c, int n, Sessoes *s); /* Menu principal */
void menu_login(Utilizadores *p, data *h, computadores *c, int n, Sessoes *s);                 /* Menu do LOGIN */
void menu_user(Utilizadores *p, data *h, computadores *c, int n, Sessoes *s);                  /* Menu principal do user */
void menu_user_computador(Utilizadores *p, data *h, computadores *c, int n, Sessoes *s);       /* Menu principal do user - computador */
void menu_admin(Utilizadores *p, data *h, computadores *c, int n, Sessoes *s);     /* Menu principal da ADMIN */
void menu_admin_users(Utilizadores *p, data *h, computadores *c, int n);           /* Menu principal da ADMIN - usuários */
void menu_admin_computadores(Utilizadores *p, data *h, computadores *c, int n, Sessoes *s);    /* Menu principal da ADMIN - computadores */

// Admin - User
void admin_editar_user(utilizadores *p, int n);                                               /* Admin editar user */
void admin_eliminar_user(utilizadores *p, int n);                       /* Admin eliminar user */
// Admin - Computador
void admin_adicionar_computador(computadores *c);                /* Admin adicionar computador */
void admin_editar_computador(computadores *c, int n);                                         /* Admin editar computador */
void admin_eliminar_computador(computadores *c, int n);                 /* Admin eliminar computador */

// User
void user_editar_dados(Utilizadores *p, int n);

// Computadores
void computadores_inicializa(Computadores *c, int n);                   /* Inicializa computadores */
void computadores_lista(Computadores *c, int n);                        /* Mostra a lista de computadores */

// Utilizadores
void utilizadores_inicializa(Utilizadores *p, int n);                   /* Inicializa os utilizadores*/
void utilizadores_introduzir(Utilizadores *p, data*h, int n);           /* Introduz um novo utilizador */                       // Criar verificações (Repitição de user e outros)
void utilizadores_listar_tabela(Utilizadores *p, data *h, int n);       /* Mostra a lista dos utilizadores com tabela */
void utilizadores_listar_simples(Utilizadores *p, data *h, int n);      /* Mostra a lista dos utilizadores sem tabela */

// Tabela
void escreve_espacos_branco(int x);                                     /* Escreve espaços em branco (usado na tabela) */
int conta_numeros(int num);                                             /* Conta a quantidade de numeros de um inteiro */
void tabela_escreve_int(int num, int digitos_tabela);                   /* Escreve um inteiro na tabela */
void tabela_escreve_string(char *string, int digitos_tabela);           /* Escreve uma string na tabela */

// Sessoes
void sessoes_tabela_precos(Sessoes *s, Utilizadores *p, int n);         /* Calcula o preço da sessao */                            // Verificar funcionamento

// Outros
void data_registo(DATA *h, int n);                                      /* Diz a data/hora atual */



/*
	Inicializa os computadores
		- Computadores *c -> Apontador para o vetor de computadores
		- n -> Número de computadores
*/
void computadores_inicializa(Computadores *c, int n) {
	for (int i = 0; i < NUM_COMPUTADORES; i++) {
		strcpy(c->nome, "Sem Nome");    /* Limpa o nome do computador */
		c->codigoComputador = i + 1;    /* Começa em 1 até n */
		c->estado = -1;                 /* -1 Não existe computador no vetor | 0 livre | 1 ocupado | 2 indisponivel */
		c->tempoUtilizacao = 0;
		c->total_faturado = 0;
		c++;
	}
}

/*
	Inicializa os utilizadores
		- Utilizadores *p -> Apontador para o vetor dos utilizadores
		- n -> Numero de utilizadores
*/
void utilizadores_inicializa(Utilizadores *p, int n) {
	for (int i = 0; i < n; i++) {
		p->codigoUtilizador = -1;       /* -1 Não tem código | 0 para ADMIN | > 0 para normais */
		p->tempo_total_utilizacao = 0;
		p->total_dinheiro_gasto = 0;
		p->tipoUser = 1;                /* 0 para ADMIN | 1 para normais */
		p->logado = 0;
		p++;
	}
}
/* Guardar Utilizadores em ficheiro Bin */
void guardaUserBin(Utilizadores *p, int n)
{
	int i;
	FILE *f;
	f = fopen("listaUser.dat", "wb");
	if (f == NULL)
	{
		fprintf(stderr, "Impossível abrir ficheiro"); //Apresenta um erro
		return;
	}
	for (i = 0; i < n; i++)
	{
		fwrite(p, sizeof(Utilizadores), 1, f); //Guarda o vetor todo no ficheiro
		p++;
	}
	fclose(f);
}

/* Ler utilizadores do ficheiro Bin */
void leUsersBin(Utilizadores *p, int n)
{
	int i;
	FILE *f;
	f = fopen("listaUser.dat", "rb");
	if (f == NULL)
	{
		fprintf(stderr, "Impossível abrir ficheiro");
		return;
	}
	i = 0;
	while (!feof(f))
	{
		i++;
		if (i < n)
		{
			fread(p, sizeof(Utilizadores), 1, f);
			p++;
		}
		else
		{
			fclose(f);
			return;
		}
	}
	fclose(f);
}

/* Guardar Computadores em ficheiro Bin */
void guardaComputadorBin(Computadores *c, int n)
{
	int i;
	FILE *f;
	f = fopen("listaComputador.dat", "wb");
	if (f == NULL)
	{
		fprintf(stderr, "Impossível abrir ficheiro"); //Apresenta um erro
		return;
	}
	for (i = 0; i < n; i++)
	{
		fwrite(c, sizeof(Computadores), 1, f); //Guarda o vetor todo no ficheiro
		c++;
	}
	fclose(f);
}

/* Ler computadores do ficheiro Bin */
void leComputadorBin(Computadores *c, int n)
{
	int i;
	FILE *f;
	f = fopen("listaComputador.dat", "rb");
	if (f == NULL)
	{
		fprintf(stderr, "Impossível abrir ficheiro");
		return;
	}
	i = 0;
	while (!feof(f))
	{
		i++;
		if (i < n)
		{
			fread(c, sizeof(Computadores), 1, f);
			c++;
		}
		else
		{
			fclose(f);
			return;
		}
	}
	fclose(f);
}

/* Guardar Sessoes em ficheiro Bin */
void guardaSessoesBin(Sessoes *s, int n)
{
	int i;
	FILE *f;
	f = fopen("listaSessoes.dat", "wb");
	if (f == NULL)
	{
		fprintf(stderr, "Impossível abrir ficheiro"); //Apresenta um erro
		return;
	}
	for (i = 0; i < n; i++)
	{
		fwrite(s, sizeof(Sessoes), 1, f); //Guarda o vetor todo no ficheiro
		s++;
	}
	fclose(f);
}

/* Ler Sessoes do ficheiro Bin */
void leSessoesBin(Sessoes *s, int n)
{
	int i;
	FILE *f;
	f = fopen("listaSessoes.dat", "rb");
	if (f == NULL)
	{
		fprintf(stderr, "Impossível abrir ficheiro");
		return;
	}
	i = 0;
	while (!feof(f))
	{
		i++;
		if (i < n)
		{
			fread(s, sizeof(Sessoes), 1, f);
			s++;
		}
		else
		{
			fclose(f);
			return;
		}
	}
	fclose(f);
}

/* Guardar Utilizadores em TXT*/
void guardaUsersTxt(Utilizadores *p, int n)
{
	FILE *f;
	int i;
	f = fopen("listaUsers.txt", "w");
	if (f == NULL)
	{
		fprintf(stderr, "Impossível abrir ficheiro");
		return;
	}
	for (i = 0; i < n; i++)
	{

		fprintf(f, "\Código Utilizador: %d; Nome: %s; Morada: %s; Contacto: %d; Data Registo: %s; Nome Utilizador: %s; Password: %s; Tipo User: %d; Tempo Utilização: %d; Total Dinheiro Gasto: %d\n", i + 1, p->codigoUtilizador, p->nome, p->morada, p->contacto, p->dataRegisto, p->nomeUtilizador, p->password, p->tipoUser, p->tempo_total_utilizacao, p->total_dinheiro_gasto);
		p++;
	}
	fclose(f);
}

/* Guardar Computadores em TXT*/
void guardaComputadoresTxt(Computadores *c, int n)
{
	FILE *f;
	int i;
	f = fopen("listaComputadores.txt", "w");
	if (f == NULL)
	{
		fprintf(stderr, "Impossível abrir ficheiro");
		return;
	}
	for (i = 0; i < n; i++)
	{

		fprintf(f, "\nCódigo Computador: %d; Nome: %s; Estado: %d; Tempo Utilização: %d; Total Faturado: %d;\n", i + 1, c->codigoComputador, c->nome, c->estado, c->tempoUtilizacao, c->total_faturado);
		c++;
	}
	fclose(f);
}

/* Guardar Sessoes em TXT*/
void guardaSessoesTXT(Sessoes *s, int n)
{
	FILE *f;
	int i;
	f = fopen("listaSessoes.txt", "w");
	if (f == NULL)
	{
		fprintf(stderr, "Impossível abrir ficheiro");
		return;
	}
	for (i = 0; i < n; i++)
	{

		fprintf(f, "\nEstado da Sessão: %d; Código Computador: %d; Código Utilizador: %d; Data Inicio: %s; Minutos Utilização: %d; Preço: %d; Pagamento: %d\n", i + 1, s->estado, s->codComputador, s->codUtilizador, s->dataInicio, s->minutosUtilizacao, s->preco, s->pagamento);
		s++;
	}
	fclose(f);
}

/* Escreve x espacos em branco (usado para formatar a tabela) */
void escreve_espacos_branco(int x)
{
	for (int i = 0; i < x; i++) printf(" ");
}

/* Conta a quantidade de caracteres de um numero */
int conta_numeros(int num)
{
	if (num < 0) return 0;
	else if (num < 10) return 1;
	else if (num < 100) return 2;
	else if (num < 1000) return 3;
	else if (num < 10000) return 4;
	return 0;
}

/* Escreve um inteiro na tabela */
void tabela_escreve_int(int num, int digitos_tabela)
{
	// Conta numeros do inteiro
	int num_dig_codUti = conta_numeros(num);

	// Calcula a diferença de digitos necessários da tabela e os digitos do inteiro
	int dif_digitos = digitos_tabela - num_dig_codUti;

	// Se a diferença for maior que 0, escreve o inteiro e os espaços em branco necessários (dif_digitos + 1 -> +1 serve para colocar o espaço antes da |)
	if (dif_digitos > 0)
	{
		printf("| %d", num);
		escreve_espacos_branco(dif_digitos + 1);
	}
	else printf("| %d ", num);
}

/* Escreve uma string na tabela */
void tabela_escreve_string(char *string, int digitos_tabela)
{
	// Calcula tamanho da string
	int tam_nome = strlen(string);

	// Calcula a diferença de digitos necessários da tabela e os digitos da string
	int dif_caracteres = digitos_tabela - tam_nome;

	// Se a diferença for maior que 0, escreve a string e os espaços em branco necessários (dif_digitos + 1 -> +1 serve para colocar o espaço antes da |)
	if (dif_caracteres > 0)
	{
		printf("| %s", string);
		escreve_espacos_branco(dif_caracteres + 1);
	}
	else printf("| %s ", string);
}

/* Lista dos utilizadores com tabela */
void utilizadores_listar_tabela(Utilizadores *p, data *h, int n)
{
	// HEADER
	printf("================================================================================= \n");
	printf("| COD |      USER      |  CONTACTO  | TIPO | LOGADO | TEMPO TOTAL | TOTAL GASTO | \n");
	printf("================================================================================= \n");

	// Loop pelos users
	for (int i = 0; i < n; i++)
	{
		// Escreve as infos
		if (p->codigoUtilizador != -1) {
			tabela_escreve_int(p->codigoUtilizador, 3);
			tabela_escreve_string(p->nomeUtilizador, 14);
			tabela_escreve_string(p->contacto, 10);
			tabela_escreve_int(p->tipoUser, 4);
			tabela_escreve_int(p->logado, 6);
			tabela_escreve_int(p->tempo_total_utilizacao, 11);
			tabela_escreve_int(p->total_dinheiro_gasto, 11);
			printf("|\n");
		}
		// Passa para o proximo user
		p++;
	}
	// FOOTER
	printf("|=====|================|============|======|========|=============|=============| \n");

	system("pause");

}

/* Tabela de preços */
void sessoes_tabela_precos(Sessoes *s, Utilizadores *p, int n) {
	double preco;
	p->codigoUtilizador = s->codUtilizador;
	if (s->minutosUtilizacao < 30)
		preco = (double)s->minutosUtilizacao * 0.05;
	else if (s->minutosUtilizacao > 30)
		preco = 30 * 0.05 + ((double)s->minutosUtilizacao - 30) * 0.025;

	if (preco < 2)
		s->preco = 2;
	else s->preco = preco;

}

/* Regista a data atual */
void data_registo(DATA *h, int n)
{
	SYSTEMTIME st;
	GetSystemTime(&st);
	for (int i = 0; i < n; i++) {
		h->ano = st.wYear;
		h->mes = st.wMonth;
		h->dia = st.wDay;
		h->hora = st.wHour;
		h->min = st.wMinute;
		h->segundo = st.wSecond;
		h++;
	}
}

/* Mostra a lista de computadores */
void computadores_lista(Computadores *c, int n)
{
	printf("\n\n LISTA DE COMPUTADORES \n\n");
	int i;

	for (i = 0; i < NUM_COMPUTADORES; i++)
	{
		if (c->estado != -1) {
		printf("Código: %d\n", c->codigoComputador);
		printf("Nome: %s\n", c->nome);
		printf("Estado: %d\n", c->estado);
		printf("Faturado: %d\n", c->total_faturado);
		printf("Tempo Utilização: %d\n\n", c->tempoUtilizacao);

		c++;
	}
	}
}

/* Adicionar Utilizador */
void utilizadores_introduzir(Utilizadores *p, data*h, int n)
{
	int i = 0;
	while ((p->codigoUtilizador != -1) && (i < n)) {
		i++;
		p++;
		h++;
	}

	if (i < n) {
		data_registo(h, n);
		printf("\nInserir novo utilizador no sistema\n\n");

		fseek(stdin, 0, 2);
		printf("\nInsira o nome completo: ");
		gets_s(p->nome);

		//Percorrer todo o vetor para verificar se há utilizadores com nomes iguais (POR FAZER!!!)
		fseek(stdin, 0, 2);
		printf("\nInsira o nome de utilizador: ");
		gets_s(p->nomeUtilizador);

		fseek(stdin, 0, 2);
		printf("\nInsira a morada: ");
		gets_s(p->morada);

		printf("\nInsira o contacto de telefone: ");
		gets_s(p->contacto);

		fseek(stdin, 0, 2);
		printf("\nInsira password: ");
		gets_s(p->password);

		printf("\nUtilizador registado em %d-%d-%d as %d:%d:%d.\n", h->ano, h->mes, h->dia, h->hora, h->min, h->segundo);
		p->codigoUtilizador = i;
		if (p->codigoUtilizador == 0) p->tipoUser = 0;

		printf("\nUtilizador registado na posicao %d\n", i + 1);
	}
	else printf("\n O programa nao tem espaco para mais utilizadores!! \n");
	system("pause");

}

/* Mostra utilizadores sem tabela */
void utilizadores_listar_simples(Utilizadores *p, data *h, int n)
{
	int i;
	for (i = 0; i < n; i++)
	{
		if (p->codigoUtilizador != -1) {
			printf("\nO utilizador %s tem os seguintes dados: ", p->nomeUtilizador);
			printf("\nNome: %s", p->nome);
			printf("\nMorada: %s", p->morada);
			printf("\nContacto: %s", p->contacto);
			printf("\nPassword: %s", p->password);
			printf("\nData de Registo: %d-%d-%d as %d:%d:%d.\n", h->ano, h->mes, h->dia, h->hora, h->min, h->segundo);
		}
		p++;
		h++;
	}
}

/* Admin editar user */
void admin_editar_user(utilizadores *p, int n)
{
	int numero_utilizadores_registados = 0;
	int i = 0;
	int codigo_utilizador;
	int aux_reset = 0;
	char opcao;
	// Ve os utilizadores existentes
	while (i < n)
	{
		if (p->codigoUtilizador != -1)
		{
			numero_utilizadores_registados++;
			aux_reset++;
			p++;
		}
		i++;
	}

	if (aux_reset != 0) { //p-> volta ao inicio

		aux_reset--;
		p--;

	}


	//Elimina o user
	if (numero_utilizadores_registados < n) {

		do {
			printf("\nQual o utilizador que pretende editar? Use o codigo.");
			scanf("%d", &codigo_utilizador);
		} while ((codigo_utilizador < 0) || (codigo_utilizador >= numero_utilizadores_registados));

	}

	while (p->codigoUtilizador != codigo_utilizador) { //Procura o utilizador selecionado
		p++;
	}
	system("CLS");
	printf("\nEscolheu o utilizador |%d|", p->codigoUtilizador);

    do {

			do {
				printf("\n#--------------------------#");
				printf("\n     Nome                 (1)      \n");
				printf("\n     Morada               (2)      \n");
				printf("\n     Contacto             (3)      \n");
				printf("\n     Nome de utilizador   (4)      \n");
				printf("\n     Password             (5)      \n");
				printf("\n     Sair                 (0)      \n");
				printf("\n#--------------------------#");
			    printf("\nO que deseja editar?");
			    scanf(" %c", &opcao);
		    } while (opcao < '0' || opcao > '5');

			switch (opcao) {
			case '1':
				fseek(stdin, 0, 2);
				printf("\nInsira novo nome: ");
				gets_s(p->nome);
				system("CLS");
				printf("\nNome alterado!\n");
				break;
			case '2':
				fseek(stdin, 0, 2);
				printf("\nInsira nova morada: ");
				gets_s(p->morada);
				system("CLS");
				printf("\nMorada alterada!\n");
				break;
			case '3':
				fseek(stdin, 0, 2);
				printf("\nInsira novo contacto: ");
				gets_s(p->contacto);
				system("CLS");
				printf("\nContacto alterado!\n");
				break;
			case '4':
				fseek(stdin, 0, 2);
				printf("\nInsira novo nome de utilizador: ");
				gets_s(p->nomeUtilizador);
				system("CLS");
				printf("\nNome de utilizador alterado!\n");
				break;
			case '5':
				fseek(stdin, 0, 2);
				printf("\nInsira nova password: ");
				gets_s(p->password);
				system("CLS");
				printf("\nPassword alterada!\n");
			case '0':
				break;
			default:
				printf("\nOpção inválida.");
				break;
			}
	} while (opcao != '0');


}

/* Admin elimiar user */
void admin_eliminar_user(utilizadores *p, int n)   //FICA OU NAO FICA???????       IMPORTANTE!!!!!!!!!!!!!!!!!!!!!!
{
	int numero_utilizadores_registados = 0;
	int i = 0;
	int codigo_utilizador;
	int aux_reset = 0;

	// Ve os utilizadores existentes
	while (i < n)
	{
		if (p->codigoUtilizador != -1)
		{
			numero_utilizadores_registados++;
			aux_reset++;
			p++;
		}
		i++;
	}

	if (aux_reset != 0) { //p-> volta ao inicio

		aux_reset--;
		p--;

	}


	//Elimina o user
	if (numero_utilizadores_registados < n){

		do {
			printf("\n");
			printf("=======================================================\n");
			printf("Introduza o codigo do utilizador que pretende remover: ");
			printf("\n=======================================================\n\n");
			scanf("%d", &codigo_utilizador);
		} while ((codigo_utilizador < 0) || (codigo_utilizador >= numero_utilizadores_registados));

	}

	while (p->codigoUtilizador != codigo_utilizador) { //Procura o utilizador selecionado
		p++;
	}
	p->codigoUtilizador = -1;
	printf("\nO utilizador %d foi removido com sucesso!", codigo_utilizador);

}

/* Admin eliminar computador */
void admin_eliminar_computador(computadores *c, int n)
{
	int computadores_existentes = 0;
	int i = 0;
	int codigo_computador;
	int aux_reset = 0;
	// Vai ver todos os computadores
	while (i < NUM_COMPUTADORES)
	{
		if (c->estado != -1)
		{
			computadores_existentes++;
			c++;
			aux_reset++;
		}
		i++;
	}

	if (aux_reset != 0) { //p-> volta ao inicio

		aux_reset--;
		c--;

	}


	//Fecha o pc
	if (computadores_existentes <= NUM_COMPUTADORES) {

		do {
			printf("\n");
			printf("======================================================\n");
			printf("Introduza o codigo do computador que pretende fechar: ");
			printf("\n======================================================\n\n");
			scanf("%d", &codigo_computador);
		} while ((codigo_computador < 1) || (codigo_computador > computadores_existentes));

	}

	while (c->codigoComputador != codigo_computador) { //Procura o computador selecionado
		c++;
	}

	if (c->estado == 0){
	c->estado = 2;
	printf("\nO computador %d esta agora indisponivel!", c->codigoComputador);
	}
	else printf("\nO computador nao existe ou esta a ser utilizado!");


}

/* Admin editar computador */
void admin_editar_computador(computadores *c, int n)
{
	int computadores_existentes = 0;
	int i = 0;
	int codigo_computador;
	int aux_reset = 0;
	char opcao;
	// Vai ver todos os computadores
	while (i < NUM_COMPUTADORES)
	{
		if (c->estado != -1)
		{
			computadores_existentes++;
			c++;
			aux_reset++;
		}
		i++;
	}

	if (aux_reset != 0) { //p-> volta ao inicio

		aux_reset--;
		c--;

	}


	//Fecha o pc
	if (computadores_existentes <= NUM_COMPUTADORES) {

		do {
			printf("\n");
			printf("======================================================\n");
			printf("Introduza o codigo do computador que pretende editar: ");
			printf("\n======================================================\n\n");
			scanf("%d", &codigo_computador);
		} while ((codigo_computador < 1) || (codigo_computador > computadores_existentes));

	}

	while (c->codigoComputador != codigo_computador) { //Procura o computador selecionado
		c++;
	}

	system("CLS");
	printf("\nEscolheu o computador |%d|", c->codigoComputador);

	do {

		do {
			printf("\n#--------------------------#");
			printf("\n     Nome                   (1)      \n");
			printf("\n     Tornar indisponivel    (2)      \n");
			printf("\n     Tornar livre           (3)      \n");
			printf("\n     Tornar ocupado         (4)      \n");
			printf("\n     Sair                   (0)      \n");
			printf("\n#--------------------------#");
			printf("\nO que deseja editar?");
			scanf(" %c", &opcao);
		} while (opcao < '0' || opcao > '4');

		switch (opcao) {
		case '1':
			fseek(stdin, 0, 2);
			printf("\nInsira novo nome: ");
			gets_s(c->nome);
			system("CLS");
			printf("\nNome alterado!\n");
			break;
		case '2':
			c->estado = 2;
			printf("\nComputador esta agora indisponivel!\n"); //DESCONSIDERAR SESSAO PARA PAGAMENTO
			system("CLS");
			printf("\nEstado alterado!\n");
			break;
		case '3':
			c->estado = 0;
			printf("\nComputador esta agora livre!\n"); //COMEÇAR SESSAO
			system("CLS");
			printf("\nEstado alterado!\n");
			break;
		case '4':
			c->estado = 1;
			printf("\nComputador esta agora ocupado!\n"); //TERMINAR SESSAO E CALCULAR PAGAMENTO
			system("CLS");
			printf("\nEstado alterado!\n");
			break;
		case '0':
			break;
		default:
			printf("\nOpção inválida.");
			break;
		}
	} while (opcao != '0');

}

/* Admin adicionar computador */
void admin_adicionar_computador(Computadores *c)
{
	int computadores_ocupados = 0;
	int i = 0;

	// Vai ver todos os computadores
	while (i < NUM_COMPUTADORES)
	{
		if (c->estado != -1)
		{
			computadores_ocupados++;
			c++;
		}
		i++;
	}

	// Se os computadores usados forem menos que os computadores existentes
	if (computadores_ocupados < NUM_COMPUTADORES)
	{
		// LOOP que só para quando o computador for adicionado
		while (1)
		{
			// Se o estado do PC for igual a -1
			if ((c->estado == -1))
			{
				fseek(stdin, 0, 2);
				printf("\nInsira o nome computador: ");
				gets_s(c->nome);
				printf("\nO computador %s foi adicionado.\nCÓDIGO: %d\n\n", c->nome, c->codigoComputador);
				c->estado = 0;
				c++;
				break;
			}
			else c++;
		}
	}
	else printf("\nNão é possivel adicionar mais computadores, lista cheia!");

	system("pause");

}

/* User editar dados */
void user_editar_dados(Utilizadores *p, int n)
{
	char opcao;

	do {

		do {
			printf("\n#--------------------------#");
			printf("\n     Nome                 (1)      \n");
			printf("\n     Morada               (2)      \n");
			printf("\n     Contacto             (3)      \n");
			printf("\n     Nome de utilizador   (4)      \n");
			printf("\n     Password             (5)      \n");
			printf("\n     Sair                 (0)      \n");
			printf("\n#--------------------------#");
			printf("\nO que deseja editar?");
			scanf(" %c", &opcao);
		} while (opcao < '0' || opcao > '5');

		switch (opcao) {
		case '1':
			fseek(stdin, 0, 2);
			printf("\nInsira novo nome: ");
			gets_s(p->nome);
			system("CLS");
			printf("\nNome alterado!\n");
			break;
		case '2':
			fseek(stdin, 0, 2);
			printf("\nInsira nova morada: ");
			gets_s(p->morada);
			system("CLS");
			printf("\nMorada alterada!\n");
			break;
		case '3':
			fseek(stdin, 0, 2);
			printf("\nInsira novo contacto: ");
			gets_s(p->contacto);
			system("CLS");
			printf("\nContacto alterado!\n");
			break;
		case '4':
			fseek(stdin, 0, 2);
			printf("\nInsira novo nome de utilizador: ");
			gets_s(p->nomeUtilizador);
			system("CLS");
			printf("\nNome de utilizador alterado!\n");
			break;
		case '5':
			fseek(stdin, 0, 2);
			printf("\nInsira nova password: ");
			gets_s(p->password);
			system("CLS");
			printf("\nPassword alterada!\n");
		case '0':
			break;
		default:
			printf("\nOpção inválida.");
			break;
		}
	} while (opcao != '0');
	system("pause");
	//POR FAZER
}

/* Menu principal */
char menu_principal(Utilizadores *p, data *h, computadores *c, int n, Sessoes *s)
{
	leSessoesBin(s, n);
	leUsersBin(p, n);
	leComputadorBin(c, n);

	char op;

	printf("\n#--------------------------#");
	printf("\n     Registar      (1)     \n");
	printf("\n     Logar         (2)     \n");
	printf("\n     Sair          (0)     \n");
	printf("\n#--------------------------#");

	do {
		printf("\nQual a opção? ");
		scanf(" %c", &op);
	} while (op < '0' || op > '2');

	system("cls");
	return op;
}

/* Menu principal do user */
void menu_user(Utilizadores *p, data *h, computadores *c, int n, sessoes *s)
{
	char op;

	printf("\n#--------------------------------------------#");
	printf("\n        Ir para PC                    (1)      \n");
	printf("\n        Editar dados                  (2)      \n");
	printf("\n        Sair                          (0)      \n");
	printf("\n#--------------------------------------------#");

	do
	{
		printf("\nQual a opção? ");
		scanf(" %c", &op);
	} while (op < '0' || op > '2');

	switch (op)
	{
	case '1':
		menu_user_computador(p, h, c, n, s);
		break;
	case '2':
		user_editar_dados(p, n); //POR FAZER
		break;
	case '0':
		menu_principal(p, h, c, n, s);
		break;
	default:
		printf("\nOpção inválida.");
		break;
	}
	system("cls");
}

/* Menu principal do user - computador */
void menu_user_computador(Utilizadores *p, data *h, computadores *c, int n, Sessoes *s)
{
	char op;

	printf("\n#--------------------------------------------#");
	printf("\n        Cena 1                  (1)      \n");
	printf("\n        Cena 2                  (2)      \n");
	printf("\n        Sair da sessao          (0)      \n");
	printf("\n#--------------------------------------------#");

	do {
		printf("\nQual a opção? ");
		scanf(" %c", &op);
	} while (op < '0' || op > '2');

	switch (op)
	{
	case '1':
		//VAMOS TENTAR SIMULAR A UTILIZAÇAO DE UM COMPUTADOR
		break;
	case '2':
		//VAMOS TENTAR SIMULAR A UTILIZAÇAO DE UM COMPUTADOR
		break;
	case '0':
		menu_user(p, h, c, n, s);
		break;
	default:
		printf("\nOpção inválida.");
		break;
	}
	system("cls");

}

/* Menu principal da admin */
void menu_admin(Utilizadores *p, data *h, computadores *c, int n, Sessoes *s)
{
	char op;

	do
	{
		printf("\n#--------------------------#");
		printf("\n     USERS            (1)      \n");
		printf("\n     PCS              (2)      \n");
		printf("\n     SESSOES          (3)      \n");
		printf("\n     GUARDAR DADOS    (4)      \n");
		printf("\n     Sair             (0)      \n");
		printf("\n#--------------------------#");

		do {
			printf("\nQual a opção? ");
			scanf(" %c", &op);

		} while (op < '0' || op > '5');

		switch (op)
		{
		case '1':
			menu_admin_users(p, h, c, n);
			break;
		case '2':
			menu_admin_computadores(p, h, c, n, s);
			break;
		case '3':
			//menu_admin_sessoes(s, h, c, n);
			break;
		case '4':
			guardaUserBin(p, n);
			guardaComputadorBin(c, n);
			guardaSessoesBin(s, n);
			guardaUsersTxt(p, n);
			guardaComputadoresTxt(c, n);
			guardaSessoesTXT(s, n);
			break;
		case '0':
			menu_principal(p, h, c, n, s);
			break;
		default:
			printf("\nOpção inválida 1.");
			break;
		}
	} while (op != '0');

	system("cls");

}

/* Menu principal da admin - Users */
void menu_admin_users(Utilizadores *p, data *h, computadores *c, int n)
{
	char op;

	do
	{
		printf("\n#--------------------------#");
		printf("\n     Lista de users   (1)      \n");
		printf("\n     Adicionar user   (2)      \n");
		printf("\n     Editar user      (3)      \n");
		printf("\n     Eliminar user    (4)      \n");
		printf("\n     Sair             (0)      \n");
		printf("\n#--------------------------#");
		do {
			printf("\nQual a opção? ");
			scanf(" %c", &op);

		} while (op < '0' || op > '4');
		switch (op) {
		case '1':
			utilizadores_listar_tabela(p, h, n);

			break;
		case '2':
			utilizadores_introduzir(p, h, n);
			break;
		case '3':
			admin_editar_user(p,n);
			break;
		case '4':
			utilizadores_listar_tabela(p, h, n);
			admin_eliminar_user(p,n);
			break;
		case '0':
			break;
		default:
			printf("\nOpção inválida. ..");
			break;
		}
	} while (op != '0');


}

/* Menu principal da admin - Computadores */
void menu_admin_computadores(Utilizadores *p, data *h, computadores *c, int n, Sessoes *s)
{
	char op;

	do {
		printf("\n#--------------------------#");
		printf("\n     Lista de PCs   (1)      \n");
		printf("\n     Adicionar PC   (2)      \n");
		printf("\n     Editar PC      (3)      \n");
		printf("\n     Eliminar PC    (4)      \n");
		printf("\n     Sair           (0)      \n");
		printf("\n#--------------------------#");


		printf("\nQual a opção? ");
		scanf(" %c", &op);



		switch (op)
		{
		case '1':
			computadores_lista(c, n);
			menu_admin_computadores(p, h, c, n, s);
			break;
		case '2':
			admin_adicionar_computador(c);
			break;
		case '3':
			admin_editar_computador(c, n);
			break;
		case '4':
			admin_eliminar_computador(c,n);
			break;
		case '0':
			menu_admin(p, h, c, n, s);
			break;
		default:
			printf("\nOpção inválida.");
			break;
		}
	} while (op != '0');
}

/* Menu do LOGIN */
void menu_login(Utilizadores *p, data *h, computadores *c, int n, sessoes *s)
{
	int i, cmpStringUser, cmpStringPass;
	char nome[15], password[15];
	Utilizadores *user = new Utilizadores;
	*user = *p;
	int nUsers = n;

	fseek(stdin, 0, 2);
	printf("\nInsira o nome de utilizador: ");
	gets_s(nome);
	fseek(stdin, 0, 2);
	printf("\nInsira a password: ");
	gets_s(password);

	for (i = 0; i < n; i++)
	{
		cmpStringUser = strcmp(nome, p->nomeUtilizador);
		cmpStringPass = strcmp(password, p->password);

		if ((cmpStringUser == 0 && cmpStringPass == 0))
		{
			if (p->codigoUtilizador == 0)
				menu_admin(p, h, c, n, s);
			else if (p->codigoUtilizador > 0)
				menu_user(p, h, c, n, s);
		}
		else p++;
	}
	printf("\nErrado.\n");
	system("pause");
}

/* Main */
void main()
{
	setlocale(LC_ALL, ""); //Caracteres acentuados


	Utilizadores user_logado;

	Utilizadores user[10];
	int nUsers = 10;


	int nComputadores = 20;
	Computadores pc[NUM_COMPUTADORES];
	data h[10];
	sessoes s[10];
	computadores_inicializa(pc, nComputadores);


	char ope;
	utilizadores_inicializa(user, nUsers);


	do {
		ope = menu_principal(user, h, pc, nUsers, s);

		switch (ope) {
		case '1':

			utilizadores_introduzir(user, h, nUsers);
			system("cls");
			break;
		case '2':
			menu_login(user, h, pc, nUsers, s);
			system("cls");
			break;
		case '3':
			menu_admin(user, h, pc, nUsers, s);
			system("cls");
			break;
		case '0':
			ope = '0';
			break;
		default:
			printf("\nOpção inválida.");
			break;
		}
	} while (ope != '0');
}