Untitled

/* Esse projeto tem o intuito de simular um sistema de leilao e aluguel.Contendo as seguintes propriedades 
 Cadastro de usuário, sendo dividido em : Cliente ou Negociador.
Autenticação de seu respectivo usuario, podendo ser autenticado o cliente ou o negociador.
Sistema de cadastro de veiculos, tanto cadastrar veiculo para ser alugado ou leiloado.
Sistema de participação em leilões.
Sistema de alocação de veiculo.
*/









#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <locale.h>
#include <time.h>
#include <windows.h>

#define MAX_USERS 100 // A constante MAX_USERS define a quantidade máxima de usuários que podem ser cadastrados.
#define MAX_CARS 100 // A constante MAX_CARS define a quantidade máxima de carros que podem ser cadastrados.
#define MAX_CARACTERES 50 // A constante MAX_CARACTERES define a quantidade de caracteres que podem ser utilizados.
#define MAX_CPF_CARACTERES 15 // A constante MAX_CPF_CARACTERES define a quantidade de caracteres do CPF.

// Estrutura para o cadastro de usuarios negociantes
typedef struct {
    char nome[MAX_CARACTERES];
    char cpf[MAX_CARACTERES];
    char email[MAX_CARACTERES];
    char endereco[MAX_CARACTERES];
    char marca[MAX_CARACTERES];
    char modelo[MAX_CARACTERES];
    char cor[MAX_CARACTERES];
    char senha[MAX_CARACTERES];
    int ano;
    float preco_aluguel;
    int id;




}negociante;

// Estrutura para o cadastro de usuarios clientes
typedef struct {
    char nome[MAX_CARACTERES];
    char cpf[MAX_CARACTERES];
    char senha[MAX_CARACTERES];
    char endereco[MAX_CARACTERES];
    char email[MAX_CARACTERES];
    float saldo;
    int id;
    char leiloes_ganhos[MAX_CARACTERES];
    char aluguel_realizados[MAX_CARACTERES];
    float lance1;
    float lance2;
    float lance3;




}cliente;

// Estrutura para o cadastro de carros em aluguel
typedef struct {
    char marca[MAX_CARACTERES];
    char placa[MAX_CARACTERES];
    int ano;
    char cor[MAX_CARACTERES];
    float preco_aluguel;    
    int dono;
    char telefone[MAX_CARACTERES];
} Carro;
// Estrutura para o cadastro de carros em leilao
typedef struct {
    char marca[MAX_CARACTERES];
    char placa[MAX_CARACTERES];
    int ano;
    char cor[MAX_CARACTERES];
    int dono;
} Carro_leilao;

// Funcao para limpar o buffer do teclado 
void clear_keyboard_buffer(void)
{
    int c = 0;
    while ((c = getchar()) != '\n' && c != EOF) {}
    return;
}

