#include "pila.h"
#include <stdlib.h>
#define TAM  10

/* Definición del struct pila proporcionado por la cátedra.
 */
struct pila {
    void** datos;
    size_t cantidad;  // Cantidad de elementos almacenados.
    size_t capacidad;  // Capacidad del arreglo 'datos'.
};

/* *****************************************************************
 *                    PRIMITIVAS DE LA PILA
 * *****************************************************************/

// Crea una pila.
// Post: devuelve una nueva pila vacía.
pila_t* pila_crear(void){
    pila_t* pila = malloc(sizeof(pila_t));
    if (!pila) {
        return NULL;
    }
    pila->datos = malloc(TAM * sizeof(void*));
    if (! pila->datos) {
        free(pila);
        return NULL;
    }
    pila->capacidad = TAM;
    pila->cantidad = 0;
    return pila;
}

// Destruye la pila.
// Pre: la pila fue creada.
// Post: se eliminaron todos los elementos de la pila.
void pila_destruir(pila_t *pila){
    if (pila){
        free(pila->datos);
        free(pila);
    }
}

// Devuelve verdadero si la pila no tiene elementos apilados, false en caso contrario.
// Pre: la pila fue creada.
bool pila_esta_vacia(const pila_t *pila){
    if(pila->cantidad == 0){
        return true;
    }
    return false;
}

//Redimensiona la pila, agrandandola o achicandola segun sea necesario, devuelve
//false en caso de que el realloc devuelva NULL, y true si la redimension fue
//exitosa y se sobreescribieron los datos.
//Pre: la pila fue creada y necesita ser redimensionada
//Post: la pila fue redimensionada, en caso de haber sido necesario
bool redimensionar(pila_t* pila){
    if(pila->cantidad == pila->capacidad){
        pila->capacidad = pila->capacidad * 2;
        void** d = realloc(pila->datos, pila->capacidad * sizeof(void*));
        if(!d){
            return false;
        }
        pila->datos = d;
        return true;
    }

    else if(pila->cantidad * 4 <= pila->capacidad){
        pila->capacidad = pila->capacidad / 2;
        void** d = realloc(pila->datos,pila->capacidad * sizeof(void*));
        if(!d){
            return false;
        }

        pila->datos = d;
        return true;
    }
    return false;
}

// Agrega un nuevo elemento a la pila. Devuelve falso en caso de error.
// Pre: la pila fue creada.
// Post: se agregó un nuevo elemento a la pila, valor es el nuevo tope.
bool pila_apilar(pila_t *pila, void* valor){
    if(!pila){
        return false;
    }

    if(pila->cantidad == pila->capacidad){
        if(!redimensionar(pila)){
            return false;
        }
    }

    pila->datos[pila->cantidad] = valor;
    pila->cantidad ++;
    return true;
}

// Obtiene el valor del tope de la pila. Si la pila tiene elementos,
// se devuelve el valor del tope. Si está vacía devuelve NULL.
// Pre: la pila fue creada.
// Post: se devolvió el valor del tope de la pila, cuando la pila no está
// vacía, NULL en caso contrario.
void* pila_ver_tope(const pila_t *pila){
    if(pila_esta_vacia(pila)){
        return NULL;
    }
    return pila->datos[pila->cantidad-1];
}

// Saca el elemento tope de la pila. Si la pila tiene elementos, se quita el
// tope de la pila, y se devuelve ese valor. Si la pila está vacía, devuelve
// NULL.
// Pre: la pila fue creada.
// Post: si la pila no estaba vacía, se devuelve el valor del tope anterior
// y la pila contiene un elemento menos.
void* pila_desapilar(pila_t *pila){
    if(pila_esta_vacia(pila)){
        return NULL;
    }
    void* tope = pila->datos[pila->cantidad - 1];
    pila->cantidad --;
    if(pila->cantidad * 4 <= pila->capacidad && pila->capacidad >= TAM){
        if(!redimensionar(pila)){
            return false;
        }
    }
    return tope;
}

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


/* ******************************************************************
 *                   PRUEBAS UNITARIAS ALUMNO
 * *****************************************************************/

void pruebas_pila_vacia(){
    //Verifico resultados en una pila vacia
    pila_t* pila_vacia = pila_crear();
    printf("INICIO DE PRUEBAS PILA VACIA\n");
    print_test("NULL es tope de una pila vacia", pila_ver_tope(pila_vacia) == NULL);
    print_test("Probar si pila esta vacia", pila_esta_vacia(pila_vacia) == true);
    print_test("No se puede desapilar pila vacia", pila_desapilar(pila_vacia) == NULL);
    //Destruyo pila vacia
    pila_destruir(pila_vacia);
    print_test("Destruir pila vacia", true);
}

