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

typedef struct
{
    char NyA[30];
    char tipoCuenta[30]; //ahorro en pesos - ahorro en dólares - ahorro en bitcoins
    int dni;
    float monto;
} stCuentaBancaria;

float verificarMonto();
void cargarCuentas(char nombreArchivo[20]);
int verifcarExistenciaDNIyTIPO(char nombreArchivo[20], int DNI, char tipoCuenta[20]);
void mostrarTodas(char nombreArchivo[20]);
void mostrarPorTipo(char nombreArchivo[20],char tipoCuenta[20]);
int pasarArchivoToArreglo(char nombreArchivo[20],stCuentaBancaria cuentas[20],int DIM);
void pasarArregloToArchivos(float monto,stCuentaBancaria cuentas[20], int validos);
stCuentaBancaria menorArchivo(char nombreArchivo[20]);
stCuentaBancaria mayorArchivo(char nombreArchivo[20]);

int main()
{
    //cargarCuentas("cuentas.dat");
   // int v = verifcarExistenciaDNIyTIPO("cuentas.dat",1,"dolares");
   // printf("v -> %d\n",v);
   //mostrarTodas("cuentas.dat");
   /*
   stCuentaBancaria cuentas[20];
   int validos = pasarArchivoToArreglo("cuentas.dat",cuentas,20);
   pasarArregloToArchivos(2000,cuentas,validos);
   printf("***************mostrando mayores\n");
   mostrarTodas("mayores.dat");
   printf("***************fin mostrando mayores\n");
   printf("***************mostrando menores\n");
   mostrarTodas("menores.dat");
   printf("***************fin mostrando menores\n");
   */
   stCuentaBancaria menor = menorArchivo("menores.dat");
   stCuentaBancaria mayor = mayorArchivo("mayores.dat");

   printf("el mayor de los mayores fue %s \n",mayor.NyA);
   printf("el menor de los menores fue %s \n",menor.NyA);
    return 0;
}


//Hacer una función que verifique si un dato existe en un archivo
//buscando por dni y tipo de cuenta. Retornará 1 ó 0. 10 pts.
int verifcarExistenciaDNIyTIPO(char nombreArchivo[20], int DNI, char tipoCuenta[20])
{
    int encontrado = 0 ;

    FILE * archi = fopen(nombreArchivo,"rb");
    stCuentaBancaria aux;

    if (archi != NULL)
    {
        while ((fread(&aux,sizeof(stCuentaBancaria),1,archi)>0)&&(encontrado==0))
        {
            if (DNI == aux.dni)
            {
                if (strcmp(tipoCuenta,aux.tipoCuenta) == 0)
                {
                    encontrado = 1;
                }
            }

        }
    }
    fclose(archi);
    return encontrado;
}

//Hacer una función que cargue cuentas bancarias
//en un archivo utilizando la función anterior y que el monto sea válido (>1000) 15 pts.
//Modularizar todo.

void cargarCuentas(char nombreArchivo[20])
{
    FILE * archi;
    char mander = 's';
    int verifcarExistencia;
    stCuentaBancaria aux;

    if (archi != NULL)
    {
        while (mander=='s')
        {

            float monto;

            do
            {
                monto = verificarMonto();
            }
            while (monto == -1);

            aux.monto = monto;

            printf("ingrese Nombre\n");
            fflush(stdin);
            scanf("%s",&aux.NyA);

            printf("ingrese Tipo de Cuenta\n");
            fflush(stdin);
            scanf("%s",&aux.tipoCuenta);

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

            verifcarExistencia = verifcarExistenciaDNIyTIPO(nombreArchivo,aux.dni,aux.tipoCuenta);

            //printf("verifcarExistencia -> %d\n",verifcarExistencia);

            while (verifcarExistencia == 1)
            {
                printf("Hubo un error, carge nuevamente\n");

                printf("ingrese Tipo de Cuenta\n");
                fflush(stdin);
                scanf("%s",&aux.tipoCuenta);

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

                verifcarExistencia = verifcarExistenciaDNIyTIPO(nombreArchivo,aux.dni,aux.tipoCuenta);
            }

            archi = fopen(nombreArchivo,"ab");
            fwrite(&aux,sizeof(stCuentaBancaria),1,archi);
            fclose(archi);

            printf("ingrese s para seguir\n");
            fflush(stdin);
            scanf("%c",&mander);
        }
    }

}