//Funcao para cadastrar negociante
int cadastro_negociante(negociante negociadores[], int* contadorUsuariosNegociantes, int* userId) {

    if (*contadorUsuariosNegociantes >= MAX_USERS) {
        printf("Limite máximo atingido");
        return 0;
    }

    negociante negociadores_db;

    printf("Nome: ");
    scanf("%s", &negociadores_db.nome);
    printf("Cpf: ");
    scanf("%s", &negociadores_db.cpf);
    printf("Senha: ");
    scanf("%s", &negociadores_db.senha);
    printf("Email: ");
    scanf("%s", &negociadores_db.email);
    printf("Endereço: ");
    scanf("%s", &negociadores_db.endereco);

    // Verificação de existência de um mesmo nome de usuario.

    int i;
    for (i = 0; i < *contadorUsuariosNegociantes; i++) {
        if (strcmp(negociadores[i].nome, negociadores_db.nome) == 0) {
            printf("Já existe um usuário com este nome. Por favor, escolha outro nome de usuário.\n");
            return 0; // retorna 0 para indicar erro 
        }
    }

    negociadores_db.id = *contadorUsuariosNegociantes + 1;




    negociadores[*contadorUsuariosNegociantes] = negociadores_db;
    *contadorUsuariosNegociantes += 1;
    *userId = negociadores_db.id;





    printf("Cadastro realizado com sucesso! Seu ID de usuário é %d.\n", negociadores_db.id);

    // Salvar usuário em arquivo .txt escrevendo as informações no formato <ID> <CPF> <nome> <senha>.
    FILE* file = fopen("usuarios_negociantes.txt", "a");
    if (file != NULL) {
        fprintf(file, "%d %s %s %s\n", negociadores_db.id, negociadores_db.cpf, negociadores_db.nome, negociadores_db.senha); // Escrevendo o CPF no arquivo
        fclose(file);
    }

    return 1;


}
//Funcao para cadastrar clientes
int cadastro_cliente(cliente clientes[], int* contadorUsuariosClientes, int* userId) {

    if (*contadorUsuariosClientes >= MAX_USERS) { // Verificação se o contador 'userCount' atingiu o limite máximo de usuários atribuido pela constante 'MAX_USUARIOS'.
        printf("Limite máximo atingido");
        return 0;
    }

    cliente cliente_db; // Declaração da variável 'cliente_db' do tipo 'Usuario'. Será utilizada para armazenar as informações colhidas do usuário a ser cadastrado.


    printf("Nome: ");
    scanf("%s", &cliente_db.nome);
    printf("Cpf: ");
    scanf("%s", &cliente_db.cpf);
    printf("Senha: ");
    scanf("%s", &cliente_db.senha);
    printf("Email: ");
    scanf("%s", &cliente_db.email);
    printf("Endereço: ");
    scanf("%s", &cliente_db.endereco);

    // Verificação de existência de um mesmo nome de usuário.
    int i;
    for (i = 0; i < *contadorUsuariosClientes; i++) {
        if (strcmp(clientes[i].nome, cliente_db.nome) == 0) {
            printf("Já existe um usuário com este nome. Por favor, escolha outro nome de usuário.\n");
            return 1; // Retorna 0 para indicar falha no cadastro
        }
    }

    // Define o ID do usuário como o número de usuários cadastrados + 1.
    cliente_db.id = *contadorUsuariosClientes + 1;

    // Adiciona o usuário cadastrado na lista de usuários incrementando contador de usuários e atualizando o ID.
    clientes[*contadorUsuariosClientes] = cliente_db;
    *contadorUsuariosClientes += 1;
    *userId = cliente_db.id;




    printf("Cadastro realizado com sucesso! Seu ID de usuário é %d.\n", cliente_db.id);



    // Salvar usuário em arquivo .txt escrevendo as informações no formato <ID> <CPF> <nome> <senha>.
    FILE* file = fopen("usuarios_clientes.txt", "a");
    if (file != NULL) {
        fprintf(file, "%d %s %s %s\n", cliente_db.id, cliente_db.cpf, cliente_db.nome, cliente_db.senha); // Escrevendo o CPF no arquivo
        fclose(file);
    }

    return 0;







}

// Autenticação de usuario negociante
int aut_negociantes(negociante negociadores[], int contadorUsuariosNegociantes, int* userId) {

    char cpf[MAX_CARACTERES];
    char senha[MAX_CARACTERES];

    printf("Insira seu cpf: ");
    scanf("%s", &cpf);
    printf("\nInsira sua senha: ");
    scanf("%s", &senha);

    // Verifica as credenciais
    int i;
    for (i = 0; i < contadorUsuariosNegociantes; i++) {
        if (strcmp(negociadores[i].cpf, cpf) == 0 && strcmp(negociadores[i].senha, senha) == 0) {
            *userId = negociadores[i].id;
            printf("Autenticação bem-sucedida! Bem-vindo(a), %s.\n", negociadores[i].nome);
            return 0;
        }

        
            
        
    }

    
    return 1;

}
// Autenticação de usuario cliente
int aut_clientes(cliente clientes[], int contadorUsuariosClientes, int* userId) {

    char cpf[MAX_CARACTERES];
    char senha[MAX_CARACTERES];

    printf("Insira seu cpf: ");
    scanf("%s", &cpf);
    printf("\nInsira sua senha: ");
    scanf("%s", &senha);

    // Verifica as credenciais
    int i;
    for (i = 0; i < contadorUsuariosClientes; i++) {
        if (strcmp(clientes[i].cpf, cpf) == 0 && strcmp(clientes[i].senha, senha) == 0) {
            *userId = clientes[i].id;
            printf("Autenticação bem-sucedida! Bem-vindo(a), %s.\n", clientes[i].nome);
            return 0;
           
        }
        

    }
  

    return 1;
}

