/******************************************************************

*
* Mdulo: Cine
*
* Descripcin:
* Mdulo de gestin de pelculas de un cine.
* Implementa los siguientes datos:
* - titulo: titulo de la pelcula
* - entradas: entradas vendidas (max. 20)
* - fecha: fecha de emisin
*
fecha.dia
*
fecha.mes
*
fecha.anno
* - horario: hora de emisin de la pelcula
*
horario.hora
*
horario.minuto
* - genero: comedia, drama, terror o blica
*
* y las siguientes operaciones:
* - alta_pelicula:alta de pelcula
* - vender_entradas: vender entradas
* - lista_peliculas: Listado de pelculas
* - calendario: Mostrar calendario de pelculas
**********************************************************************/
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include "Cine.h"
#include "Calendario.h"
int numPeliculas = 0;
int auxIndice = 0;
int gen;
TipoCharGenero auxGenero;
TipoVectorPelicula vectorAuxiliar;
TipoCalendario calendario;
int orden = 0;
/*============================================================================
Procedimiento:
Dar alta a pelculas
Validaciones:
La pelcula a la que se pretende dar alta no est ya grabada (titulo)
La fecha y hora introducidas son vlidas
No existe ninguna pelcula programada en la fecha solicitada
El gnero introducido se corresponde con uno de los 4 vlidos
==============================================================================*/
void TipoGestion::CrearPelicula(TipoVectorPelicula vectorPeliculas) {
TipoPelicula pelicula;
InicializarPelicula( pelicula) ;
/*-- Comprobamos que no tengamos guardadas ya el nmero
mximo de pelculas --*/
if (ComprobarNumPeliculas()) {
system("cls");
printf( "
ALTA DE PELICULAS\n" );
printf( " ============================\n" );
printf( "\n" );
/*-- Comprobamos que el ttulo no est repetido --*/
do {
printf( "Titulo de la pelicula: " );
scanf( " %[^\n]s",pelicula.titulo );

} while (TituloRepetido(pelicula, vectorPeliculas));

/*-- Comprobamos que la fecha sea correcta y no est ocupada --*/
do {
try {
printf( "\nDia de la pelicula: " );
fflush(stdin);
if (scanf( " %2d", &pelicula.fecha.dia ) == 0) {
throw true;
}
printf( "\nMes de la pelicula: " );
fflush(stdin);
if (scanf( " %2d", &pelicula.fecha.mes ) == 0) {
throw true;
}
printf( "\nAnno de la pelicula: " );
fflush(stdin);
if (scanf( " %4d", &pelicula.fecha.anno ) == 0) {
throw true;
}
} catch (bool e) {
pelicula.fecha.dia = 0;
pelicula.fecha.mes = 0;
pelicula.fecha.anno = 0;
}
} while (!(calendario.EsCorrecta( pelicula.fecha.dia, pelicula.fecha.mes, pelicula.fecha.anno ))
|| (FechaOcupada( pelicula.fecha, vectorPeliculas )));
/*-- Comprobamos que sea una hora vlida --*/
do {
try {
printf( "\nHora de la pelicula: " );
fflush(stdin);
if (scanf( " %d", &pelicula.horario.hora ) == 0) {
throw true;
}
printf( "\nMinuto de la pelicula: " );
fflush(stdin);
if (scanf( " %d", &pelicula.horario.minuto ) == 0) {
throw true;
}
} catch (bool e) {
/* asignamos valores erneos, para que la funcin ComprobarHorario
de false */
pelicula.horario.hora = 24;
pelicula.horario.minuto = 60;
}
} while (!(ComprobarHorario( pelicula.horario )));
/*-- Comprobamos que sea un gnero vlido --*/
do {
gen = 0;
printf( "\nGenero de la pelicula: " );
scanf( " %s", &auxGenero );
} while (!(ComprobarGenero( auxGenero, gen ))); /* Pasamos gen por referencia */
pelicula.genero = TipoGenero(gen);
/*-- asignamos la pelcula a su posicin dentro del vector --*/
vectorPeliculas[auxIndice] = pelicula;
OrdenaVectorPeliculas( vectorPeliculas, auxIndice );
} else {
/* else if (ComprobarNumPelicula */
printf( "\nNo puede aadir ms peliculas\n" );
printf( "\nSe admiten hasta peliculas\n" );
}
/* fin if (ComprobarNumPelicula */
}
/
*====================================================================================

======
Procedimiento: OrdenaVectorPeliculas
Ordena vectorPeliculas por fecha
=====================================================================================
=====*/
void TipoGestion::OrdenaVectorPeliculas( TipoVectorPelicula vectorPeliculas, int auxIndice ) {
TipoPelicula auxPelicula;
int aux = auxIndice-1;
while ((auxIndice>0) && (EsPosterior(vectorPeliculas[aux].fecha,vectorPeliculas[auxIndice].fecha))) {
auxPelicula = vectorPeliculas[aux];
vectorPeliculas[aux] = vectorPeliculas[auxIndice];
vectorPeliculas[auxIndice] = auxPelicula;
auxIndice --;
aux --;
}
}
/
*====================================================================================
======
Funcin:ComprobarHorario
Comprobar que la hora introducida es vlida
True:
False: Imprime mensaje de error
=====================================================================================
=====*/
bool TipoGestion::ComprobarHorario( TipoHorario horario) {
if (horario.hora<0 || horario.hora > 23 || horario.minuto < 0 || horario.minuto > 59) {
printf( "\nLa hora introducida no es correcta" );
printf( "\nIntroduzca un nuevo horario\n" );
return false;
} else {
return true;
}
}
/*====================================================================
Funcin: TituloRepetido
Comprueba si el ttulo de la pelcula est repetido
True: Asigna a la global auxIndice la posicin en el vector
vectorPeliculas del primer elemento libre (titulo = "")
False: Imprime mensaje de error
====================================================================*/
bool TipoGestion::TituloRepetido( TipoPelicula pelicula, TipoVectorPelicula vectorPeliculas) {
for ( int i = 0; i < maxPeliculas; i++) {
if (strcmp (vectorPeliculas[i].titulo, "") == 0) {
auxIndice = i;
/* Posicin del primer elemento del vector libre */
return false;
} else if ( strcmp (pelicula.titulo, vectorPeliculas[i].titulo) == 0) {
printf( "\nYa ha dado alta a una pelicula con ese titulo" );
printf( "\nIntroduzca un nuevo titulo\n" );
return true;
}
}
return false;
}
/*====================================================================
Funcion:comprobarNumPeliculas
Comprueba si se ha rebasado el mximo de pelculas admitidas
====================================================================*/
bool TipoGestion::ComprobarNumPeliculas() {
if (numPeliculas < maxPeliculas) {
return true;

} else {
return false;
}
}
/*====================================================================
Funcin: FechaOcupada
Comprueba si una fecha est ocupada
True: Imprime mensaje de error
False:
====================================================================*/
bool TipoGestion::FechaOcupada( TipoFecha fecha, TipoVectorPelicula vectorPeliculas) {
for ( int i = 0; i < maxPeliculas; i++) {
if ((vectorPeliculas[i].fecha.dia == fecha.dia) && (vectorPeliculas[i].fecha.mes == fecha.mes) &&
(vectorPeliculas[i].fecha.anno == fecha.anno)) {
printf( "\nYa hay una pelcula programada para esta fecha" );
printf( "\nIntroduzca una nueva fecha\n" );
return true;
}
}
return false;
}
/*============================================================================
Funcin: ComprobarGenero
Comprueba si el gnero introducido es correcto.
True: Devuelve el int que corresponde a la posicin en el tipo enum del gnero
False: Imprime mensaje de error
============================================================================*/
bool TipoGestion::ComprobarGenero( TipoCharGenero genero, int & gen ) {
if (strcmp(genero, "comedia")==0) {
gen = 0;
return true;
} else if (strcmp(genero, "drama")==0) {
gen = 1;
return true;
} else if (strcmp(genero, "terror")==0) {
gen = 2;
return true;
} else if (strcmp(genero, "belica")==0) {
gen = 3;
return true;
} else {
printf( "\nEl gnero debe ser comedia, drama, terror o belica" );
printf( "\nIntroduzca un nuevo genero\n" );
return false;
}
}
/*===================================================================
Procedimiento: InicializarVectorPeliculas
===================================================================*/
void TipoGestion::InicializarVectorPeliculas(TipoVectorPelicula vectorPeliculas) {
TipoPelicula pelicula;
InicializarPelicula( pelicula );
for (int i = 0; i < maxPeliculas; i++) {
/* strcpy(vectorPeliculas[i].titulo, "");
vectorPeliculas[i].entradas = 0;
vectorPeliculas[i].fecha.dia = 0;
vectorPeliculas[i].fecha.mes = 0;
vectorPeliculas[i].fecha.anno = 0;
vectorPeliculas[i].horario.hora = 0;
vectorPeliculas[i].horario.minuto = 0; */
vectorPeliculas[i] = pelicula;
}
}

/* ===================================================================
Procedimiento: InicializarPelicula
Procedimiento para inicializar el registro pelicula
===================================================================*/
void TipoGestion::InicializarPelicula(TipoPelicula & pelicula) {
strcpy(pelicula.titulo, "" );
pelicula.entradas = 0;
pelicula.fecha.dia = 0;
pelicula.fecha.mes = 0;
pelicula.fecha.anno = 0;
pelicula.horario.hora = 0;
pelicula.horario.minuto = 0;
}
/*===================================================================
Procedimiento: MostraCalendario
Muestra calendario de un mes/ao dado como entradas
Si no hay pelculas programadas ese mes, se muestra el calendario
sin pelculas, y el emnsaje 'No existen pelculas este mes'
Si existen pelculas:
Muestra VV si quedan entradas por vender
Muestra XX si aforo completo
Lista las pelculas programadas, las entradas restantes o
Aforo completo
===================================================================*/
void TipoGestion::MostrarCalendario(TipoVectorPelicula vectorPeliculas) {
int m = 0;
int a = 0;
system("cls");
printf( "
CALENDARIO DE PELICULAS\n" );
printf( " ============================\n" );
printf( "\n" );
do {
try {
printf( "\nMes: " );
fflush(stdin);
if (scanf( " %2d", &m ) == 0) {
throw true;
}
printf( "\nAnno: " );
fflush(stdin);
if (scanf( " %4d", &a ) == 0) {
throw true;
}
} catch (bool e) {
m = 0;
a = 0;
}
} while (!calendario.EsCorrecta(1, m, a));
calendario.ImprimirCalendario( m, a, vectorPeliculas );
ImprimePeliculasMes( m, a, vectorPeliculas);
printf( "\n" );
system("pause");
}
/*===================================================================
Procedimiento: ImprimePeliculasMes
Listado de pelculas del mes y ao pasados como parmetros
===================================================================*/
void TipoGestion::ImprimePeliculasMes( int mes, int anno, TipoVectorPelicula vectorPeliculas ) {
bool hayPeliculas = false;
for (int i=0; i<maxPeliculas; i++) {
if ((vectorPeliculas[i].fecha.mes == mes) && (vectorPeliculas[i].fecha.anno == anno)) {
ImprimePelicula( vectorPeliculas[i] , 1 );
hayPeliculas = true;

}
}
if (!hayPeliculas) {
printf( "\n\nNo existen peliculas este mes\n" );
}
}
/*===================================================================
Procedimiento: ListarPeliculas
Listado de pelculas del gnero pasado como entrada
Lista genero, ttulo, fecha, hora y entradas vendidas
Si se han vendido todas, muestra el mensaje 'Aforo compelto'
===================================================================*/
void TipoGestion::ListarPeliculas( TipoVectorPelicula vectorPeliculas ) {
bool hayPeliculas = false;
system("cls");
do {
gen = 0;
printf( "\nGenero de la pelicula: " );
scanf( "%s", &auxGenero );
} while (!(ComprobarGenero( auxGenero, gen ))); /* Pasamos gen por referencia */
for (int i=0; i<maxPeliculas; i++) {
if (vectorPeliculas[i].genero == TipoGenero(gen)) {
ImprimePelicula( vectorPeliculas[i], 0 );
hayPeliculas = true;
}
}
if (!hayPeliculas) {
printf( "\nNo hay peliculas del genero introducido\n" );
}
system("pause");
}
/*===================================================================
Procedimiento: ImprimePelicula
Imprime, en una lnea:
Gnero
Ttulo
Fecha programada
Hora programada
Nmero de entradas por vender o 'Aforo completo'
Parmetro:
orden:
0 - Primer campo: gnero
1 - Prime3r campo: fecha;
==================================================================*/
void TipoGestion::ImprimePelicula( TipoPelicula pelicula, int orden ) {
TipoCharGenero gen;
switch (int(pelicula.genero)) {
case 0:
strcpy( gen,"Comedia" );
break;
case 1:
strcpy( gen, "Drama" );
break;
case 2:
strcpy( gen,"Terror" );
break;
case 3:
strcpy( gen,"Belica" );
break;
}
if (orden == 0) {
printf( "\n%s. %s. %02d-%02d-%02d. %02d:%02d horas. ",
gen, pelicula.titulo, pelicula.fecha.dia, pelicula.fecha.mes,

pelicula.fecha.anno, pelicula.horario.hora, pelicula.horario.minuto);

} else {
printf( "\n%02d-%02d-%02d %s. %s. %02d:%02d horas. ",
pelicula.fecha.dia, pelicula.fecha.mes,
pelicula.fecha.anno, pelicula.titulo, gen, pelicula.horario.hora, pelicula.horario.minuto);
}
if ( pelicula.entradas < 20) {
printf( "%2d entradas vendidas.\n", pelicula.entradas );
} else {
printf( "Aforo Completo.\n" );
}
}
/*===================================================================
Procedimiento: VenderEntradas
Vender entradas.
Realiza las siguientes validaciones:
Al menos hay una pelcula grabada
El titulo de la pelicula existe
El nmero de entradas solicitado est disponible
===================================================================*/
void TipoGestion::VenderEntradas(TipoVectorPelicula vectorPeliculas) {
TipoPelicula pelicula;
InicializarPelicula( pelicula);
/*-- Comprobamos que hay, al menos, una pelicula --*/
if (strcmp( vectorPeliculas[0].titulo,"") == 0) {
printf( "\nNo se pueden vender entradas." );
printf( "\nNo hay ninguna pelicula en cartelera\n" );
system("pause");
return;
}
system("cls");
printf( "
VENDER ENTRADAS\n" );
printf( " ============================\n" );
printf( "\n" );
/*-- Comprobamos que exista pelcula con el ttulo introducido --*/
do {
printf( "Titulo de la pelicula: " );
scanf( " %[^\n]s",pelicula.titulo );
} while (!TituloExiste( pelicula, vectorPeliculas ));
/*-- Si estn vendidas todas las entradas, no pide entradas y sale --*/
if ( vectorPeliculas[auxIndice].entradas == 20 ) {
printf( "\nNo quedan entradas para esta pelicula\n" );
system("pause");
return;
}
/*-- Comprobamos el nmero de entradas disponibles --*/
do {
printf( "\nNumero de entradas a vender: " );
fflush(stdin);
if (scanf( " %d", &pelicula.entradas ) == 0) {
pelicula.entradas = 21;
}
} while ( !ComprobarEntradas(pelicula, vectorPeliculas));
vectorPeliculas[auxIndice].entradas = vectorPeliculas[auxIndice].entradas + pelicula.entradas;
}
/*==================================================================
Funcin: TituloExiste
Funcin que comprueba si el ttulo de la pelcula existe
True: asigna a la variable global auxIndice la posicin en el
vector vectorPeliculas de la pelciula buscada
False: Imprime mensaje con el error
===================================================================*/

bool TipoGestion::TituloExiste( TipoPelicula pelicula, TipoVectorPelicula vectorPeliculas) {

for ( int i = 0; i < maxPeliculas; i++) {
if ( strcmp (vectorPeliculas[i].titulo, pelicula.titulo) == 0) {
auxIndice = i;
return true;
}
}
printf( "\nNo hay ninguna pelicula con ese titulo" );
printf( "\nIntroduzca un nuevo titulo\n" );
return false;
}
/*===================================================================
Funcin: ComprobarEntradas
Comprueba que el nmero de entradas solicitadas sea > 0 y que
est disponble para esa pelcula
True: la operacin es correcta
False: Imprime mensaje con el error
===================================================================*/
bool TipoGestion::ComprobarEntradas(TipoPelicula pelicula, TipoVectorPelicula vectorPeliculas) {
int disponibles = 20 - vectorPeliculas[auxIndice].entradas;
if ((pelicula.entradas <= 0) || ( pelicula.entradas > disponibles)) {
printf( "\nNumero de entradas no disponible\n" );
printf( "\nQuedan %2d entradas disponibles\n", disponibles );
return false;
}
return true;
}
/*=================================================================
Procedimiento para comparar dos fechas.
True: La primera es posterior a la segunda
================================================================*/
bool TipoGestion::EsPosterior( const TipoFecha f1, const TipoFecha f2) {
if (f1.anno != f2.anno) {
return (f1.anno > f2.anno);
} else if (f1.mes != f2.mes) {
return (f1.mes > f2.mes);
} else {
return (f1.dia > f2.dia);
}
}