#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 cantidadAnioDeterminado(int anio,char nombreArchivo[20]);
int copiarArregloToArchivo(stAlumno alumnos[100], int validos, char nombreArchivo[20]);
int copiarArchivoToArreglo(stAlumno alumnos[100], int tam, char nombreArchivo[20]);
int cantidadRegistroArchivoX(char nombreArchivoX[20]);
void mostrarUnAlumnoDesdeArchivo(char nombreArchivo[20], int pos);
void sobreescribirRegistro(char nombreArchivo[20]);
void invertir(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);

    int cantidadAnio = cantidadAnioDeterminado(1988,nombreArchivo);
    // printf("la cantidad de alumnos en el anio %d es de ... %d\n",1988,cantidadAnio);

    /*

    stAlumno alumnos[100];
    int tam = 100;
    int validosArreglo = copiarArchivoToArreglo(alumnos,tam,nombreArchivo);
    printf("la cantidad de alumnos pasados al ARREGLO es de ... %d\n",validosArreglo);
    int cantidadArchivo = copiarArregloToArchivo(alumnos,validosArreglo,"otroArchivo.dat");
    printf("otro archivo...\n");
    leerArchivo("otroArchivo.dat");
    */

    int cantidadElementos = cantidadRegistroArchivoX(nombreArchivo);
   // printf("la cantidad de alumnos es de ... %d\n",cantidadElementos);

  // printf("el alumno en la pos %d es ...\n",2);
   //mostrarUnAlumnoDesdeArchivo(nombreArchivo,2);

   //sobreescribirRegistro(nombreArchivo);

   invertir(nombreArchivo);

    printf("upsidedown? archivo...\n");

   leerArchivo(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);
    gets(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);
}

/*
Crear una función que retorne la cantidad de alumnos que cursan un determinado año.
El año buscado se pasa por parámetro.
*/

int cantidadAnioDeterminado(int anio,char nombreArchivo[20])
{
    FILE * archi = fopen(nombreArchivo,"rb");
    stAlumno alumnoLector;
    int cantidad = 0;
    if (archi != NULL) //el archi  esta!
    {
        while (fread(&alumnoLector,sizeof(stAlumno),1,archi)>0)//leo desde el segundo
        {
            if (alumnoLector.anio == anio)
            {
                cantidad++;
            }
        }
    }
    fclose(archi);
    return cantidad;
}

/*
Crear una función que reciba como parámetro un arreglo de tipo alumno
y lo copie en el archivo.

*/

int copiarArchivoToArreglo(stAlumno alumnos[100], int tam, char nombreArchivo[20])
{
    int validos = 0;
    FILE * archi = fopen(nombreArchivo,"rb");
    stAlumno alumnoLector;
    if (archi != NULL) //el archi  esta!
    {
        while (fread(&alumnoLector,sizeof(stAlumno),1,archi)>0)//leo desde el segundo
        {
            alumnos[validos] = alumnoLector;
            validos++;
        }
    }
    fclose(archi);
    return validos;
}

int copiarArregloToArchivo(stAlumno alumnos[100], int validos, char nombreArchivo[20])
{
    int indice = 0;
    FILE * archi = fopen(nombreArchivo,"ab");
    stAlumno alumnoLector;
    if (archi != NULL) //el archi  esta!
    {
        while (indice<validos)// un for tambie
        {
            alumnoLector = alumnos[indice];//aux para guardar
            fwrite(&alumnoLector,sizeof(stAlumno),1,archi);
            indice++;
        }
    }
    fclose(archi);
    return validos;
}


/*
Crear una función que retorne la cantidad de registros que tiene el archivo.
Usar fseek y ftell.
Puede pensar la función para uso genérico, que sirva para averiguar la cantidad de registros de cualquier archivo.
*/
int cantidadRegistroArchivoX(char nombreArchivoX[20])
{
    int cantidadElementos = 0;
     FILE * archi = fopen(nombreArchivoX,"rb");
     if (archi != NULL)
     {
        fseek(archi,0,SEEK_END); //nos vamos al final y nos desplazamos 0
        long tam = ftell(archi); //pedimos bytes hasta el CURSOR
        cantidadElementos = tam / sizeof(stAlumno);
     }
     fclose(archi);
     return cantidadElementos;

}
/*
14. Dado un archivo de alumnos, que tenga al menos 10 registros, hacer una función que muestre
el contenido de un registro, cuyo número (entre 0 y 9) se pase por parámetro.
Controlar no sobrepasar los límites del archivo.
*/