// Funcao para cadastrar veiculos em aluguel
int cadastrarVeiculoAluguel(Carro carros[], int* carroCount, int *userId) {
    if (*carroCount >= MAX_CARS) {
        printf("Limite máximo de veículos atingido!\n");
        return;
    }

    Carro novoCarro;

    printf("\nCadastro de veículo\n");

    printf("Digite a marca do veículo: ");
    scanf("%s", &novoCarro.marca);
    printf("Digite a placa do veículo: ");
    scanf("%s", &novoCarro.placa);
    printf("Digite o ano do veículo: ");
    scanf("%d", &novoCarro.ano);
    printf("Digite a cor do veículo: ");
    scanf("%s", &novoCarro.cor);
    printf("Digite o preço do aluguel por dia: R$");
    scanf("%f", &novoCarro.preco_aluguel);
    printf("Digite seu telefone de contato: ");
    scanf("%s", &novoCarro.telefone);

    // Define o dono do veículo como o ID do usuário logado
    novoCarro.dono = *userId;

    // Adiciona o veículo ao vetor
    carros[*carroCount] = novoCarro;
    *carroCount += 1;

    // Salva todos os dados cadastrados num arquivo .txt no formato  <id> <marca> <placa> <cor> <ano> <preco> <telefone>

    FILE* filealuguel; // chama a funcao file e cria o ponteiro filealuguel
    filealuguel = fopen("carros_aluguel.txt", "a"); // o ponteiro filealuguel chama a funcao de abertura de arquivos fopen("nome_do_arquivo.txt", "atributo") nesse caso esta em modo A = acrescenta, caso o arquivo não exista ele cria um 
    if (filealuguel != NULL) {
        fprintf(filealuguel, "%d %s %s %s %d %f %s\n", novoCarro.dono, novoCarro.marca, novoCarro.placa, novoCarro.cor, novoCarro.ano, novoCarro.preco_aluguel, novoCarro.telefone); // Inserindo todas informações 
        fclose(filealuguel); // fecha o arquivo.
    }

    printf("Veículo cadastrado com sucesso!\n");

    return 0;
}

// Cadastrar veiculo leilao
int cadastrarVeiculoLeilao(Carro_leilao carrosleilao[], int* carroCountLeilao, int *userId) {
    if (*carroCountLeilao >= MAX_CARS) { // Verifica se o numero maximo de carros cadastrados atingiu, no caso é o valor predefinido MAX_CARS que é 100.
        printf("Limite máximo de veículos atingido!\n"); // Se o numero de carros cadastrados for maior ou igual a 100 ele imprime essa mensagem
    }

    Carro_leilao novoCarro; // Cria uma variavel chamada de novoCarro que é da STRUCT CARRO, essa variavel ira armazenar as informacoes.

    printf("\nCadastro de veículo\n");
    printf("Digite a marca do veículo: ");
    scanf("%s", novoCarro.marca);
    printf("Digite a placa do veículo: ");
    scanf("%s", novoCarro.placa);
    printf("Digite o ano do veículo: ");
    scanf("%d", &novoCarro.ano);
    printf("Digite a cor do veículo: ");
    scanf("%s", novoCarro.cor);


    // Define o dono do veículo como o ID do usuário logado
    novoCarro.dono = *userId;

    // Adiciona o veículo ao vetor
    carrosleilao[*carroCountLeilao] = novoCarro;
    *carroCountLeilao += 1;

    // Salva todos carros cadastrados em um .txt no formado <ID> <marca> <placa> <cor> <ano> 

    FILE* filecarro; // Funcao FILE(arquivo) e cria o ponteiro * filecarro
    filecarro = fopen("carros_leilao.txt", "a"); // Função que abre o arquivo de texto, está no modo A de 'append' ou seja acrescenta, caso o arquivo não exista ele cria um e caso exista ele acrescenta as informacoes ao arquivo existente.
    if (filecarro != NULL) {
        fprintf(filecarro, "%d %s %s %s %d\n", novoCarro.dono, novoCarro.marca, novoCarro.placa, novoCarro.cor, novoCarro.ano); // Insere todos os dados que acabaram de ser inseridos no cadastro, dentro do arquivo de texto
        fclose(filecarro); // Fecha o arquivo de texto, para evitar o vazamento.
    }

    printf("Veículo cadastrado com sucesso!\n");

    return 0;


}

