Untitled

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>
#include <ctype.h>
#include <windows.h>
#define VERMELHO    12
#define CIANO       11
#define MAX_ESPACOS 4
#define MAX_NOME_ESPACO 20

// Estrutura do item da lista
typedef enum { MORADOR, APARTAMENTO } TipoItem;

typedef struct {
    TipoItem tipo;
    union {
        // Estrutura com as informações do morador
        struct {
            char nome[50];
            int idade;
            int cpf;
        } morador;
        
        // Estrutura do apartamento
        struct {
            int numeroEndereco;
            int numeroQuartos;
            int numeroBanheiros;
            float valorAluguel; // Novo campo para o valor do aluguel
            char nomeMorador[50]; // Nome do morador que ocupa o apartamento
        } apartamento;
    } info;
} ItemLista;

// Estrutura da lista de moradores
typedef struct NoLista {
    ItemLista item;
    struct NoLista *prox;
} NoLista;

typedef struct {
    NoLista *primeiro;
    int tamanho;
} ListaMoradores;

// Estrutura da lista de apartamentos
typedef struct NoListaApartamento {
    ItemLista item;
    struct NoListaApartamento *prox;
} NoListaApartamento;

typedef struct {
    NoListaApartamento *primeiro;
    int tamanho;
} ListaApartamentos;

// Estrutura de espaço comum
typedef struct EspacoComum {
    char nome[MAX_NOME_ESPACO];
    int disponivel;
    char horario[MAX_NOME_ESPACO];
    int limite_usuarios;
    int usuarios_presentes;
} EspacoComum;

// Estrutura de nó para a lista de espaços comuns
struct NoListae {
    EspacoComum espaco;
    struct NoListae *prox;
};

// Função para criar a lista
ListaMoradores* criarListaMoradores() {
    ListaMoradores *lista = (ListaMoradores*) malloc(sizeof(ListaMoradores));
    if (lista != NULL) {
        lista->primeiro = NULL;
        lista->tamanho = 0;
    }
    return lista; 
}

ListaApartamentos* criarListaApartamentos() {
    ListaApartamentos *lista = (ListaApartamentos*) malloc(sizeof(ListaApartamentos));
    if (lista != NULL) {
        lista->primeiro = NULL;
        lista->tamanho = 0;
    }
    return lista; 
}

// Função para colocar um elemento na lista
void inserirMorador(ListaMoradores *lista, ItemLista novoMorador) {
    NoLista *novoNo = (NoLista*) malloc(sizeof(NoLista));
    if (novoNo == NULL) {
        printf("Erro na alocação de memória\n");
        return;
    }
    novoNo->item = novoMorador;
    novoNo->prox = lista->primeiro;
    lista->primeiro = novoNo;
    lista->tamanho++;
}

void inserirApartamento(ListaApartamentos *lista, ItemLista novoApartamento) {
    NoListaApartamento *novoNo = (NoListaApartamento*) malloc(sizeof(NoListaApartamento));
    if (novoNo == NULL) {
        printf("Erro na alocação de memória\n");
        return;
    }
    novoNo->item = novoApartamento;
    novoNo->prox = lista->primeiro;
    lista->primeiro = novoNo;
    lista->tamanho++;
}

// Função de busca
NoLista* buscarMorador(ListaMoradores *lista, char nome[]) {
    NoLista *atual = lista->primeiro;
    while (atual != NULL) {
        if (atual->item.tipo == MORADOR && strcmp(atual->item.info.morador.nome, nome) == 0) {
            return atual;
        }
        atual = atual->prox;
    }
    return NULL;
}

NoListaApartamento* buscarApartamento(ListaApartamentos *lista, int numeroEndereco) {
    NoListaApartamento *atual = lista->primeiro;
    while (atual != NULL) {
        if (atual->item.tipo == APARTAMENTO && atual->item.info.apartamento.numeroEndereco == numeroEndereco) {
            return atual;
        }
        atual = atual->prox;
    }
    return NULL;
}

