#include "lista.hpp"

nodo_lista::nodo_lista(Objeto item, nodo_lista* siguiente) {
	data = item;
	sig = siguiente;
}

nodo_lista* borre(nodo_lista** refnodo) {
	/* rutina auxiliar, borra un nodo y deja a su referencia apuntando al siguiente nodo */
	if (*refnodo == NULL) return NULL;
	nodo_lista *J = *refnodo;
	*refnodo = J->sig;
	delete J;
	return *refnodo;
}

Objeto extraiga(nodo_lista** refnodo) {
	/* rutina auxiliar, borra un nodo y deja a su referencia apuntando al siguiente nodo,
	   devuelve el objeto que había en el nodo borrado */
	if (*refnodo == NULL) return NULL;
	Objeto item = (*refnodo)->data;
	borre(refnodo);
	return item;
}

Lista::Lista(nodo_lista* N) {
	primero = N;
}

Lista::~Lista() {
	while(primero!=NULL)
		borre(&primero);
}

Lista::Lista(Lista& origen) {
	primero = NULL;
	nodo_lista** K = &primero;
	for ( nodo_lista* I=origen.primero; I!=NULL; I=I->sig ) {
		nodo_lista* J = new nodo_lista( I->data );
		if ( J==NULL ) return;
		*K = J;
		K = &(J->sig);
	}
}

Lista::Lista(Lista& origen, int inicio, int final) {
	primero = NULL;
	nodo_lista** K = &primero;
	nodo_lista* I = origen.primero;
	int n;
	for ( n=0; n<inicio; n++ ) {
		if ( I==NULL ) return;
		I = I->sig;
	}
	for ( ; n<final; n++ ) {
		if ( I==NULL ) return;
		nodo_lista* J = new nodo_lista( I->data );
		if ( J==NULL ) return;
		*K = J;
		K = &(J->sig);
		I = I->sig;
	}
}

int Lista::vacia() {
	return primero == NULL;
}

int Lista::contar() {
	int n=0;
	for ( nodo_lista* I=primero; I!=NULL; I=I->sig ) {
		n++;
	}
	return n;
}

nodo_lista* Lista::buscar(int posicion) {
	/* rutina auxiliar: regresa un apuntador al posicion-ésimo nodo de la lista */
	nodo_lista* I=primero;
	for ( int n=0; n<posicion; n++ ) {
		if ( I==NULL ) return NULL;
		I = I->sig;
	}
	return I;
}

nodo_lista** Lista::previo(int posicion) {
	/* rutina auxiliar: regresa una referencia al apuntador al posicion-ésimo nodo de la lista */
	nodo_lista** K=&primero;
	for ( int n=0; n<posicion; n++ ) {
		if ( *K==NULL ) return K; /* si se agota, retorna una referencia al campo sig del último nodo */
		K = &((*K)->sig);
	}
	return K;
}

nodo_lista* Lista::ultimo() {
	/* rutina auxiliar: regresa un apuntador al último nodo de la lista */
	if (primero==NULL) return NULL;
	nodo_lista* I;
	for(I=primero; I->sig!=NULL; I=I->sig);
	return I;
}

nodo_lista** Lista::penultimo() {
	/* rutina auxiliar: regresa una referencia al apuntador al último nodo de la lista */
	if (primero==NULL) return NULL;
	nodo_lista** K;
	for ( K=&primero; (*K)->sig!=NULL; K = &((*K)->sig) );
	return K;
}

Objeto Lista::item(int posicion) {
	nodo_lista* I=buscar(posicion);
	if (I==NULL) return NULL;
	return I->data;
}

Lista& Lista::agregar(Objeto item, int posicion) {
	nodo_lista** K = previo(posicion);
	nodo_lista* J = new nodo_lista(item,*K);
	if (J!=NULL) *K=J;
	return *this;
}

Lista& Lista::agregar_inicio(Objeto item) {
	nodo_lista* J = new nodo_lista(item,primero);
	if (J!=NULL) primero=J;
	return *this;
}

Lista& Lista::agregar_final(Objeto item) {
	nodo_lista *J = ultimo();
	if (J==NULL)
		/* lista vacia, crear primer elemento */
		primero = new nodo_lista(item,primero);
	else {
		J->sig = new nodo_lista(item,J->sig);
	}
	return *this;
}

Lista& Lista::insertar(Lista& origen, int posicion) {
	nodo_lista **K = previo(posicion);
	for (nodo_lista *I=origen.primero; I!=NULL; I=I->sig) {
		nodo_lista* J = new nodo_lista( I->data, *K );
		if (J==NULL) return *this;
		*K = J;
		K = &(J->sig);
	}
	return *this;
}

Lista& Lista::insertar_inicio(Lista& origen) {
	nodo_lista **K = &primero;
	for (nodo_lista *I=origen.primero; I!=NULL; I=I->sig) {
		nodo_lista* J = new nodo_lista( I->data, *K );
		if (J==NULL) return *this;
		*K = J;
		K = &(J->sig);
	}
	return *this;
}

Lista& Lista::insertar_final(Lista& origen) {
	nodo_lista *J = ultimo();
	for (nodo_lista *I=origen.primero; I!=NULL; I=I->sig) {
		J = J->sig = new nodo_lista( I->data, J->sig );
		if (J==NULL) return *this;
	}
	return *this;
}

Lista& Lista::borrar(int posicion) {
	borre(previo(posicion));
	return *this;
}

Lista& Lista::borrar_primero() {
	borre(&primero);
	return *this;
}

Lista& Lista::borrar_ultimo() {
	borre(penultimo());
	return *this;
}

Lista& Lista::borrar(int inicio, int final) {
	nodo_lista **K=previo(inicio);
	for (int n=inicio;n<final && K!=NULL;n++) {
		borre(K);
	}
	return *this;
}

Objeto Lista::extraer(int posicion) {
	return extraiga(previo(posicion));
}

Objeto Lista::extraer_primero() {
	return extraiga(&primero);
}

Objeto Lista::extraer_ultimo() {
	return extraiga(penultimo());
}

Lista& Lista::extraer(int inicio, int final) {
	nodo_lista **K,**P;
	P = K = previo(inicio);
	nodo_lista *L = *K;
	for ( int n=inicio; n<final && (*K)!=NULL; ++n ) {
		K = &((*K)->sig);
	}
	*P = *K; /* lista original continúa donde termina el rango extraído */
	*K = NULL; /* rango extraído termina */
	return *(new Lista(L));
}