ejercicio_c_cine.c

/*
  ____          _____               _ _           _
 |  _ \        |  __ \             (_) |         | |
 | |_) |_   _  | |__) |_ _ _ __ _____| |__  _   _| |_ ___
 |  _ <| | | | |  ___/ _` | '__|_  / | '_ \| | | | __/ _ \
 | |_) | |_| | | |  | (_| | |   / /| | |_) | |_| | ||  __/
 |____/ \__, | |_|   \__,_|_|  /___|_|_.__/ \__, |\__\___|
         __/ |                               __/ |
        |___/                               |___/

____________________________________
/ Si necesitas ayuda, contáctame en \
\ https://parzibyte.me               /
 ------------------------------------
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||----w |
                ||     ||
Creado por Parzibyte (https://parzibyte.me). Este encabezado debe mantenerse intacto,
excepto si este es un proyecto de un estudiante.
*/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

// En C no podemos tener cadenas sin límite, por eso definimos un límite considerable
#define MAXIMA_LONGITUD_CADENA 101


// El struct que guarda los datos de las películas
struct detalleDePelicula {
    char nombre[MAXIMA_LONGITUD_CADENA];
    char horaInicio[MAXIMA_LONGITUD_CADENA];
    char cine[MAXIMA_LONGITUD_CADENA];
    char sala[MAXIMA_LONGITUD_CADENA];
    char dia[MAXIMA_LONGITUD_CADENA];
    char clasificacion;
    // Aquí hay un struct dentro de un struct, pues vamos a guardar los datos en una "pila" en donde este dato puede tener
    // otro dato en "siguiente"
    struct detalleDePelicula *siguiente;
};

// El inicio de la pila es un nodo superior que al inicio es NULL
struct detalleDePelicula *superior = NULL;


// Función que regresará un detalle de película en caso de encontrarla
struct detalleDePelicula *
buscar(char horaInicio[MAXIMA_LONGITUD_CADENA], char cine[MAXIMA_LONGITUD_CADENA], char sala[MAXIMA_LONGITUD_CADENA],
       char dia[MAXIMA_LONGITUD_CADENA]) {
    // Vamos a usar este temporal para leer toda la pila
    struct detalleDePelicula *temporal = superior;
    // Recorremos toda la pila
    while (temporal != NULL) {
        // Si encontramos que coincide lo buscado con lo que hay en la pila en este momento, entonces regresamos el detalle
        if (
                strcmp(cine, temporal->cine) == 0 &&
                strcmp(sala, temporal->sala) == 0 &&
                strcmp(horaInicio, temporal->horaInicio) == 0 &&
                strcmp(dia, temporal->dia) == 0
                ) {
            return temporal;
        }
        // Y vamos avanzando
        temporal = temporal->siguiente;
    }
    // En caso de terminar de recorrer la pila y que no haya nada, regresamos NULL
    return NULL;
}


// Agrega una película por primera vez
void
agregarPorPrimeraVez(char nombre[MAXIMA_LONGITUD_CADENA], char horaInicio[MAXIMA_LONGITUD_CADENA],
                     char cine[MAXIMA_LONGITUD_CADENA], char sala[MAXIMA_LONGITUD_CADENA],
                     char dia[MAXIMA_LONGITUD_CADENA], char clasificacion) {
    // Requerir RAM para alojar este detalle de película
    struct detalleDePelicula *d = malloc(sizeof(struct detalleDePelicula));
    // Llenamos el struct. Copiamos el nombre, hora, etcétera
    memcpy(d->nombre, nombre, MAXIMA_LONGITUD_CADENA);
    memcpy(d->horaInicio, horaInicio, MAXIMA_LONGITUD_CADENA);
    memcpy(d->cine, cine, MAXIMA_LONGITUD_CADENA);
    memcpy(d->sala, sala, MAXIMA_LONGITUD_CADENA);
    memcpy(d->dia, dia, MAXIMA_LONGITUD_CADENA);
    d->clasificacion = clasificacion;
    // Y como estamos agregando un elemento, ahora éste es el superior, y su siguiente es el que antes era el superior
    d->siguiente = superior;
    superior = d;
}


