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

void cargarPila(Pila * duracell);
int pasarPilaToArreglo(Pila duracell, int arreglo[20]);
int mayorElemento(int arreglo[20], int validos);
int menorPila(Pila * pila);
float promedio(int arreglo[20],int validos);

int main()
{
    Pila tripleA;
    inicpila(&tripleA);
    cargarPila(&tripleA);

    mostrar(&tripleA);

    int arreglo[20] = {0};
    int validos = pasarPilaToArreglo(tripleA,arreglo);

    for (int i=0;i<validos;i++)
    {
        printf("Elemento: %d\n",arreglo[i]);
    }

    int mayor =  mayorElemento(arreglo,validos);

    printf("Elemento mayor: %d\n",mayor);

    float promedioCalculado = promedio(arreglo,validos);

    printf("Promedio Calculado mayor: %f\n",promedioCalculado);

    return 0;
}

/*
1. Hacer una función que cargue una pila de números enteros mientras el usuario así lo desea.
La pila se envía por parámetro.

*/


void cargarPila(Pila * duracell)
{
    char mander = 's';
    while (mander == 's')
    {
        leer(duracell);

        printf("Desea continuar? \n");
        fflush(stdin);
        scanf("%c",&mander);
    }
}

/*
Copiar los elementos impares de la pila a un arreglo. Dicho arreglo es de dimensión 20.
Controlar que no se puedan pasar más elementos. Los elementos deben quedar en la pila.
*/

int pasarPilaToArreglo(Pila duracell, int arreglo[20])
{
    int contador = 0;
    int elemento;
    while ((!pilavacia(&duracell)) && (contador<20))
    {
        elemento = desapilar(&duracell);
        if (elemento % 2 !=0)
        {
            arreglo[contador] = elemento;
            contador++;
        }
    }
    return contador;
}

/*
3. Buscar y retornar el mayor elemento del arreglo del punto anterior.
*/


int mayorElemento(int arreglo[20], int validos)
{
    int mayor = arreglo[0];
    for (int i=1;i<validos;i++)
    {
        if (mayor < arreglo[i])
        {
            mayor = arreglo[i];
        }
    }
    return mayor;
}

/*

4. Buscar el menor elemento de la pila del punto 2 y quitarlo de la pila.
La pila debe quedar en orden.

*/

int menorPila(Pila * pila)
{
    int menor = tope(pila);
    int elemento;
    Pila aux;
    inicpila(&aux);

    while (!pilavacia(pila))
    {
        elemento = tope(pila);
        apilar(&aux,desapilar(pila));

        if (elemento < menor)
        {
            menor = elemento;
        }
    }

    while (!pilavacia(&aux))
    {
        if (tope(&aux) == menor)
        {
            desapilar(&aux);
        }
        else
        {
            apilar(pila,desapilar(&aux));
        }
    }

    return menor;
}

/*

5. Realizar una función que saque el promedio de los elementos del arreglo.

*/

float promedio(int arreglo[20],int validos)
{
    float promedioCalculado = 0;
    int suma = 0;
    for (int i=0;i<validos;i++)
    {
        suma = suma + arreglo[i];
    }

    promedioCalculado = (float)(suma / validos);

    return promedioCalculado;
}