#include <stdio.h>
#include <stdlib.h>
#include "pila.h"

typedef struct {
     int legajo;
     char nombreYapellido [30];
     int edad;
     int anio;
//año que cursa, recordar que no podemos utilizar la ñ para definir variables
} stAlumno;

void cargarArchivo(char nombreArchivo[20]);
stAlumno cargarUnAlumno();
void leerArchivo(char nombreArchivo[20]);
void mostrarUnAlumno(stAlumno aux);
void cargarAlFinal(char nombreArchivo[20]);
int pasarApila(Pila * pilinMayores, char nombreArchivo[20],int edad );
void mostrarAlumnoPorRango(char nombreArchivo[20],int minEdad, int maxEdad);
void mayorEdad(char nombreArchivo[20]);

int main()
{
    char nombreArchivo[] = "alumnos.dat";
    Pila pila; inicpila(&pila);
    Pila pila2; inicpila(&pila2);

    //cargarArchivo(nombreArchivo);
    //cargarAlFinal(nombreArchivo);
    leerArchivo(nombreArchivo);

    int cantidadApilados18 = pasarApila(&pila,nombreArchivo,18); //mayores
    //printf("la cantidad de mayores es de ... %d\n",cantidadApilados18);
    //mostrar(&pila);

    int nuevaEdad = 32;
    int cantidadApiladosEdad = pasarApila(&pila2,nombreArchivo,nuevaEdad); //otra edad
    //printf("la cantidad de mayores es %d es de ... %d\n",nuevaEdad,cantidadApiladosEdad);
    //mostrar(&pila2);

    //mostrarAlumnoPorRango(nombreArchivo,30,50);

    mayorEdad(nombreArchivo);

    return 0;
}

/*
Crear una función que cargue un archivo de alumnos.
Abrirlo de manera tal de verificar si el archivo ya está creado previamente.
 Cargar el archivo con 5 datos. Cerrarlo dentro de la función
*/

void cargarArchivo(char nombreArchivo[20])
{
    FILE * archi = fopen(nombreArchivo,"rb");
    if (archi == NULL) //el archi no esta!
    {
        archi = fopen(nombreArchivo,"wb");
        if (archi != NULL) //no hay error de escritura
        {
            int cantidadDeDatos = 2;
            int datosCargados = 0;
            for (datosCargados = 0;datosCargados<cantidadDeDatos;datosCargados++)
            {
                 stAlumno aux = cargarUnAlumno();
                 fwrite(&aux,sizeof(stAlumno),1,archi);
            }
        }
    }
    else
        {
            printf("el archi esta con datos\n");
            leerArchivo(nombreArchivo);
        }

        fclose(archi);
}

stAlumno cargarUnAlumno()
{
    stAlumno aux;

    printf("ingrese legajo\n");
    fflush(stdin);
    scanf("%d",&aux.legajo);

    printf("ingrese nombre Y apellido \n");
    fflush(stdin);
    scanf("%s",&aux.nombreYapellido);

    printf("ingrese edad \n");
    fflush(stdin);
    scanf("%d",&aux.edad);

     printf("ingrese anio \n");
    fflush(stdin);
    scanf("%d",&aux.anio);

    return aux;
}

/*
Crear una función que muestre por pantalla
los registros de un archivo de alumnos. Modularizar.
*/

void leerArchivo(char nombreArchivo[20])
{
    FILE * archi = fopen(nombreArchivo,"rb");
    if (archi != NULL) //el archi  esta!
    {
        stAlumno alumnoLector;
        while (fread(&alumnoLector,sizeof(stAlumno),1,archi)>0)
        {
            mostrarUnAlumno(alumnoLector);
        }
    }
    else
    {
        printf("el archivo no existeee\n");
    }

}

void mostrarUnAlumno(stAlumno aux)
{
    printf("***************\n");
    printf("legajo -> %d\n",aux.legajo);
    printf("nombre Y apellido -> %s\n",aux.nombreYapellido);
    printf("edad -> %d\n",aux.edad);
    printf("anio -> %d\n",aux.anio);
    printf("***************\n");
}

/*
Crear una función que permita agregar de a un elemento al final del archivo.
 O sea, se debe abrir el archivo, se piden los datos
 (se llena una variable de tipo struct alumno),
 se escribe en el archivo y se cierra.
*/
void cargarAlFinal(char nombreArchivo[20])
{
    FILE * archi = fopen(nombreArchivo,"rb");
    if (archi != NULL) //el archi  esta!
    {
        archi = fopen(nombreArchivo,"ab");//agrego al final
        if (archi != NULL)
        {
            char mander = 's';
            while (mander == 's')
            {
                stAlumno aux = cargarUnAlumno();
                fwrite(&aux,sizeof(stAlumno),1,archi);

                printf("desea seguir??? \n");
                fflush(stdin);
                scanf("%c",&mander);
            }
        }
        else
        {
            printf("no se puede escribir\n");
        }
    }
    else
        {
            printf("no se puede abrir, existe???\n");
        }
    fclose(archi);
}
/*
Crear una función que pase a una pila los números de legajo de los alumnos mayores de edad.
*/
/*
Dado un archivo de alumnos, hacer una función que cuente la cantidad de alumnos mayores a edad específica que se envía por parámetro.
*/
int pasarApila(Pila * pilinMayores, char nombreArchivo[20], int edadDeterminada )
{
    FILE * archi = fopen(nombreArchivo,"rb");
    int cantidadApilados = 0;
    if (archi != NULL) //el archi  esta!
    {
        stAlumno alumnoLector;
        while (fread(&alumnoLector,sizeof(stAlumno),1,archi)>0)
        {
           if (alumnoLector.edad >= edadDeterminada)
           {
               apilar(pilinMayores,alumnoLector.legajo);
               cantidadApilados++;
           }
        }
    }
    else
    {
        printf("el archivo no existeee\n");
    }
    fclose(archi);
    return cantidadApilados;
}

/*
Dado un archivo de alumnos, mostrar por pantalla el nombre de todos los alumnos entre un rango de edades específico (por ejemplo, entre 17 y 25 años).
Dicho rango debe recibirse por parámetro. Modularizar
*/

void mostrarAlumnoPorRango(char nombreArchivo[20],int minEdad, int maxEdad)
{
  FILE * archi = fopen(nombreArchivo,"rb");
    if (archi != NULL) //el archi  esta!
    {
        stAlumno alumnoLector;
        while (fread(&alumnoLector,sizeof(stAlumno),1,archi)>0)
        {
           if ((alumnoLector.edad > minEdad) && (alumnoLector.edad < maxEdad))
           {
               mostrarUnAlumno(alumnoLector);
           }
        }
    }
    else
    {
        printf("el archivo no existeee\n");
    }
    fclose(archi);
}
/*
Dado un archivo de alumnos, mostrar el los datos del alumno de mayor edad. Modularizar.
*/
void mayorEdad(char nombreArchivo[20])
{
    FILE * archi = fopen(nombreArchivo,"rb");
    if (archi != NULL) //el archi  esta!
    {
        stAlumno alumnoLector;
        stAlumno alumnoMayor;
        fread(&alumnoMayor,sizeof(stAlumno),1,archi);//el primero
        while (fread(&alumnoLector,sizeof(stAlumno),1,archi)>0)//leo desde el segundo
        {
           if (alumnoLector.edad > alumnoMayor.edad)
           {
               alumnoMayor = alumnoLector;
           }
        }
        printf("el alumno mayor es ...\n");
        mostrarUnAlumno(alumnoMayor);
    }
    else
    {
        printf("el archivo no existeee\n");
    }
    fclose(archi);
}