#ifndef _PILAGENERICA_HPP
#define _PILAGENERICA_HPP

// Constantes y tipos previos
const unsigned TAM_MAX = 1000;

// Interfaz del TAD Pila. Pre-declaraciones:

/* Los valores del TAD Pila representan una pila de elementos,
 * que sigue un comportamiento LIFO (Last In, First Out). Los
 * valores de Pila disponen de operaciones que permiten apilar
 * elementos, desapilar el último elemento, consultar el tope
 * de la pila y verificar si la pila está vacía.
 *
 * El tipo Elemento requerirá tener el operador habitual de
 * copia =, que se utilizará en las operaciones de apilar,
 * desapilar y cima.
      Elemento& operator=(const Elemento& origen)
 */
template<typename Elemento> struct Pila;

/* Crea una pila vacía (es decir, no contiene ningún elemento) */
template<typename Elemento> void inicializar(Pila<Elemento>& p);

/* Si p no está llena, devuelve en el mismo parámetro p la pila
 * resultante de añadir e a p y error = falso. En caso contrario,
 * la pila p no se modifica y error = verdad */
template<typename Elemento> void apilar(Pila<Elemento>& p,
                                            Elemento e, bool& error);

/* Si p no es vacía, devuelve la pila resultante de eliminar
 * el último elemento que fue apilado, dejándolo en c, y error = falso.
 * Si la pila es vacía, error = verdad */
template<typename Elemento> void desapilar(Pila<Elemento>& p,
                                            Elemento& e, bool& error);

/* Si p no es vacía, devuelve en e el último elemento apilado en p y
 * error = falso. En caso contrario, error = verdad y e queda indefinido */
template<typename Elemento> void cima(const Pila<Elemento>& p,
                                            Elemento& e, bool& error);

/* Devuelve verdad si y sólo si p no tiene ningún elemento */
template<typename Elemento> bool estaVacia(const Pila<Elemento>& p);

/* Devuelve verdad si y sólo si p ha alcanzado su máximo de capacidad */
template<typename Elemento> bool estaLlena(const Pila<Elemento>& p);
// Al hacer la pila genérica, el uso de template nos obliga a declarar 
// esta función como pública :(

/* Operaciones del iterador */ 

/* Prepara el iterador para que el siguiente elemento a visitar 
 * sea la cima de la pila p, si existe (situación de no haber
 * visitado ningún elemento) */
template<typename Elemento> void iniciarIterador(Pila<Elemento>& p);

/* Devuelve falso si ya se han visitado todos los elementos 
 * contenidos en p, verdad en caso contrario */
template<typename Elemento> bool existeSiguiente(const Pila<Elemento>& p);

/* Implementa las ops. siguiente y avanza de la especificación.
 * Si existeSiguiente(p), error = falso y e toma el valor del
 * siguiente elemento de la pila, y se avanza el iterador al
 * siguiente elemento de la pila. En caso contrario,
 * error = verdad, e queda indefinido y p queda como estaba */
template<typename Elemento> void siguiente(Pila<Elemento>& p,
                                            Elemento& e, bool& error);

// Declaración

template<typename Elemento> struct Pila {
    friend void inicializar<Elemento>(Pila<Elemento>& p);
    friend void apilar<Elemento>(Pila<Elemento>& p, char c, bool& error);
    friend void desapilar<Elemento>(Pila<Elemento>& p, char& c, bool& error);
    friend void cima<Elemento>(const Pila<Elemento>& p, char& c, bool& error);
    friend bool estaVacia<Elemento>(const Pila<Elemento>& p);
    friend bool estaLlena<Elemento>(const Pila<Elemento>& p);
    friend void iniciarIterador<Elemento>(Pila<Elemento>& p);
	friend bool existeSiguiente<Elemento>(const Pila<Elemento>& p);
	friend void siguiente<Elemento>(Pila<Elemento>& p, Elemento& e, bool& error);

    private: // Representación interna de los valores del TAD
        Elemento datos[TAM_MAX];
        int tope;
        int iter; // iterador
};

// Implementación de las operaciones: al ser un TAD genérico,
// el código ha de estar en el archivo HPP (una guarrada, pero OBLIGATORIO)

/* Crea una pila vacía (es decir, no contiene ningún elemento) */
template<typename Elemento> void inicializar(Pila<Elemento>& p) {
    p.tope = -1;
    // necesidades de C: los vectores se indexan empezando en 0
}

/* Devuelve verdad si y sólo si p ha alcanzado su máximo de capacidad */
template<typename Elemento> bool estaLlena(const Pila<Elemento>& p) {
  return p.tope == (TAM_MAX - 1);
}

/* Si p no está llena, devuelve en el mismo parámetro p la pila
 * resultante de añadir e a p y error = falso. En caso contrario,
 * la pila p no se modifica y error = verdad */
template<typename Elemento> void apilar(Pila<Elemento>& p,
                                            Elemento e, bool& error) {
    error = true;
    if (!estaLlena(p)) {
        p.tope = p.tope + 1;
        p.datos[p.tope] = e;
        error = false;
    }
}

/* Si p no es vacía, devuelve la pila resultante de eliminar
 * el último elemento que fue apilado, dejándolo en c, y error = falso.
 * Si la pila es vacía, error = verdad */
template<typename Elemento> void desapilar(Pila<Elemento>& p,
                                            Elemento& e, bool& error) {
    error = true;
    if (!estaVacia(p)) {
        e = p.datos[p.tope];
        p.tope = p.tope - 1;
        error = false;
    }
}

/* Si p no es vacía, devuelve en e el último elemento apilado en p y
 * error = falso. En caso contrario, error = verdad y e queda indefinido */
template<typename Elemento> void cima(const Pila<Elemento>& p,
                                            Elemento& e, bool& error) {
    error = true;
    if (!estaVacia(p)) {
        e = p.datos[p.tope];
        error = false;
    }
}

/* Devuelve verdad si y sólo si p no tiene ningún elemento */
template<typename Elemento> bool estaVacia(const Pila<Elemento>& p) {
  return (p.tope == -1);
}

/* Operaciones del iterador */ 

/* Prepara el iterador para que el siguiente elemento a visitar 
 * sea la cima de la pila p, si existe (situación de no haber
 * visitado ningún elemento) */
template<typename Elemento> void iniciarIterador(Pila<Elemento>& p) {
	p.iter = p.tope;
}

/* Devuelve falso si ya se han visitado todos los elementos 
 * contenidos en p, verdad en caso contrario */
template<typename Elemento> bool existeSiguiente(const Pila<Elemento>& p) {
	return p.iter != -1;
}

/* Implementa las ops. siguiente y avanza de la especificación.
 * Si existeSiguiente(p), error = falso y e toma el valor del
 * siguiente elemento de la pila, y se avanza el iterador al
 * siguiente elemento de la pila. En caso contrario,
 * error = verdad, e queda indefinido y p queda como estaba */
template<typename Elemento> void siguiente(Pila<Elemento>& p,
                                            Elemento& e, bool& error) {
  	error = true;
  	if(existeSiguiente(p)) {
  		e = p.datos[p.iter];
  		p.iter--;
  		error = false;
  	}
}

#endif