#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include "LinkedList.h"

typedef struct Node {
    Data data ;
    List next ;
} Node ;

static List NewNode(Data val, List next)
{
    List n = malloc(sizeof(Node)) ;
    if( n == NULL )
        return NULL ;
    n->data = val ;
    n->next = next ;
    return n ;
}

/* Cria uma cópia duma lista, em que todos os nós são novos.*/
List ListClone(List l) /*List l é apontador*/
{
	if(l==NULL){ 
		return NULL;
	}
	List last = NewNode(l->data, NULL);
	List res = last;
	l=l->next;	
	for(; l!=NULL ; l = l->next){
		last = last-> next = NewNode(l->data, NULL);
	}
	return res;
}

/* No final de l1, acrescenta uma cópia da lista l2 (usando Clone, claro)*/
List ListAppend(List l1, List l2)
{
	List res = l1;
	if(l1==NULL){
		return ListClone(l2);
	}
	else if(l2==NULL){
		return l1;
	}
	else{
		for(;(l1->next)!=NULL; l1=l1->next);
		l1->next=ListClone(l2);
		return res;
	}
}

/* Inverte uma lista, duplicando todos os nós da lista original.*/
List ListRev(List l){
	List res = NULL;
	for(; l!=NULL;l=l->next){
		res = NewNode(l->data, res);
	}
	return res;
	
}

/* Inverte uma lista, aproveitando os nós da lista original.*/
List ListRev2(List l){
	List k;
	List res = NULL;
	while(l!=NULL){
		k=l->next; 
		l->next = res;
		res=l;
		l=k;
	}
	return l;
}

/* Elimina duma lista, todos os nós com valores repetidos.
   Mantenha a ordem dos elementos que ficam.
   No caso dos elementos repetidos, pode eliminar as repetições que desejar.
   Use a operação free. Não faz mal se a complexidade da solução for quadrática.*/
List ListUniq(List l){

}

List ListMakeRange(Data a, Data b)
{  // TECNICA: Fazer crescer a lista no ultimo no'.
    if( a > b )
        return NULL ;
    double i ;
    List l = NewNode(a, NULL), last = l ;
    for( i = a + 1 ; i <= b ; i++ )
        last = last->next = NewNode(i, NULL) ;
    return l ;
}	

/* Outra maneira, mais palavrosa, de escrever a funcao anterior:

List ListMakeRange(Data a, Data b)
{
    if( a > b )
        return NULL ;
    double i ;
    List l = NewNode(a, NULL) ;
    List last = l ;
    for( i = a + 1 ; i <= b ; i++ ) {
        List q = NewNode(i, NULL) ;
        last->next = q ;
        last = q ;
    }
    return l ;
}
*/

int ListLength(List l) {
    int count ;
    for( count = 0 ; l != NULL ; l = l->next, count++ ) ;
    return count ;
}

bool ListGet(List l, int idx, Data *res)
{
    int i ;
    for( i = 0 ; i < idx && l != NULL ; i++, l = l->next ) ;
    if( l == NULL )
        return false ;
    else {
        *res = l->data ;
        return true ;
    }
}

List ListPutAtHead(List l, Data val)
{
    return NewNode(val, l) ;
}

List ListPutAtEnd(List l, Data val)
{
    if( l == NULL )
        return NewNode(val, NULL) ;
    else {
        List p ;
        for( p = l ; p->next != NULL ; p = p->next ) ; // Goto last node
        p->next = NewNode(val, NULL) ;  // Assign to the last 'next'
        return l ;
    }
}

List ListFilter(List l, BoolFun toKeep)
{  // TECNICA: Usar um no' inicial suplementar para permitir tratamento uniforme.
    Node dummy ;
    dummy.next = l ;
    l = &dummy ;
    while( l->next != NULL )
        if( toKeep(l->next->data) )
            l = l->next ;
        else {
            List del = l->next ;
            l->next = l->next->next ;
            free(del) ;
        }
    return dummy.next ;
}

void ListPrint(List l)
{
    for( ; l != NULL ; l = l->next)
        printf("%lf\n", l->data) ;
}

static bool isEven(Data data) {
    return (int)data % 2 == 0 ;
}

static bool isOdd(Data data) {
    return (int)data % 2 != 0 ;
}
/*
static void Test() {
    List l = ListMakeRange(1.1, 7.8) ;
    printf("----------\n") ;
    ListPrint(l) ;
    printf("----------\n") ;
    l = ListFilter(l, isEven) ;
    ListPrint(l) ;
    printf("----------\n") ;
    l = ListFilter(l, isOdd) ;
    ListPrint(l) ;
    printf("----------\n") ;
*/
}