// Si ya existe, la actualiza. Si no, la agrega por primera vez
void agregarOActualizar(char nombre[MAXIMA_LONGITUD_CADENA], char horaInicio[MAXIMA_LONGITUD_CADENA],
                        char cine[MAXIMA_LONGITUD_CADENA], char sala[MAXIMA_LONGITUD_CADENA],
                        char dia[MAXIMA_LONGITUD_CADENA], char clasificacion) {
    // Buscar película con estos datos
    struct detalleDePelicula *existente = buscar(horaInicio, cine, sala, dia);
    // Si no existe, lo agregamos por primera vez
    if (existente == NULL) {
        agregarPorPrimeraVez(nombre, horaInicio, cine, sala, dia, clasificacion);
        printf("\nPelicula agregada\n");
    } else {
        // Si no, solo actualizamos (y lo indicamos)
        memcpy(existente->nombre, nombre, MAXIMA_LONGITUD_CADENA);
        memcpy(existente->horaInicio, horaInicio, MAXIMA_LONGITUD_CADENA);
        memcpy(existente->cine, cine, MAXIMA_LONGITUD_CADENA);
        memcpy(existente->sala, sala, MAXIMA_LONGITUD_CADENA);
        memcpy(existente->dia, dia, MAXIMA_LONGITUD_CADENA);
        existente->clasificacion = clasificacion;
        printf("\nPelicula ya existia, fue reemplazada\n");
    }
}


// Esta función se reutiliza varias veces. Simplemente recibe un detalle de película y lo imprime
void imprimirPelicula(struct detalleDePelicula *detalleDePelicula) {
    printf("Nombre: %s, hora: %s, cine: %s, sala: %s, dia: %s, clasificacion: %c\n", detalleDePelicula->nombre,
           detalleDePelicula->horaInicio, detalleDePelicula->cine, detalleDePelicula->sala, detalleDePelicula->dia,
           detalleDePelicula->clasificacion);
}

// Esta función busca una película existente con los datos (usando la función "buscar" vista anteriormente
// En caso de que encuentre datos, invoca a "imprimirPelicula" vista anteriormente de igual modo
void desplegarInformacion(char horaInicio[MAXIMA_LONGITUD_CADENA], char cine[MAXIMA_LONGITUD_CADENA],
                          char sala[MAXIMA_LONGITUD_CADENA], char dia[MAXIMA_LONGITUD_CADENA]) {
    printf("\n--Resultados de busqueda por hora, cine, sala y dia --\n");
    struct detalleDePelicula *existente = buscar(horaInicio, cine, sala, dia);
    if (existente == NULL) {
        printf("No hay pelicula para los datos proporcionados");
    } else {
        imprimirPelicula(existente);
    }
}

// Recorre toda la pila de películas y en caso de que encuentre una en la que coincide el nombre, la imprime
void buscarPeliculaPorNombre(char nombre[MAXIMA_LONGITUD_CADENA]) {
    printf("\n--Resultados de busqueda por nombre --\n");
    struct detalleDePelicula *temporal = superior;
    while (temporal != NULL) {
        if (strcmp(nombre, temporal->nombre) == 0) {
            imprimirPelicula(temporal);
        }
        temporal = temporal->siguiente;
    }
}

// Lo mismo que "buscarPeliculaPorNombre" pero ahora también busca por día y clasificación
void buscarPeliculaPorDiaYClasificacion(char dia[MAXIMA_LONGITUD_CADENA], char clasificacion) {
    printf("\n--Resultados de busqueda por dia y clasificacion --\n");
    struct detalleDePelicula *temporal = superior;
    while (temporal != NULL) {
        if (strcmp(dia, temporal->dia) == 0 && temporal->clasificacion == clasificacion) {
            imprimirPelicula(temporal); // <-- Aquí reusamos la función "imprimirPelicula"
        }
        temporal = temporal->siguiente;
    }
}