// Função para carregar usuários do arquivo
int carregarUsuariosClientes(cliente clientes[]) {
    FILE* file = fopen("usuarios_clientes.txt", "r");
    if (file == NULL) {
        printf("Erro ao abrir arquivo de usuários.\n");
        return 0;
    }

  

    int count = 0;
    while (fscanf(file, "%d %s %s %s", &clientes[count].id, clientes[count].cpf, clientes[count].nome, clientes[count].senha) == 4) { // Lendo o CPF do arquivo
        count++;
        
    }

    fclose(file);
    return count;
}
// Função para carregar usuários do arquivo
int carregarUsuariosNegociantes(negociante negociadores[]) {

    FILE* file = fopen("usuarios_negociantes.txt", "r");
    if (file == NULL) {
        printf("Erro ao abrir arquivo de usuários.\n");
        return 0;
    }

    int count = 0;
    while (fscanf(file, "%d %s %s %s", &negociadores[count].id, negociadores[count].cpf, negociadores[count].nome, negociadores[count].senha) == 4) { 
        count++;
    }

    fclose(file);
    return count;
}

// Função para carregar veículos do arquivo
int carregarCarrosAluguel(Carro carros[]) {
    FILE* file = fopen("carros_aluguel.txt", "r");
    if (file == NULL) {
        printf("Erro ao abrir arquivo de veículos.\n");
        return 0;
    }
     // <id> <marca> <placa> <cor> <ano> <preco> <telefone>
    int counter = 0;
    while (fscanf(file, "%d %s %s %s %d %f %s", &carros[counter].dono, carros[counter].marca, carros[counter].placa, &carros[counter].ano,carros[counter].cor, &carros[counter].preco_aluguel,carros[counter].telefone) == 7) {
    //  printf("1\n"); // debug verificand se o numero de impressoes do numero bate com o numero de veiculos cadastrados
        counter++;
    }

    fclose(file);
    return counter;
}

// Função para carregar veículos do arquivo
int carregarCarrosLeilao(Carro_leilao carrosleilao[]) {
    FILE* file = fopen("carros_leilao.txt", "r");
    if (file == NULL) {
        printf("Erro ao abrir arquivo de veículos.\n");
        return 0;
    }

    int count = 0;
    while (fscanf(file, "%d %s %s %s %d", &carrosleilao[count].dono, carrosleilao[count].marca, carrosleilao[count].placa, carrosleilao[count].cor, &carrosleilao[count].ano) == 5) {
       //printf("1\n"); // debugando, verificand se o numero de impressoes do numero bate com o numero de veiculos cadastrados
        count++;
       
    }

    fclose(file);
    return count;
}