// Função de remoção 
void removerMorador(ListaMoradores *lista, char nome[]) {
    NoLista *anterior = NULL;
    NoLista *atual = lista->primeiro;
    
    while (atual != NULL) {
        if (atual->item.tipo == MORADOR && strcmp(atual->item.info.morador.nome, nome) == 0) {
            if (anterior == NULL) {
                lista->primeiro = atual->prox;
            } else {
                anterior->prox = atual->prox;
            }
            free(atual);
            lista->tamanho--;
            return;
        }
        anterior = atual;
        atual = atual->prox;
    }
}

void removerApartamento(ListaApartamentos *lista, int numeroEndereco) {
    NoListaApartamento *anterior = NULL;
    NoListaApartamento *atual = lista->primeiro;
    
    while (atual != NULL) {
        if (atual->item.tipo == APARTAMENTO && atual->item.info.apartamento.numeroEndereco == numeroEndereco) {
            if (anterior == NULL) {
                lista->primeiro = atual->prox;
            } else {
                anterior->prox = atual->prox;
            }
            free(atual);
            lista->tamanho--;
            return;
        }
        anterior = atual;
        atual = atual->prox;
    }
}

// Função para verificar se uma string contém apenas letras ou espaços
int contemApenasLetras(const char *str) {
    while (*str) {
        if (!isalpha(*str) && *str != ' ') { // Permitir espaços no nome
            return 0;
        }
        str++;
    }
    return 1;
}

// Função de verificação de disponibilidade dos apartamentos
void verificarDisponibilidadeApartamentos(ListaApartamentos *lista, ListaMoradores *listaMoradores) {
    NoListaApartamento *atual = lista->primeiro;
    printf("Lista de apartamentos disponíveis:\n");
    int num = 1;
    while (atual != NULL) {
        // Verificar se o apartamento está ocupado
        NoLista *morador = buscarMorador(listaMoradores, atual->item.info.apartamento.nomeMorador);
        if (morador == NULL) {
            printf("%d. Número de Endereço: %d, Quartos: %d, Banheiros: %d, Valor do Aluguel: R$ %.2f\n", 
                    num,
                    atual->item.info.apartamento.numeroEndereco,
                    atual->item.info.apartamento.numeroQuartos,
                    atual->item.info.apartamento.numeroBanheiros,
                    atual->item.info.apartamento.valorAluguel);
            num++;
        }
        atual = atual->prox;
    }
}

// Função de registro de reserva
void registrarReserva(ListaMoradores *listaMoradores, ListaApartamentos *listaApartamentos, char nome[], int numeroEndereco) {
    NoListaApartamento *apartamento = buscarApartamento(listaApartamentos, numeroEndereco);
    
    if (apartamento == NULL) {
        printf("Apartamento não encontrado.\n");
        return;
    }
    
    // Verificar se o nome contém apenas letras
    if (!contemApenasLetras(nome)) {
        printf("O nome do morador deve conter apenas letras.\n");
        return;
    }
    
    strcpy(apartamento->item.info.apartamento.nomeMorador, nome);
    
    printf("Reserva efetuada com sucesso:\n");
    printf("Apartamento: %d\n", apartamento->item.info.apartamento.numeroEndereco);

    removerApartamento(listaApartamentos, numeroEndereco);

    printf("\nApartamentos disponíveis para aluguel:\n");
    verificarDisponibilidadeApartamentos(listaApartamentos, listaMoradores);
}

// Função para atualizar informações do morador
void atualizarMorador(ListaMoradores *listaMoradores, char nomeAntigo[], char novoNome[], int novaIdade, int novoCpf) {
    NoLista *morador = buscarMorador(listaMoradores, nomeAntigo);
    if (morador == NULL) {
        printf("Morador não encontrado.\n");
        return;
    }

    // Atualizar informações do morador
    strcpy(morador->item.info.morador.nome, novoNome);
    morador->item.info.morador.idade = novaIdade;
    morador->item.info.morador.cpf = novoCpf;

    printf("Informações do morador atualizadas com sucesso.\n");
}

