/*
 * definition of functions in sorted-int-list.h
 *
 * implemented using iteration (i.e., loops)
 */
#include "sorted-int-list.h"

/*
 * insert n into list and return updated list 
 */
sorted_int_list_node_t * sorted_int_list_insert(
		sorted_int_list_node_t * lst, int n) 
{
	sorted_int_list_node_t * newnode = malloc(sizeof *newnode);
	if (newnode == NULL) {
		puts("could not get memory");
		exit(1);
	}
	newnode->data = n;
	newnode->next = NULL;

    /* special case for empty list */
    if (lst == NULL) {
        return newnode;
    }

    /* special case for inserting at start of list */
    if (lst->data > n) {
        newnode->next = lst;
        return newnode;
    }

    /* traverse list until we get to node just before where to insert */
    sorted_int_list_node_t * p;
    for (p = lst; (p->next != NULL) && (p->data >= n); p = p->next) { }

    /* insert new node and return */
    newnode->next = p->next;
    p->next = newnode;
    return lst;
}

/* 
 * count occurrences of n in list
 */
int sorted_int_list_count(sorted_int_list_node_t * lst, int n) {

    int count = 0;
    /* traverse list (loop executes 0 times if empty list) */
    for (sorted_int_list_node_t * p = lst; p != NULL; p = p->next) {
        if (p->data == n) count += 1;
    }
    return count;
}

/* 
 * remove all occurrences of n from list and return updated list
 */
sorted_int_list_node_t * sorted_int_list_remove(
		sorted_int_list_node_t * lst, int n)
{
    /* special case for empty list */
	if (lst == NULL) {
		return NULL;
	}

    /* special case for node(s) at start of list */
	if (lst->data == n) {
        do {
            sorted_int_list_node_t * to_delete = lst;
            lst = lst->next;
            free(to_delete);
        } while (lst->data == n);
    }

    /* traverse list until we get past nodes that could be removed */
    for (sorted_int_list_node_t * p = lst; 
            (p->next != NULL) && (p->data <= n);
            p = p->next) 
    {
        if (p->next->data == n) {
            /* remove node from list */
            sorted_int_list_node_t * to_delete = p->next;
            p->next = p->next->next;
            free(to_delete);
        }
    }
    return lst;
}

/*
 * remove all nodes from list and return NULL
 */
sorted_int_list_node_t * sorted_int_list_remove_all(
		sorted_int_list_node_t * lst) 
{
    sorted_int_list_node_t * p = lst;

    /* 
     * traverse list 
     * (can't use a for loop here since after we free a node we don't
     * have access to its "next" field)
     */
    while (p != NULL) {
        sorted_int_list_node_t * to_delete = p;
        p = p->next;
        free(to_delete);
    }
	return NULL;
}

/*
 * print all elements of lst to output stream f using format fmt
 * ("fmt" is the kind of string expected by fprintf, e.g., "%d " or "%d\n")
 *
 * the FILE * parameter lets the caller decide whether to print
 *   to stdout or a file (already open) or what
 * the fmt parameter lets the caller decide whether to print all on 
 *   one line or each on a separate line or what
 */
void sorted_int_list_print(sorted_int_list_node_t * lst, FILE * f, char * fmt)
{
    /* traverse list (loop executes 0 times if empty list) */
    for (sorted_int_list_node_t * p = lst; p != NULL; p = p->next) {
        /* print data for this node */
        fprintf(f, fmt, p->data);
    }
}