int main() {
    // Declarar variables que vamos a reusar durante toda la ejecución
    int eleccion;
    char nombre[MAXIMA_LONGITUD_CADENA];
    char horaInicio[MAXIMA_LONGITUD_CADENA];
    char cine[MAXIMA_LONGITUD_CADENA];
    char sala[MAXIMA_LONGITUD_CADENA];
    char dia[MAXIMA_LONGITUD_CADENA];
    char clasificacion;
    // Ciclo infinito. Se termina cuando se hace un "return"
    while (1) {
        printf("\n1. Registrar pelicula\n2. Desplegar informacion que se proyecta en la sala de un cine\n3. Buscar pelicula\n4. Listar peliculas en cierto dia por clasificacion de edad\n5. Salir\nSeleccione:");
        scanf("%d", &eleccion);
        while (getchar() !=
               '\n'); // <-- Limpiar el búfer de entrada, esto es porque en ocasiones hay errores al usar scanf
        // Si la elección es 5, salimos inmediatamente
        if (eleccion == 5) {
            return 0;
        }
        // Si no, evaluamos la elección
        switch (eleccion) {
            // Caso 1: registrar película
            case 1:
                // Solicitar todos los datos
                printf("Ingresa el nombre: ");
                // Leer lo que el usuario ha escrito
                fgets(nombre, MAXIMA_LONGITUD_CADENA - 1, stdin);
                // Pero remover el salto de línea (Enter) que hay al final
                // (eso de remover y leer se repite varias veces)
                strtok(nombre, "\n");
                printf("Ingresa la hora de inicio:");
                fgets(horaInicio, MAXIMA_LONGITUD_CADENA - 1, stdin);
                strtok(horaInicio, "\n");
                printf("Ingresa el cine:");
                fgets(cine, MAXIMA_LONGITUD_CADENA - 1, stdin);
                strtok(cine, "\n");
                printf("Ingresa la sala:");
                fgets(sala, MAXIMA_LONGITUD_CADENA - 1, stdin);
                strtok(sala, "\n");
                printf("Ingresa el dia en formato YYYY-MM-DD:");
                fgets(dia, MAXIMA_LONGITUD_CADENA - 1, stdin);
                strtok(dia, "\n");
                // Aquí no usamos fgets porque es un solo caracter, no una cadena
                printf("Ingresa la clasificacion (A, B o C):");
                scanf("%c", &clasificacion);
                // Invocamos a la función agregarOActualizar con los datos definidos
                agregarOActualizar(nombre, horaInicio, cine, sala, dia, clasificacion);
                break;
            case 2:
                // De aquí en adelante son cosas similares
                printf("Ingresa la hora de inicio:");
                fgets(horaInicio, MAXIMA_LONGITUD_CADENA - 1, stdin);
                strtok(horaInicio, "\n");
                printf("Ingresa el cine:");
                fgets(cine, MAXIMA_LONGITUD_CADENA - 1, stdin);
                strtok(cine, "\n");
                printf("Ingresa la sala:");
                fgets(sala, MAXIMA_LONGITUD_CADENA - 1, stdin);
                strtok(sala, "\n");
                printf("Ingresa el dia en formato YYYY-MM-DD:");
                fgets(dia, MAXIMA_LONGITUD_CADENA - 1, stdin);
                strtok(dia, "\n");
                desplegarInformacion(horaInicio, cine, sala, dia);
                break;
            case 3:
                printf("Ingresa el nombre:");
                fgets(nombre, MAXIMA_LONGITUD_CADENA - 1, stdin);
                strtok(nombre, "\n");
                buscarPeliculaPorNombre(nombre);
                break;
            case 4:
                printf("Ingresa el dia en formato YYYY-MM-DD:");
                fgets(dia, MAXIMA_LONGITUD_CADENA - 1, stdin);
                strtok(dia, "\n");
                printf("Ingresa la clasificacion (A, B o C):");
                scanf("%c", &clasificacion);
                buscarPeliculaPorDiaYClasificacion(dia, clasificacion);
                break;
            default:
                printf("Opcion invalida");
                break;
        }
    }
}