// Função para inserir um novo espaço comum na lista de espaços comuns
void inserirEspacoComum(struct NoListae **lista, EspacoComum novoEspaco) {
    struct NoListae *novoNo = (struct NoListae*) malloc(sizeof(struct NoListae));
    if (novoNo == NULL) {
        printf("Erro na alocação de memória\n");
        return;
    }
    novoNo->espaco = novoEspaco;
    novoNo->prox = *lista;
    *lista = novoNo;
}

// Função para reservar um espaço comum
void reservarEspaco(struct NoListae **lista, int opcao) {
    struct NoListae *atual = *lista;
    int indice = 1;
    while (atual != NULL) {
        if (indice == opcao) {
            if (atual->espaco.disponivel && atual->espaco.usuarios_presentes < atual->espaco.limite_usuarios) {
                atual->espaco.usuarios_presentes++;
                printf("Espaço '%s' reservado com sucesso.\n", atual->espaco.nome);
            } else {
                printf("O espaço '%s' está lotado ou não está disponível para reserva no momento.\n", atual->espaco.nome);
            }
            return;
        }
        atual = atual->prox;
        indice++;
    }
}

// Função para imprimir texto colorido
void imprimirTextoColorido(const char *texto, int cor) {
    HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleTextAttribute(hConsole, cor);
    printf("%s", texto);
    SetConsoleTextAttribute(hConsole, 7); // Resetar para a cor padrão
}