// Funcao participar de um leilao
int participar_leilao(Carro_leilao carrosleilao[], int* carroCountLeilao, cliente clientes[], int* contadorUsuarioClientes, int* userId) {



    printf("\nLista de veiculos leiloados\n\n");

    FILE* pleilao;
    pleilao = fopen("carros_leilao.txt", "r");
    if (pleilao == NULL) {
        printf("Erro ao localizar o arquivo");
    }
    do {
        char c = fgetc(pleilao);

        // Checando o final do arquivo.
        if (feof(pleilao)) {
            break;
        }
        printf("%c", c);

    } while (1);


    // <ID> <marca> <placa> <cor> <ano> 
    char placa[MAX_CARACTERES];

    printf("\nInsira aqui o a placa do veiculo cadastrado no leilao: ");
    scanf("%s", placa);


    
    int j; int rodadas = 0;
    // Variaveis locais do leilao

    
    
    int valormin1, valormin2, valormin3;
    float valor_inicial = 0.0;
    int roundcount1, roundcount2, roundcount3;
    int maxvalor;


    // Criação de usuários fantasmas para simulação.
    //Pessoa 1
    char nome_fic[MAX_CARACTERES] = "Felipe";
    float lances_fic, lances_fic2, lances_fic3;
    // Pessoa 2
    char nome_pessoa[MAX_CARACTERES] = "Henrique";
    float lances_pessoa, lances2_pessoa, lances3_pessoa;

    for (j = 0; j < *carroCountLeilao; j++) {
        if (strcmp(carrosleilao[j].placa, placa) == 0) {
            printf("\nPlaca do veiculo selecionado: %s", carrosleilao[j].placa);
            printf("\n\n[Regras]\nO Leilão será encerrado após três rodadas.\nCada rodada é estabelecido um novo valor minimo, que será passado para a próxima.\nO intervalo entre uma rodada e outra é de 60 segundos(1 minuto).\nCaso o cliente desista do leilão basta inserir o valor de 0 nas rodadas.\nO vencedor deverá entrar em contato com a nossa empresa através do telefone (81) 2538-2657\n\n ");
                // PRIMEIRA RODADA
            printf("Valor minimo inicial: %.2f\n", valor_inicial);
            printf("\tRodada 1:\n");
            for (roundcount1 = 0; roundcount1 < 1; roundcount1++) {
                printf("%s \n", nome_fic);
                printf("Lance: ");
                scanf("%f", &lances_fic);
                printf("\nPróximo lance em 20 segundos, fique atento....\n\n");
                Sleep(2000); // próximo lance após 20s ( 20mil milisegundos)
                printf("%s \n", nome_pessoa);
                printf("Lance: ");
                scanf("%f", &lances_pessoa);
                printf("\nPróximo lance em 20 segundos, fique atento....\n\n");
                Sleep(2000); // próximo lance após 20s ( 20mil milisegundos)

                int k;
                for (k = 0; k < *contadorUsuarioClientes; k++) { // Verificando qual foi o usuário logado e realizando os lances do leilao a partir dele.
                    if (clientes[k].id == *userId) {
                        printf("%s\n", clientes[k].nome);
                        printf("Lance: ");
                        scanf("%f", &clientes[k].lance1);

                        if (lances_fic > lances_pessoa && lances_fic > clientes[k].lance1){
                            valormin1 = lances_fic;
                        }
                        else if (lances_pessoa > lances_fic && lances_pessoa > clientes[k].lance1){
                            valormin1 = lances_pessoa;
                        }
                        else if (clientes[k].lance1 > lances_fic && clientes[k].lance1 > lances_pessoa){
                            valormin1 = clientes[k].lance1;
                        }


                    }
                }
            }


            maxvalor = valormin1; // define o valor máximo do leilao com o valor maximo da 1 rodada
            printf("Processando todos os lances e definindo um novo valor minimo.....\n\n");
            Sleep(2000);

            printf("\tRodada 2:\n");
            printf("Valor minimo inicial: %d", valormin1);
                // SEGUNDA RODADA ########################################################
            for (roundcount2 = 0; roundcount2 < 1; roundcount2++) {
                printf("\nNome: %s", nome_fic);
                printf("\nLance: ");
                scanf("%f", &lances_fic2);
                if (lances_fic2 < valormin1) {
                    printf("Você inseriu um valor menor que o minimo da rodada\n");
                }
                printf("\nPróximo lance em 20 segundos, fique atento....\n\n");
                Sleep(20000);
                printf("%s \n", nome_pessoa);
                printf("Lance: ");
                scanf("%f", &lances2_pessoa);
                if (lances2_pessoa < valormin1) {
                    printf("Você inseriu um valor menor que o minimo da rodada\n");
                }
                printf("\nPróximo lance em 20 segundos, fique atento....\n\n");
                Sleep(2000);

                int k;
                for (k = 0; k < *contadorUsuarioClientes; k++) {
                    if (clientes[k].id == *userId) {
                        printf("%s\n", clientes[k].nome);
                        printf("Lance: ");
                        scanf("%f", &clientes[k].lance2);
                        if (clientes[k].lance2 < valormin1) {
                            printf("Você inseriu um valor menor que o minimo da rodada\n");
                        }

                        if (lances_fic2 > lances2_pessoa && lances_fic2 > clientes[k].lance2 && lances_fic2 > valormin1){
                            valormin2 = lances_fic2; 
                        }
                        else if (lances2_pessoa > lances_fic2 && lances2_pessoa > clientes[k].lance2 && lances2_pessoa > valormin1){
                            valormin2 = lances2_pessoa; 
                        }
                        else if (clientes[k].lance2 > lances2_pessoa && clientes[k].lance2 > lances_fic2 && clientes[k].lance2 > valormin1){
                            valormin2 = clientes[k].lance2;  
                        }
                        else if (valormin1 > clientes[k].lance2 && valormin1 > lances2_pessoa && valormin1 > lances_fic2){
                                               
                            valormin2 = valormin1;  
                        }


                    } // final do if que verifica usuario logado
                } // final for verifica cliente

              

            } // final do for rodada2

            maxvalor = valormin2; // define o valor máximo do leilao com o valor maximo da 2 rodada
            printf("Processando todos os lances e definindo um novo valor minimo.....\n\n");
            Sleep(5000);
                // TERCEIRA RODADA ################################################################################################
            printf("\tRodada 3:\n");
            printf("Valor minimo inicial: %d", valormin2);
                
            for (roundcount3 = 0; roundcount3 < 1; roundcount3++) {
                printf("Nome: %s", nome_fic);
                printf("\nLance:");
                scanf("%f", &lances_fic3);
                if (lances_fic3 < valormin2) {
                    printf("Você inseriu um valor menor que o minimo da rodada\n");
                }
                printf("\nPróximo lance em 20 segundos, fique atento....\n\n");
                Sleep(20000);
                printf("Nome: %s", nome_pessoa);
                printf("\nLance: ");
                scanf("%f", &lances3_pessoa);
                if (lances3_pessoa < valormin2) {
                    printf("Você inseriu um valor menor que o minimo da rodada\n");
                }
                printf("\nPróximo lance em 20 segundos, fique atento....\n\n");
                Sleep(20000);

                int k;
                for (k = 0; k < *contadorUsuarioClientes; k++) {
                    if (clientes[k].id == *userId) {
                        printf("Nome: %s\n", clientes[k].nome);
                        printf("Lance: ");
                        scanf("%f", &clientes[k].lance3);
                        if (clientes[k].lance3 < valormin2) {
                            printf("Você inseriu um valor menor que o minimo da rodada\n");
                        }

                        if (lances_fic3 > lances3_pessoa && lances_fic3 > clientes[k].lance3 && lances_fic3 > valormin2){
                            valormin3 = lances_fic2;
                            maxvalor = valormin3; // define o valor máximo do leilao com o valor maximo da 3 rodada
                            printf("Parabéns %s você teve o maior lance entre os competidores e venceu o leilão, entre em contato conosco através do telefone:(81) 2538-2657 ", nome_fic);
                            printf("\nPlaca do veiculo %s", placa);
                            return 0; // Leilao foi um sucesso
                        }
                        else if (lances3_pessoa > lances_fic3 && lances3_pessoa > clientes[k].lance3 && lances3_pessoa > valormin2){
                            valormin3 = lances2_pessoa;
                            maxvalor = valormin3; // define o valor máximo do leilao com o valor maximo da 3 rodada
                            printf("Parabéns %s você teve o maior lance entre os competidores e venceu o leilão, entre em contato conosco através do telefone:(81) 2538-2657 ", nome_pessoa);
                            printf("\nPlaca do veiculo %s", placa);
                            return 0; // Leilao foi um sucesso

                        }
                        else if (clientes[k].lance3 > lances3_pessoa && clientes[k].lance3 > lances_fic3 && clientes[k].lance3 > valormin2){
                            valormin3 = clientes[k].lance3;
                            maxvalor = valormin3; // define o valor máximo do leilao com o valor maximo da 3 rodada
                            printf("Parabéns %s você teve o maior lance entre os competidores e venceu o leilão, entre em contato conosco através do telefone:(81) 2538-2657", clientes[k].nome);
                            printf("\nPlaca do veiculo %s", placa);
                            return 0; // Leilao foi um sucesso

                        }


                    } // final do if que verifica usuario logado
                } // final for verifica cliente

            }// final for da rodada 3

            
           
            

            return 1; // PLACA NAO LOCALIZADA 
        } // Comparador se a placa digitada pelo usuario está cadastrada no leilao

       
    } // Final do verificador da placa




}// final da funcao


