/*
 * singly_linked_list.c
 *
 *  Created on: Oct 16, 2019
 *      Author: Bojan Rikic RA134/2016
 */

#include "singly_linked_list.h"

Node* create_node(int_least16_t new_value)
{
    Node* current_node = malloc(sizeof(Node));
    if (!current_node)
    {
    return (Node*)NULL;
    }
    current_node->value = new_value;
    current_node->next = (Node*) NULL;
    return current_node;
}

List* make_list(void)
{
    List* initalize_singly_linked_list = malloc(sizeof(List));
    if (!initalize_singly_linked_list)
    {
        printf("No memory !\n");
        return (List*)NULL;
    }
    initalize_singly_linked_list->head = (Node*)NULL;
    return initalize_singly_linked_list;
}


void push_begin(List* singly_linked_list, int_least16_t n)
{
    Node* new_node_for_push_to_begin = (Node*) malloc(sizeof(Node));
    new_node_for_push_to_begin->value = n;
    new_node_for_push_to_begin->next = singly_linked_list->head;
    singly_linked_list->head = new_node_for_push_to_begin;
}
void insert_in_list(const List* singly_linked_list, const Node *position,int_least16_t n)
{
    Node* new_node = (Node*)NULL;
    Node* tmp_node = (Node*)NULL;

    if (position == (Node*)NULL)
    {
        return;
    }

    new_node = create_node(n);

    tmp_node = singly_linked_list->head;

    while(tmp_node->next != position->next)
    {
        tmp_node = tmp_node->next;
    }

    new_node->next = tmp_node->next;
    tmp_node->next = new_node;
}

void push_end(List* singly_linked_list, int_least16_t n)
{
    Node* new_node_for_push_to_end = (Node*)NULL;
    if(singly_linked_list->head == (Node*)NULL)
    {
        singly_linked_list->head = create_node(n);
    }
    else
    {
        new_node_for_push_to_end = singly_linked_list->head;
        while (new_node_for_push_to_end->next != (Node*)NULL)
        {
            new_node_for_push_to_end = new_node_for_push_to_end->next;
        }
        new_node_for_push_to_end->next = create_node(n);
    }
}

void print_list(const List* singly_linked_list)
{
    Node* current_node_for_print = singly_linked_list->head;
    if(singly_linked_list->head == (Node*)NULL)
    {
        printf("List is empty!\n");
        return;
    }
    printf("List: ");
    while( current_node_for_print !=NULL )
    {
        printf("%"PRIdLEAST16",", current_node_for_print->value);
        current_node_for_print = current_node_for_print->next;
    }
    printf("\n");
}

int_least16_t pop_last(List* singly_linked_list){
    int_least16_t last_element;
    Node* toDelete;
    Node* secondLastNode;

    if(singly_linked_list->head == (Node*)NULL)
    {
        return (int_least16_t)0;
    }
    else
    {
        toDelete = singly_linked_list->head;
        secondLastNode = singly_linked_list->head;

        while(toDelete->next != (Node*)NULL)
        {
            secondLastNode = toDelete;
            toDelete = toDelete->next;
        }

        if(toDelete == singly_linked_list->head)
        {
            singly_linked_list->head = (Node*)NULL;
        }
        else
        {
            secondLastNode->next = (Node*)NULL;
        }
        last_element = toDelete->value;
        free(toDelete);
    }
    return last_element;
}


void clear_list(List* singly_linked_list)
{
    Node* current_node_for_clear_list;

    while(singly_linked_list->head != (Node*)NULL)
    {
        current_node_for_clear_list = singly_linked_list->head;
        singly_linked_list->head = current_node_for_clear_list->next;
        free(current_node_for_clear_list);
    }
}

void split_list(const List* singly_linked_list, List* list_with_even_index,List* list_with_odd_index)
{

    uint_least8_t i = (uint_least8_t)0U;
    Node* node_odd = singly_linked_list->head;
    Node* temp;

    Node* node_odd_temp =  list_with_odd_index->head;
    Node* node_even_temp = list_with_even_index->head;

    while(node_odd != (Node*)NULL)
    {
        temp = create_node(node_odd->value);

        i++;
        if((i%(uint_least8_t)2U) == (uint_least8_t)1U)
        {
            node_odd_temp = temp;
            push_end(list_with_odd_index,node_odd_temp->value);
        }
        else
        {
            node_even_temp = temp;
            push_end(list_with_even_index,node_even_temp->value);
        }
        node_odd = node_odd->next;
    }
    node_odd_temp->next = (Node*)NULL;
    node_even_temp->next = (Node*)NULL;
}