int main() {
    setlocale(LC_ALL, "Portuguese");
    
    // Cabeçalho
    imprimirTextoColorido("-=-= Centro Universitário do Rio São Francisco =-=-\n", CIANO);
    imprimirTextoColorido("\nAlunos:\n", VERMELHO);
    imprimirTextoColorido("\tAnthonio Calazans\n", CIANO);
    imprimirTextoColorido("\tAnthony dos Santos Martins\n", CIANO);
    imprimirTextoColorido("\tGlauber Lima\n", CIANO);
    imprimirTextoColorido("\tGuilherme Augusto\n", CIANO);
    imprimirTextoColorido("\tGuilherme Leite\n", CIANO);
    imprimirTextoColorido("\tIago Kauan\n", CIANO);
    imprimirTextoColorido("\tYuri A moreira\n", CIANO);
    imprimirTextoColorido("\nProfessora:\n", VERMELHO);
    imprimirTextoColorido("\tMirthys Marinho\n\n", CIANO);
    
    system("pause");
    system("cls");
    
    // Regras do condomínio
    puts("\033[0;31mRegras do condomínio:\033[0m");
    puts("\033[0;36m");
    puts("1 - É proibido fazer barulho após as 22h.");
    puts("2 - Não é permitido estacionar em locais não destinados a estacionamento.");
    puts("3 - O uso da área de lazer deve ser feito de forma a não atrapalhar os demais moradores.\033[0m\n");
	
    system("pause");
    system("cls");
    
    
    // Criando listas de moradores e apartamentos
    ListaMoradores *listaMoradores = criarListaMoradores();
    ListaApartamentos *listaApartamentos = criarListaApartamentos();
    
    // Inserindo apartamentos com valores base
    ItemLista novoApartamento;
    novoApartamento.tipo = APARTAMENTO;
    
    novoApartamento.info.apartamento.numeroEndereco = 101;
    novoApartamento.info.apartamento.numeroQuartos = 2;
    novoApartamento.info.apartamento.numeroBanheiros = 2;
    novoApartamento.info.apartamento.valorAluguel = 1000.00;
    inserirApartamento(listaApartamentos, novoApartamento);
    
    novoApartamento.info.apartamento.numeroEndereco = 201;
    novoApartamento.info.apartamento.numeroQuartos = 3;
    novoApartamento.info.apartamento.numeroBanheiros = 2;
    novoApartamento.info.apartamento.valorAluguel = 1500.00;
    inserirApartamento(listaApartamentos, novoApartamento);
    
    novoApartamento.info.apartamento.numeroEndereco = 301;
    novoApartamento.info.apartamento.numeroQuartos = 1;
    novoApartamento.info.apartamento.numeroBanheiros = 1;
    novoApartamento.info.apartamento.valorAluguel = 800.00;
    inserirApartamento(listaApartamentos, novoApartamento);
    
    // Verificando disponibilidade dos apartamentos
    printf("Apartamentos disponíveis para aluguel:\n");
    verificarDisponibilidadeApartamentos(listaApartamentos, listaMoradores);
    
    // Solicitar ao usuário registrar reservas
    char nomeMorador[50];
    int enderecoApartamento;
    char opcao;
    do {
        printf("\nDigite o nome do morador para registrar a reserva: ");
        fgets(nomeMorador, 50, stdin);
        nomeMorador[strcspn(nomeMorador, "\n")] = 0; // Remover a quebra de linha
        
        printf("Digite o número do apartamento para a reserva: ");
        scanf("%d", &enderecoApartamento);
        
        registrarReserva(listaMoradores, listaApartamentos, nomeMorador, enderecoApartamento);
        
        // Verificar se há apartamentos disponíveis
        if (listaApartamentos->tamanho == 0) {
            printf("Desculpe, todos os apartamentos estão ocupados no momento. Por favor, volte mais tarde.\n");
            break;
        }

        printf("\nDeseja fazer outra reserva? (S/N): ");
        scanf(" %c", &opcao);
        getchar(); // Limpar o buffer de entrada
    } while (opcao == 'S' || opcao == 's');
    
    // Área de lazer:
    struct NoListae **listaEspacos = (struct NoListae **)malloc(sizeof(struct NoListae *));
    if (listaEspacos == NULL) {
        printf("Erro: Falha na alocação de memória para a lista de espaços.\n");
        return 1;
    }
    
    struct EspacoComum espacos[MAX_ESPACOS] = {
        {"Piscina", 1, "09:00 - 18:00", 10, 0},
        {"Academia", 1, "06:00 - 22:00", 10, 0},
        {"Salao_de_festas", 1, "08:00 - 00:00", 10, 0},
        {"Quadra", 1, "09:00 - 22:00", 10, 0},
    };

    int i = 0;
    do {
        inserirEspacoComum(&(*listaEspacos), espacos[i]);
        i++;
    } while (i < MAX_ESPACOS);

    do {
        printf("\nDeseja reservar uma área de lazer? (S/N): ");
        scanf(" %c", &opcao);

        if (opcao == 'S' || opcao == 's') {
            do {
                printf("Areas de Lazer Disponíveis:\n");
                puts("\n");
                struct NoListae *atual = *listaEspacos;
                int indice = 1;
                while (atual != NULL) {
                    if (atual->espaco.disponivel && atual->espaco.usuarios_presentes < atual->espaco.limite_usuarios) {
                        printf("%d. %s\n", indice++, atual->espaco.nome);
                    }
                    atual = atual->prox;
                }
                printf("\nEscolha um espaço pelo número correspondente (ou 0 para sair):\n");
                printf("Opção: ");
                scanf("%d", &opcao);
                getchar(); // Limpar o buffer de entrada

                switch (opcao) {
                    case 0:
                        printf("\nSaindo...\n");
                        break;
                    case 1:
                    case 2:
                    case 3:
                    case 4:
                        printf("\nOpção escolhida: %d\n", opcao);
                        reservarEspaco(&(*listaEspacos), opcao);
                        break;
                    default:
                        printf("\nOpção inválida! Tente novamente.\n");
                }
            } while (opcao != 0);
        } else if (opcao != 'N' && opcao != 'n') {
            break;
        }
    } while (opcao == 'S' || opcao == 's');
    
    printf("Pressione qualquer tecla para sair...\n");
    getchar(); // Esperar que o usuário pressione qualquer tecla para sair

    return 0;
}