// Funcao alugar veiculo

int alugar_veiculo(Carro carros[], int* carroCount, cliente clientes[], int* contadorUsuarioClientes, int* userId) {
    printf("\nLista de veiculos disponiveis para alugar\n\n");

    FILE* paluguel;
    paluguel = fopen("carros_aluguel.txt", "r");
    if (paluguel == NULL) {
        printf("Erro ao localizar o arquivo");
    }
    do {
        char d = fgetc(paluguel);

        // Checando o final do arquivo.
        if (feof(paluguel)) {
            break;
        }
        printf("%c", d);

    } while (1);


    // <ID> <marca> <placa> <cor> <ano> <telefone>


    char placaaluguel[MAX_CARACTERES];

    printf("\n\nInsira aqui a placa do veiculo a ser alugado: ");
    scanf("%s", placaaluguel);

    int q;
    for (q = 0; q < *carroCount;q++){
        if (strcmp(carros[q].placa, placaaluguel) == 0) {
            printf("\nPlaca do veiculo selecionado: %s\n" , carros[q].placa);
            int resposta;
            printf("Deseja alocar esse veiculo?\n1-Sim\n2-Não\nEscolha: ");
            scanf("%d", &resposta);
            if (resposta == 1) {
                printf("veiculo alocado com sucesso, por favor entre em contato com o dono do veiculo\n\n");
                break;
            }
            else if (resposta == 2) {
                printf("Você optou por não alocar esse veiculo, redirecionando para o menu principal.....\n\n");
                Sleep(2000);
                break;
            }


        } // final do if que verifica se a placa que o usuario digitou está cadastrada na struct






        

    } // final do for 
    

} // Final da funcao