float verificarMonto()
{
    float verificado = -1;
    printf("ingrese Monto\n");
    fflush(stdin);
    scanf("%f",&verificado);
    if (verificado < 1000)
    {
        verificado = -1;
    }
    return verificado;
}

/*
Hacer una función que muestre todas las cuentas del archivo pero ordenadas por tipo. En el archivo se guardan desordenadas.
No hay que modificar el archivo. Modularizar. 15 pts.*/
void mostrarPorTipo(char nombreArchivo[20],char tipoCuenta[20])
{
    FILE * archi = fopen(nombreArchivo,"rb");
    stCuentaBancaria aux;

    if (archi != NULL)
    {
        while (fread(&aux,sizeof(stCuentaBancaria),1,archi)>0)
        {

            if (strcmp(tipoCuenta,aux.tipoCuenta) == 0)
            {
                    printf("mostrando cuenta--->\n");
                    printf("DNI -> %d\n",aux.dni);
                    printf("Tipo De cuenta -> %s\n",aux.tipoCuenta);
                    printf("Monto -> %f\n",aux.monto);
                    printf("fin mostrando cuenta--->\n");
            }
        }
    }
    fclose(archi);
}

void mostrarTodas(char nombreArchivo[20])
{
    mostrarPorTipo(nombreArchivo,"pesos");
    mostrarPorTipo(nombreArchivo,"dolares");
    mostrarPorTipo(nombreArchivo,"bitcoins");
}

//Hacer una función que pase el archivo a un arreglo de stCuentaBancaria. 10 pts.
int pasarArchivoToArreglo(char nombreArchivo[20],stCuentaBancaria cuentas[20],int DIM)
{
    FILE * archi = fopen(nombreArchivo,"rb");
    stCuentaBancaria aux;
    int pos = 0;
    if (archi != NULL)
    {
        while ((fread(&aux,sizeof(stCuentaBancaria),1,archi)>0) && (pos<DIM))
        {
            cuentas[pos] = aux;
            pos++;

        }
    }
    fclose(archi);
    return pos;
}

//Hacer una función que pase del arreglo al archivo de “ricos”
//todas aquellas cuentas cuyo monto sea mayor o igual a un dato recibido
//y el resto al archivo de “resto”.
void pasarArregloToArchivos(float monto,stCuentaBancaria cuentas[20], int validos)
{
    FILE * archiMayores = fopen("mayores.dat","ab");
    FILE * archiMenores = fopen("menores.dat","ab");

    int i = 0;
    for (i=0;i<validos;i++)
    {
        if (cuentas[i].monto > monto)
        {
            fwrite(&cuentas[i],sizeof(stCuentaBancaria),1,archiMayores);
        }
        else
        {
            fwrite(&cuentas[i],sizeof(stCuentaBancaria),1,archiMenores);
        }
    }

    fclose(archiMayores);
    fclose(archiMenores);

}

//Hacer dos funciones que muestre el mayor de “ricos” y el menor del “resto”.
stCuentaBancaria mayorArchivo(char nombreArchivo[20])
{
    stCuentaBancaria mayor;
    stCuentaBancaria aux;
    FILE * archi = fopen(nombreArchivo,"rb");

    if (archi != NULL)
    {
        fread(&mayor,sizeof(stCuentaBancaria),1,archi);
        while (fread(&aux,sizeof(stCuentaBancaria),1,archi)>0)
        {
            if (aux.monto > mayor.monto)
            {
               mayor = aux;
            }
        }
    }

    fclose(archi);
    return mayor;
}

stCuentaBancaria menorArchivo(char nombreArchivo[20])
{
    stCuentaBancaria menor;
    stCuentaBancaria aux;
    FILE * archi = fopen(nombreArchivo,"rb");

    if (archi != NULL)
    {
        fread(&menor,sizeof(stCuentaBancaria),1,archi);
        while (fread(&aux,sizeof(stCuentaBancaria),1,archi)>0)
        {
            if (aux.monto < menor.monto)
            {
               menor = aux;
            }
        }
    }

    fclose(archi);
    return menor;
}