#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
#include <string.h>
#include "clog.h"

// Linked list of strings on the heap

typedef struct _Node {  // canonical type name is 'struct _Node'
    // int   value; // v1 - linked list of ints
    // char* value; // v2 - linked list of strings
    void* a_value;  // v3 - linked list of anything
    struct _Node* next;
} Node;  // shortcut (typedef) name is 'Node'

void print_list(Node* head) {
    for(Node* curr = head; curr != NULL; curr = curr -> next) {
        printf("[%p]", (void*) curr -> a_value);
        printf(curr -> next != NULL ? "→" : "\n");
    }
}

// void append(int value, Node** a_head, Node** a_tail) {   // v1 - linked list of ints
// void append(char* value, Node** a_head, Node** a_tail) { // v2 - linked list of strings
void append(void* a_value, Node** a_head, Node** a_tail) {  // v3 - linked list of anything

    // 1. Allocate memory for the new node.
    Node* new_tail = malloc(sizeof(*new_tail));

    // 2. Initialize the fields of the new node.
    *new_tail = (Node) { .a_value = a_value, .next = NULL };

    // 3. Depending on whether or not the list was initially empty…
    if(*a_head == NULL) {  // If list is empty (size 0)…
        // … Set the head (*a_head) to the (address of) the new tail, or …
        *a_head = new_tail; // type of  *a_head is Node*.  type of new_tail is Node*.
    }
    else {
        // … Connect the old tail to the new tail.
        (*a_tail) -> next = new_tail;
    }

    // 4. Set the tail (*a_tail) to the (address of the) new tail.
    *a_tail = new_tail;
    // IMPORTANT:  This must come last.
}

void destroy_list(Node** a_head, Node** a_tail) {
    while(*a_head != NULL) {  // While list is not empty…
        Node* new_head = (*a_head) -> next;  // 1. Save (address of) new head (or NULL)
        //free((*a_head) -> value);            // 2. Free whatever head node refers to.
        free(*a_head);                       // 3. Free the old head.
        *a_head = new_head;                  // 4. Set the head to the new_head.
    }
    *a_tail = NULL;                          // 5. Set the tail to NULL.
    // Order is important.  If we free before saving the (address of) new_head, we won't 
    // be able to access it.
    
    assert(*a_head == NULL);
}

int main(int argc, char* argv[]) {
    Node* head = NULL; // Linked list of size 0 (empty list)
    Node* tail = NULL;

    char* s1 = "AB";
    append(s1, &head, &tail);
    assert(head == tail); // In a list of size 1, head and tail refer to the same Node.

    char* s2 = "CD";
    append(s2, &head, &tail);
    assert(head != tail); // In a list of size 2, head and tail DON'T refer to the same Node
    //assert(tail -> value == 11);
    char* s3 = "EF";
    append(s3, &head, &tail);

    print_list(head);

    destroy_list(&head, &tail);
    assert(head == NULL);
    assert(tail == NULL);

    return EXIT_SUCCESS;
}