// Funcao menu principal 

int menu_principal() {
    setlocale(LC_ALL, "Portuguese_Brazil"); // permitir uso da acentuação sem dar problema na hora de imprimir 

    int escolhamenu; // armazena a escolha do menu
   
    int cadastro = NULL;  // variaveis que normalmente sao carregadas com o retorno das funcoes.
    cliente clientes[MAX_USERS]; // definindo a variavel clientes do tipo struct cliente com a capacidade MAX_USERS que é definida 
    negociante negociadores[MAX_USERS]; // definindo a variavel negociadores do tipo struct negociante com a capacidade MAX_USERS que é definida
    Carro carros[MAX_CARS]; // definindo a variavel carros do tipo struct Carro com a capacidade MAX_CARS que é definida
    Carro_leilao carrosleilao[MAX_CARS]; // definindo a variavel carrosleilao do tipo struct Carro_leilao com a capacidade MAX_CARS que é definida
    int contadorUsuariosClientes = 0; // inicializando o contador de cliente com 0
    int contadorUsuariosNegociantes = 0; // iniciando o contador de negociantes com 0
    int carroCount = 0; //contador de carro aluguel
    int carroCountLeilao = 0; // contador de carro leilao
    int userId = 0; // iniciando o id do usuario com 0
    int i = 1; // posicao inicial do cadastro


    // Carregar veículos do arquivo
    carroCount = carregarCarrosAluguel(carros);
    carroCountLeilao = carregarCarrosLeilao(carrosleilao);

    // Carregar usuários do arquivo clientes
    contadorUsuariosClientes = carregarUsuariosClientes(clientes);
    contadorUsuariosNegociantes = carregarUsuariosNegociantes(negociadores);






    // inicio da funcao
   
    printf("\t\t\t\tSejam bem-vindos a Leilões & Alugueis ltda\n\n");



    //Simples loop, caso o valor não seja nenhuma disponivel o menu continua aparecendo.
    do {

        printf("[1] Realizar cadastro Negociante\n"); // Realiza o cadastro de negociante
        printf("[2] Realizar cadastro cliente\n"); // Realiza o cadastro de cliente
        printf("[3] Participar de um leilão\n"); // Para participar de um leilao, é necessario ter um cadastro como cliente.
        printf("[4] Alugar um veiculo\n"); // Para alugar um veiculo, é necessário ter um cadastro como cliente.
        printf("[5] Leiloar meu veiculo\n"); // Para leiloar um veiculo, é necessário ter um cadastro como negociante
        printf("[6] Alugar meu veiculo\n"); // Para alugar um veiculo, é necessário ter um cadastro como negociante
        printf("[7] Encerrar programa\n"); // Sai do loop e encerra o programa.


        printf("Escolha: ");
        scanf("%d", &escolhamenu);
        system("cls");




        switch (escolhamenu) {
        case 1: //Realizar cadastro Negociante
            cadastro_negociante(negociadores, &contadorUsuariosNegociantes, &userId); // funcao de cadastro para negociantes
            break;
        case 2: //Realizar cadastro cliente
            cadastro_cliente(clientes, &contadorUsuariosClientes, &userId); // funcao de cadastro para negociantes
            break;
        case 3: //Participar de um leilão
            printf("Necessário possuir um cadastro como cliente!!\n\n");
            int entrarleilao = aut_clientes(clientes, contadorUsuariosClientes, &userId);
            if (entrarleilao == 0) {
                participar_leilao(carrosleilao, &carroCountLeilao, clientes,&contadorUsuariosClientes, &userId);
                
            }
            else
                printf("Encerrando....\n\n");
            break;
        case 4: //Alugar um veiculo
            printf("Necessário possuir um cadastro como cliente!!\n\n");
            int alugarumveiculo = aut_clientes(clientes, contadorUsuariosClientes, &userId);
            if (alugarumveiculo == 0) {
                alugar_veiculo(carros, &carroCount, clientes, &contadorUsuariosClientes, &userId);
            }
            else
                printf("Encerrando...\n\n");
            break;
        case 5: //Leiloar meu veiculo
            printf("Necessário possuir um cadastro como negociador!!\n\n");
            int leilaoveiculo = aut_negociantes(negociadores, contadorUsuariosNegociantes, &userId); // Eu carrego a variavel leilaoveiculo com o RETORNO da funcao aut_negociantes.
            if (leilaoveiculo == 0){
                cadastrarVeiculoLeilao(carrosleilao, &carroCountLeilao, &userId);
            }
            else
                printf("Encerrando....\n\n");


            break;
        case 6: // Alugar meu veiculo
            printf("Necessário possuir um cadastro como negociador!!\n\n");
            int aluguelveiculo = aut_negociantes(negociadores, contadorUsuariosNegociantes, &userId); // Eu carrego a variavel aluguelveiculo com o RETORNO da funcao aut_negociantes.
            if (aluguelveiculo == 0) { // se o valor retornado for igual a 0, ele ira executar a funcao de cadastro dos veiculos para aluguel
                cadastrarVeiculoAluguel(carros, &carroCount, &userId);
            }
            else // se não ele irá encerrrar o programa, medida de seguranca pois a senha inserida foi errada.
                printf("Encerrando...\n\n"); // 


            break;
        case 7: // Encerrar programa
            return 7;
            break;
        default:
            printf("Por favor insira uma escolha valida!!!\n");

        }







    } while (escolhamenu < 1 || escolhamenu >7);


}

int main() {
    setlocale(LC_ALL, "Portuguese_Brazil"); // permitir uso da acentuação sem dar problema na hora de imprimir 

    int loop;

    do {
        loop = menu_principal();

    } while (loop != 7);


    return 0;
}