#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();                                                          /* Menu principal */
void menu_login(Utilizadores *p, data *h, computadores *c, int n);              /* Menu do LOGIN */
void menu_user(Utilizadores *p, data *h, computadores *c, int n);               /* Menu principal do user */
void menu_user_computador(Utilizadores *p, data *h, computadores *c, int n);    /* Menu principal do user - computador */
void menu_admin(Utilizadores *p, data *h, computadores *c, int n);              /* 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); /* Menu principal da ADMIN - computadores */

// Admin - User
void admin_editar_user();                                               /* Admin editar user */
void admin_eliminar_user();                                             /* Admin eliminar user */
// Admin - Computador
void admin_adicionar_computador();                                      /* Admin adicionar computador */
void admin_editar_computador();                                         /* Admin editar computador */
void admin_eliminar_computador();                                       /* 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++;
    }
}

/* 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++)
    {
        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");
    printf("\n Pressiona <enter> para continuar\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()
{
    printf("\nFuncao de editar user!");
    system("pause");
    //POR FAZER!!
}

/* Admin elimiar user */
void admin_eliminar_user()
{
    printf("\nFuncao de eliminar user!");
    system("pause");
    //POR FAZER!!
}

/* Admin eliminar computador */
void admin_eliminar_computador()
{
    printf("\nFuncao de eliminar pc!");
    system("pause");
    //POR FAZER
}

/* Admin editar computador */
void admin_editar_computador()
{
    printf("\nFuncao de editar pc!");
    system("pause");
    //POR FAZER
}

/* 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");
    //POR FAZER
}

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

    system("pause");
    //POR FAZER
}

/* Menu principal */
char menu_principal()
{
    char op;

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

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

    //system("cls");
    return op;
}

/* Menu principal do user */
void menu_user(Utilizadores *p, data *h, computadores *c, int n)
{
    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);
            break;
        case '2':
            user_editar_dados(p, n); //POR FAZER
            break;
        case '0':
            menu_principal();
            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)
{
    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);
            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)
{
    char op;

    do
    {
        printf("\n#--------------------------#");
        printf("\n     USERS            (1)      \n");
        printf("\n     PCS              (2)      \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);
            break;
        case '0':
            menu_principal();
            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(); //POR FAZER
            break;
        case '4':
            admin_eliminar_user(); //PORFAZER
            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)
{
    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);
                break;
            case '2':
                admin_adicionar_computador(c); //POR FAZER
                break;
            case '3':
                admin_editar_computador();  //POR FAZER
                break;
            case '4':
                admin_eliminar_computador(); //POR FAZER
                break;
            case '0':
                menu_admin(p, h, c, n);
                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)
{
    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);
            else if (p->codigoUtilizador > 0)
                menu_user(p, h, c, n);
        }
        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];
    computadores_inicializa(pc, nComputadores);


    char ope;
    utilizadores_inicializa(user, nUsers);


    do {
        ope = menu_principal();

        switch (ope) {
        case '1':

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