void pruebas_con_un_elemento(){

    //Verifico resultados en una pila con un elemento

    pila_t* pila_unitaria = pila_crear();
    int* a = malloc(sizeof(int*));
    *a = 20;
    printf("INICIO DE PRUEBAS PILA CON UN ELEMENTO\n");
    pila_apilar(pila_unitaria,a);
    free(a);
    print_test("Se pudo apilar un elemento y tiene como tope el elemento recien apilado", pila_ver_tope(pila_unitaria) == a);
    print_test("La pila ya no esta vacia", pila_esta_vacia(pila_unitaria) == false);
    pila_desapilar(pila_unitaria);
    print_test("Se desapilo el elemento(NULL es tope de pila)", pila_ver_tope(pila_unitaria) == NULL);
    print_test("La pila vuelve a estar vacia", pila_esta_vacia(pila_unitaria) == true);

    //Destruyo pila unitaria

    pila_destruir(pila_unitaria);
    print_test("Destruir pila unitaria", true);
}

void pruebas_apilando_NULL(){
    printf("PRUEBA DE EJEMPLO CATEDRA\n");
    pila_t* ejemplo = NULL;
    print_test("Puntero inicializado a NULL", ejemplo == NULL);
    pila_t* pila_elem_nulo = pila_crear();

    //Se puede apilar NULL

    printf("PRUEBA APILANDO NULL\n");
    for(int i = 0; i != 5;i++){
        void* elemento_nulo = malloc(sizeof(void*));
        free(elemento_nulo);
        elemento_nulo = NULL;
        pila_apilar(pila_elem_nulo,elemento_nulo);
    }
    print_test("Prueba apilar varias veces NULL(verifico si la pila esta vacia)", pila_esta_vacia(pila_elem_nulo) == false);
    print_test("Prueba apilar varias veces NULL (verifico que el tope sea NULL)", pila_ver_tope(pila_elem_nulo) == NULL);
    pila_desapilar(pila_elem_nulo);
    print_test("Se desapilo un NULL, pero sigue habiendo otros(la pila no esta vacia)", pila_esta_vacia(pila_elem_nulo) == false);

    //Destruyo pila con NULL

    pila_destruir(pila_elem_nulo);
    print_test("Destruir pila con NULL", true);
}

void pruebas_volumen(){
    //Apilo muchos elementos y verifico tope

    int* x = (int*) 20 ;
    void* l = "prueba";

    pila_t* pila_probar = pila_crear();

    for(int i = 0; i != 100000 ;i++){
        int* elem_1 = malloc(sizeof(int*));
        free(elem_1);
        elem_1 = x;
        pila_apilar(pila_probar,elem_1);
        char* elem_2 = malloc(sizeof(char*));
        free(elem_2);
        elem_2 = l;
        pila_apilar(pila_probar,elem_2);
    }

    print_test("Prueba apilar algunos elementos", pila_esta_vacia(pila_probar) == false);
    print_test("Verificar que el tope sea el correcto", pila_ver_tope(pila_probar) == l);

    pila_desapilar(pila_probar);
    print_test("Desapilo y vuelvo a verificar tope", pila_ver_tope(pila_probar) == x);

    //Puedo vaciar pila con elementos

    while(!pila_esta_vacia(pila_probar)){
        pila_desapilar(pila_probar);
    }
    print_test("Pila con elementos se pudo vaciar", pila_esta_vacia(pila_probar) == true);
    print_test("Desapilar pila vacia devuelve NULL" , pila_desapilar(pila_probar) == NULL);

    //Vuelvo a apilar muchos elementos para probar destruir pila no vacia

    for(int i = 0; i != 500 ;i++){
        void* elem_1 = malloc(sizeof(void*));
        free(elem_1);
        elem_1 = x;
        pila_apilar(pila_probar,elem_1);
        void* elem_2 = malloc(sizeof(void*));
        free(elem_2);
        elem_2 = l;
        pila_apilar(pila_probar,elem_2);
    }

    //Destruyo pila no vacia

    pila_destruir(pila_probar);
    print_test("Destruir pila no vacia", true);
}


/* ******************************************************************
 *                        PROGRAMA PRINCIPAL
 * *****************************************************************/

/* Programa principal. */

void pruebas_pila_alumno(void) {

    /* Ejecutar todas las pruebas unitarias. */

    pruebas_pila_vacia();
    pruebas_con_un_elemento();
    pruebas_apilando_NULL();
    pruebas_volumen();
}