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

void cargarPila(Pila * p);
void pasarPila(Pila * origen, Pila * destino);

int main()
{
    printf("Hello world!\n");
    Pila p, ordenada,nuevoDato,nuevaPila;
    inicpila(&p);
    inicpila(&nuevaPila);
    inicpila(&nuevoDato);
    inicpila(&ordenada);
    cargarPila(&p);
    mostrar(&p);
   // insertarPilaEnOtraPila(&nuevaPila,&p);
    //  mostrar(&nuevaPila);
    //int menor = devuelveMenor(&p);
    //printf("el menor es ... %d\n",menor);
    //pasarOrdenada(&p,&ordenada);
    //mostrar(&ordenada);
    //leer(&nuevoDato);
    //insertarEnOrden(&ordenada,&nuevoDato);

    //mostrar(&ordenada);
    int suma = 0;
    suma = sumatope(p);
    printf("el sumatope es ... %d\n",suma);
    return 0;
}

/*
1. Hacer una función que permita ingresar varios elementos a una Pila,
tantos como quiera el usuario.
*/

void cargarPila(Pila * p)
{
    char mander = 's';
    while (mander == 's')
    {
        leer(p);
        printf("desea seguir? s/n");
        fflush(stdin);
        scanf("%c",&mander);
    }

}


/*2. Hacer una función que pase todos los elementos de una pila a otra.*/

void pasarPila(Pila * origen, Pila * destino)
{
    while (!pilavacia(origen))
    {
        apilar(destino,desapilar(origen));
    }
}

//4-buscar y eliminar el menor de una pila

int devuelveMenor(Pila * p)
{
    Pila menor,aux;
    inicpila(&menor);
    inicpila(&aux);
    apilar(&menor,desapilar(p));//primer menor

    while (!pilavacia(p))
    {
        if (tope(&menor)>tope(p)) //no sos tan menor
        {
            apilar(&aux,desapilar(&menor)); //se va del menor
            apilar(&menor,desapilar(p)); //me quedo con el nuevo menor
        }
        else
        {
               apilar(&aux,desapilar(p));
        }
    }

    //????

    pasarPila(&aux,p);

    return tope(&menor);
}

//generar una pila ordenada

void pasarOrdenada(Pila * p, Pila * ordenada)
{
    while (!pilavacia(p))
    {
        apilar(ordenada,devuelveMenor(p));
    }
}

//Hacer una función que inserte en una pila ordenada un nuevo elemento,
//conservando el orden de ésta.

void insertarEnOrden(Pila *dada,Pila *dato)
{
    Pila aux; inicpila(&aux);
    //primera vuelta, dada vacia
    //segunda vuelta (dada con un elemento) y datos
    while ((!pilavacia(dada)) && (tope(dato)<tope(dada)))
    {
        apilar(&aux,desapilar(dada));
    }
    //apilo dada directamente
    apilar(dada,desapilar(dato));

    pasarPila(&aux, dada);

}

//7. Hacer una función que pase los elementos de una pila a otra,
//de manera que se genere una nueva pila ordenada. Usar la función del ejercicio 6.
//(Ordenamiento por inserción)

void insertarPilaEnOtraPila(Pila *dada,Pila *datos)
{
    Pila aux; inicpila(&aux);
    while (!pilavacia(datos))//donde esta la info
    {
        apilar(&aux,desapilar(datos)); //saco 1 a 1 los elemetnos
        insertarEnOrden(dada,&aux);//inserta la pila AUX en DADA
    }
    //pila ordenada es dada
}

// Hacer una función que sume y retorne
//los dos primeros elementos de una pila (tope y anterior), sin alterar su contenido.

int sumatope(Pila  p)
{
    int resultado = 0;
    int contador = 0;

    while (!pilavacia(&p)&&contador<2)
    {
        int tope = desapilar(&p);
        resultado = resultado + tope;
        contador++;
    }
    //printf("%d",resultado);
    return resultado;
}