/*
  Name: Validar y calcular diferencia en dias
  Author: Luis Mora Morales
  Date: 15/02/12 22:20
*/

#include <iostream>
#include <stdlib.h>

using namespace std;

int dias[2];
int meses[2];
int años[2];
int i = 0; 

struct bmpFecha

{
       
unsigned short int dia:5;
unsigned short int mes:4;
unsigned short int anno:7;

}

fecha[2];
int diaMes[12] = {31,28,31,30,31,30,31,31,30,31,30,31};

bool bisiesto (bmpFecha f);
bool validar (bmpFecha f);
void obtener_fecha();


char * mesLetra[] = { "Enero", "Febrero", "Marzo", "Abril", "Mayo",
    "Junio", "Julio", "Agosto", "Septiembre", "Octubre", "Noviembre",
    "Diciembre"};

int diasMes[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

struct stFecha{
    unsigned short int dia: 5; // Campo dia 5 bits; 32 valores
    unsigned short int mes: 4; // Campo mes 4 bits; 16 valores
    unsigned short int ano: 7; // Campo ano 7 bits; 128 valores 

    stFecha(){ almacenaFecha(1, 1, 1960); }
    stFecha(short d, short m, short a)
    {
        if( !almacenaFecha(d, m, a) )
            almacenaFecha(dias, meses, años);
    }
       
    bool almacenaFecha(short d, short m, short a)
    {   
        bool almacenar = false;
         
        if( validarFecha(&d, &m, &a) )
        {
            dia = d;
            mes = m;
            ano = a-1960;
           
            almacenar = true;
        }
       
        return almacenar;
    }
       
    void mostrarFecha()
    {
        cout.fill('0');
        cout.width(2);
        cout << dia << "/";
        cout.width(2);
        cout << mes << "/" << ano + 1960 << endl;
        cout.fill(' ');
    } 
       
    bool bisiesto()
    {
        bisiesto( ano );
    }
   
    bool validarFecha();
    int compararFechas( stFecha fecha2 );     
    int diferencia( stFecha fecha2 );
   
    private :
    bool bisiesto( int anno )
    {
        bool anoBisiesto = false;
     
        if( !((anno+1960)%4) && ( (anno+1960)%100 || !((anno+1960)%400) ) )
            anoBisiesto = true;
     
        return anoBisiesto;
    }
   
    bool validarFecha( short *d, short *m, short *a);
};
   

 

void comparar_fechas();
int diferencia;

int main()
{
    int subcidio;
    int ultimo;
    int penultimo;
    int antepenultimo;
    double total;
    char salir;
   
    do {
       
    obtener_fecha();
    i++;
    obtener_fecha();
    comparar_fechas();
   
   
   
    if(diferencia>3){
    subcidio=diferencia-3;
    cout << "Ingrese el salario del ultimo mes sin incapacidad : ";
    cin >> ultimo;
    cout << "Ingrese el salario del penultimo mes sin incapacidad : ";
    cin >> penultimo;
    cout << "Ingrese el salario del antepenultimo mes sin incapacidad : ";
    cin >> antepenultimo;
    total=((ultimo+penultimo+antepenultimo)/3/30*subcidio)*0.60;
    cout << "El subsidio correspondiente al empleado es de : " << total;
    }
    else cout << "No le corresponde ningun subsidio por incapacidad ";
    cout << endl << endl;
    system("pause");
    cout << "Desea realizar otro calculo S/N : ";
    cin >> salir;
    i=0;
}while(salir=='S' || salir=='s');
   return 0;
}

bool stFecha::validarFecha()
{
    bool fechaValida = false;
       
    if( mes >= 1 && mes <= 12 && ano <= 127 )
    {
        if( mes == 2 && bisiesto() )
        {
            if( dia >= 1 && dia <= 29 )
                fechaValida = true;
        }
        else
        {
            if( dia >= 1 && dia <= diasMes[mes-1] )
                fechaValida = true;
        }
    }
   
    return fechaValida;
}

int stFecha::compararFechas( stFecha fecha2 )
{
    int fechaPeso1, fechaPeso2, difPeso, resComp;
   
    // Convertimos las fechas en numeros con peso significativo
    fechaPeso1 = ano * 10000 + mes * 100 + dia;
    fechaPeso2 = fecha2.ano * 10000 + fecha2.mes * 100 + fecha2.dia;
   
    // Las restamos y comparamos la diferencia
    if( (difPeso = fechaPeso1 - fechaPeso2) > 0 )
        // La primera es mayor; 1
        resComp = 1;
    else
        if(difPeso < 0)
            // La segunda es mayor; -1
            resComp = -1;
        else
            // Son iguales; 0
            resComp = 0;

    return resComp;           
}       
       
int stFecha::diferencia( stFecha fecha2 )
{
    // Con vuestro permiso voy a usar punteros a las estructuras;
    // para referenciar correctamente a la menor y mayor fecha
    // y no crear mas estructuras en memoria
    stFecha *refFechMen, *refFechMay;
    int i, antBis;
    float acumDias;

    if( compararFechas( fecha2 ) > 0 )
    {   // Si compararFechas es cierto (mayor que cero); es decir 1
        // La primera fecha es mayor
        refFechMen = &fecha2;
        refFechMay = this;
    }
    else
    {   // Si compararFechas es falso (menor o igual que cero);
        // es decir 0 o -1
        // La segunda fecha es mayor o ambas son iguales.
        refFechMen = this;
        refFechMay = &fecha2;
    }
   
    // Calculo de los dias contenidos en años completos
    // Consideremos el año de la fecha menor como completo
    //---------------------------------------------------------------------
    // Buscamos el anterior bisiesto al año del fecha menor
    for( antBis = refFechMen->ano - 1; !bisiesto(antBis); antBis-- );
    // Calculamos la fracción de día erronea que llevamos a partir del año
    // bisiesto: 0, 0.25, 0.50 o 0.75
    acumDias = ((refFechMen->ano - antBis) * 0.25) - 0.25;
    // Acumulamos los años con su fraccion de dias erroneos
    acumDias += (refFechMay->ano - refFechMen->ano) * 365.25;

    // Acumulamos dias desde principio de año hasta la fecha mayor
    //---------------------------------------------------------------------   
    for( i = 1; i < refFechMay->mes; i++ )
        acumDias += diasMes[i-1];
   
    ( bisiesto(refFechMay->ano) && refFechMay->mes > 2 )?
        acumDias += refFechMay->dia  : acumDias += refFechMay->dia - 1;
   
    // Desacumulamos los dias desde principio de año hasta la fecha menor;
    // para quitar la diferencia de dias que hemos sumado de más
    // al considerar el primer año completo
    //---------------------------------------------------------------------   
    for( i = 1; i < refFechMen->mes; i++ )
        acumDias -= diasMes[i-1];
       
    ( bisiesto(refFechMen->ano) && refFechMen->mes > 2 )?   
        acumDias -= refFechMen->dia : acumDias -= refFechMen->dia - 1;
   
    // Finalmente retornamos acumulados despreciando la parte decimal
    //---------------------------------------------------------------------       
    return (int) acumDias;
}       

bool stFecha::validarFecha( short *d, short *m, short *a)
{
    bool fechaValida = false;
           
    if( *m >= 1 && *m <= 12
        && *a >= 1960 && *a <= 2087 )
    {
        if( *m == 2 && bisiesto((int) *a ))
        {
            if( *d >= 1 && *d <= 29 )
                fechaValida = true;
        }
        else
        {
            if( *d >= 1 && *d <= diasMes[*m-1] )
                fechaValida = true;
        }
    }
   
    return fechaValida;
}   


void obtener_fecha()
{   

int valido = 0;

while(valido != 1){
 
   
do{
system("cls");
if(i==0)
cout << "Ingrese la fecha de inicio de la incapacidad : " << endl << endl;
else cout << "Ingrese la fecha de fin de la incapacidad : " << endl << endl;

cout << "Introduzca el dia : ";

cin >> dias;


fecha.dia = dias;}while (dias > 31 || dias < 1);

do{
system("cls");

cout << "Introduzca el mes : ";

cin >> meses;

fecha.mes = meses;}while (meses > 12 || meses < 1);

do{
system("cls");

cout << "Introduzca el a\244o mayor a 1960 y menor a 2087 : ";

cin >> años;

fecha.anno = años - 1960;}while (años < 1960 || años > 2087 );

if (validar(fecha)){ cout << "\nFecha correcta" << endl << endl;
valido = 1;}

else {

cout << "\nFecha incorrecta" << endl << endl;
}

system("pause");

}// Fin del while
}


bool validar (bmpFecha f)
{

if (f.dia > diaMes[f.mes-1]) {

if ((f.mes == 2) && (f.dia == 29) && bisiesto(f)) return true;

else return false;

}

else return true;

}

bool bisiesto (bmpFecha f)
{

if (((f.anno + 1960) % 4 == 0) && ((f.anno + 1960) % 100 != 0))

return true;

else {

if ((f.anno + 1960) % 400 ==0) {

return true;

}

else return false;

}
}

void comparar_fechas()
{
     
        stFecha fechaPrueba1(dias[0],meses[0],años[0]);
        cout << "\nResultado de la validacion: "
        << fechaPrueba1.validarFecha() << endl; // y comprobamos si es valida
       
        fechaPrueba1.mostrarFecha(); cout << endl; // La mostramos
 
        stFecha fechaPrueba2(dias[1],meses[1],años[1]); // Creamos otra fecha
        cout << "\nResultado de la validacion: "
        << fechaPrueba2.validarFecha() << endl; // y comprobamos si es valida
   
        fechaPrueba2.mostrarFecha(); cout << endl; // La mostramos
   
   
   //Comparamos las fechas
   cout << "\nResultado de la comparacion: "
        << fechaPrueba1.compararFechas(fechaPrueba2) << endl;

   // Vemos la diferencia en dias entre las fechas anteriores       
   cout << "Resultado de la diferencia: "
        << fechaPrueba1.diferencia(fechaPrueba2) << endl << endl;
        diferencia=fechaPrueba1.diferencia(fechaPrueba2);

}