void mostrarUnAlumnoDesdeArchivo(char nombreArchivo[20], int pos)
{

    int cantidad = cantidadRegistroArchivoX(nombreArchivo);
    FILE * archi = fopen(nombreArchivo,"rb");
    stAlumno alumnoLector;
    if (pos <= cantidad)//si me paso una pos que es valida dentro de la cantidad
    {
        if (archi!=NULL)
        {
            fseek(archi,sizeof(stAlumno)*(pos-1),SEEK_SET);
            if (fread(&alumnoLector,1,sizeof(stAlumno),archi)>0)
            {
                mostrarUnAlumno(alumnoLector);
            }
        }
    }
    else
    {
        printf("pos invalida\n");
    }
    fclose(archi);
}

/*
Realice una (o varias) funciones que permitan modificar un registro existente
en el archivo de alumnos. La misma debe permitir modificar uno o
todos los campos de la estructura y sobreescribir el registro existente en el archivo.
*/

void sobreescribirRegistro(char nombreArchivo[20])
{
    int pos = 0;
    int op = 0;

    int cantidadRegistros = cantidadRegistroArchivoX(nombreArchivo);

    do
    {
        printf("ingrese un pos valida para modificar\n");
        scanf("%d",&pos);
    }while(pos>cantidadRegistros);

    mostrarUnAlumnoDesdeArchivo(nombreArchivo,pos);

    printf("desea cambiar todos (0) o algunos (1) ?\n");
    scanf("%d",&op);

    FILE * archi = fopen(nombreArchivo,"r+b");
    fseek(archi,sizeof(stAlumno)*(pos-1),SEEK_SET);

    if (op == 0)
    {
        stAlumno alumnoNuevo = cargarUnAlumno();

        if (archi!=NULL)
        {
            fwrite(&alumnoNuevo,sizeof(stAlumno),1,archi);
        }
        fclose(archi);
    }
    else
    {
        stAlumno alumnoViejo;
        fread(&alumnoViejo,sizeof(stAlumno),1,archi);//leo los datos
        fseek(archi,sizeof(stAlumno)*(pos-1),SEEK_SET); //me vuelvo a la pos original

        printf("cual desea modificar?\n");
        printf("1-nombre\n");
        printf("2-anio\n");
        printf("3-legajo\n");
        printf("4-edad\n");
        scanf("%d",&op);

        switch (op)
        {
            case 1:
                     printf("ingrese nombre Y apellido \n");
                    fflush(stdin);
                    gets(alumnoViejo.nombreYapellido);
                    break;
            case 2:
                    printf("ingrese anio \n");
                    fflush(stdin);
                    scanf("%d",&alumnoViejo.anio);
                    break;
            case 3:
                    printf("ingrese legajo\n");
                    fflush(stdin);
                    scanf("%d",&alumnoViejo.legajo);
                    break;
            case 4:
                    printf("ingrese edad \n");
                    fflush(stdin);
                    scanf("%d",&alumnoViejo.edad);
                    break;

        }
        fwrite(&alumnoViejo,sizeof(stAlumno),1,archi);
        fclose(archi);
    }

}



/*
Dado un archivo de alumnos, hacer una función que invierta los elementos del mismo.
No se puede usar otro archivo auxiliar ni un arreglo auxiliar. Debe trabajar sobre el archivo.
Puede utilizar variables de tipo alumno auxiliares.

*/


void invertir(char nombreArchivo[20])
{
    stAlumno alumnoIndice;
    stAlumno alumnoLimite;
     int limite = cantidadRegistroArchivoX(nombreArchivo);
     limite = limite - 1;
     FILE * archi = fopen(nombreArchivo,"r+b");
     int indice = 0;
     while (indice < limite)
     {
          printf("indice -> %d limite -> %d\n",indice,limite);

          fseek(archi,sizeof(stAlumno)* indice,SEEK_SET);//0
          fread(&alumnoIndice,sizeof(stAlumno),1,archi);

          printf("alumnoIndice\n");

          mostrarUnAlumno(alumnoIndice);

          fseek(archi,sizeof(stAlumno)* (limite),SEEK_SET);//-1 un registro
          fread(&alumnoLimite,sizeof(stAlumno),1,archi);

          printf("alumnoLimite\n");

          mostrarUnAlumno(alumnoLimite);

          fseek(archi,sizeof(stAlumno)* indice,SEEK_SET); //volvemos al principio
          fwrite(&alumnoLimite,sizeof(stAlumno),1,archi); //escribimos el ultimo

          fseek(archi,sizeof(stAlumno)* (limite),SEEK_SET);//4-1 = 3 ´pero apuntando al 4
          fwrite(&alumnoIndice,sizeof(stAlumno),1,archi); //escribimos el ultimo



         indice++;
         limite--;
     }
     fclose(archi);
}