#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <cs50.h>
#include <string.h>

typedef struct dllist
{
    char word[26];
    struct dllist *next;
    struct dllist *prev;
}
dllnode;

// this will take more bytes of memory
// than a singly linked list
// don't use if you don't want to delete elements

// why can't you call it dllnode initially?


/*
singly linked lists are easy to add to, but hard to remove from
doubly linked lists resolve this issue

singly linked lists exted the ability to collect and organize data,
however they can only ever move in one direction through the list
this makes it difficult to delete a node

a doubly linked list allows moving forward and backward
through the list, all by adding one extra pointer to our
struct definition
*/

bool find(dllnode *head, char *string);

/*
the hash function should return the sum
of the ascii values of the first 3 letters
in char. it works even if the string is fewer
than 3
*/
unsigned int hash(const char *word)
{

    char c;
    int val = 0;
    //int cval;
    for (int i = 0; word[i] != '\0'; i++)
    {
        if (i < 3)
        {
            c = word[i];
            val += c;
        }
        else
        {
            continue;
        }
        /*
        this should work even if there
        is no char stored at word i
        when the word is shorter than 3 chars?
        */

    }
    return val%26;
}
bool find(dllnode *head, char *string)
{
    dllnode *trav = head;
    bool found = false;

    for (int i = 0; trav != NULL; i++)
    {
        for (int j = 0; trav->word[j] != '\0'; j++)
        {
            if (trav->word[j] == string[j]) // this returns true if any of the characters match
            {
                found = true;
                //continue;?
            }
            else
                found = false;
        }
        trav=trav->next;
    }
    return found;
}

//unsigned int size(void)
unsigned int size(dllnode *innode)
{
    dllnode *nownode = innode;
    int count = 0;
    int i = 0;
    while (nownode->next != NULL)
    {
        count++;
        i++;
        nownode = nownode->next;
    }
    return count;
}
// size table[1] returns 2... why not 3?

/*
return the number of words in the dictionary
you might iterate over every linked list in
the hashtable counting the number of
nodes in the linked list

or
as you are loading the hash table
you could keep track of the number
of words loaded so farin the linked list and return
the value in the size function

*/
dllnode *insert(dllnode *head, char *string)
{
    //dllnode *tmp = head;

    dllnode *input = malloc(sizeof(dllnode));
    for (int i = 0; string[i] != '\0'; i++)
    {
        input->word[i] = string[i];
    }


    //input->next = head;
    //input->prev = NULL;
    head->prev = input;
    input->prev = NULL;
    input->next = head;

    return input;

}

void erase(dllnode *target)
{
    target->prev->next = target->next;
    target->next->prev = target->prev;
    free(target);
}

/*
void delpoint(dllnode *head)
{
    dllnode *cursor = head;
    dllnode *tmp = cursor->next;
    while (cursor != NULL)
    {
        //dllnode *tmp = cursor;
        free(tmp)
    }
}


steps involved
    a. if you've reached a null pointer, stop
    b. delete the rest of the list..... how to delete? in a loop? set the value to null? empty?
    c. free the current node

    recursion
    delete everyone else
    then delete me

    in order to work with linked lists effectively, there are a number of operations to understand
        1. create a linked list when it doesn't already exist
        2. search through a linked list to find an element
        3.insert a new node into the linked list.
        4. delete a single element from a linked list
            this is not easy as you need to keep two pointers
            doubly linked lists resolve this issue
        5. delete an entire linked list

*/

void destroy(dllnode *head)
{
    dllnode *cursor = head;// create a pointer, "cursor", and point it to the same place as head
    while (cursor != NULL)
    {
        dllnode *temp = cursor->next;// create a pointer and point it to the same place as cursor->next
        //free(temp);//free the memory that cursor points to
        // prints Soundgarden  `
        free(cursor);
        //prints # `#, - `-
        //free the memory that cursor points to
        cursor = temp;// set cursor to point to the same place as temp
        //free(cursor);
    }
    //free(cursor);
    //free(head);
    //dllnode *elim = head;

    //dllnode *cursor = elim->next;
    /*
    head points to the first node of the linked list
    head and elim point to the first node in the linked list
    they hold the address of that node, but they are not that node
    elim is also a local variable to the function so setting it to
    NULL doesn't affect the actual original head pointer that is in main

    erasing the address doesn't demolish the building, you just
    won't know where it is. setting elim == NULL doesn't magically demolish
    the building. the building is still there, the address is now gone

    if you want to release the memory used by a node,
    you have to use free to say that you don't need it anymore.
    because the pointer is separate from the thing it points to
    calling free on that pointer does not set it to NULL
    the pointer will still be pointing to the memory
    you freed, it just won't be in memory anymore

    to free a linked list:

    1. Create a pointer "cursor" and point it to the same place as head
    2. as long as cursor is not NULL:
        a. create a pointer "temp" and point it to the same place as
        "cursor->next"
        b. free the memory that "cursor" points to
        c. set "cursor" to point to the same place as tmp
    */

    //while (elim->next != NULL)
    //while (elim != NULL)
    //while (cursor != NULL)
    //{
        //cursor = cursor->next;
        //if (cursor == NULL)

        //dllnode *cursor = elim->next;

        //elim = elim->next;
        //if (elim != NULL)
        //elim = elim->next;

        /*
        if (elim->next == NULL)
        {
            elim = NULL;
            //elim = elim->next;
        }
        else
        {
            elim = elim->next;
        }
        */
    //}
    return;
    /*
    dllnode *eliminate = head;
    while (eliminate != NULL)
    {
        eliminate = NULL;
        eliminate = eliminate->next;
        //eliminate = NULL;
        free(eliminate);
    }
    */
}

//bool unload(void)
bool unload(dllnode *nownode)
{
    int i = 0;
    dllnode *cursor = nownode;
    while (cursor->next != NULL)
    {
        dllnode *tmp = cursor;
        cursor = cursor->next;
        free(tmp);
        i++;
    }
    return false;
}

int main(int argc, char *argv[])
{

    dllnode *fruit1 = malloc(sizeof(dllnode));
    dllnode *fruit2 = malloc(sizeof(dllnode));
    dllnode *fruit3 = malloc(sizeof(dllnode));

    char *f1 = "apple";
    char *f2 = "avocado";
    char *f3 = "papaya";

    char *f4 = "avocado";
    bool cmp = strcmp(f4, f3);
    printf("comparing strings:\n");
    printf("string f2 prints: %s\n", f2);
    printf("string f4 prints: %s\n", f4);
    printf("strcmp(f4, f2) prints: ");
    printf("%d ",strcmp(f4,f2));
    if(strcmp(f4, f2) == 0)
    {
        printf("Match!\n");
    }
    else
    {
        printf("strings don't match:( \n");
    }

    /*
    for (int i = 0; f1[i] != '\0'; i++)
    {
        fruit1->word[i] = f1[i];
    }
    */
    printf("fruit1->word prints %s\n", fruit1->word);
    printf("applying strcpy: \n");
    strcpy(fruit1->word,f1);
    fruit1->next = fruit2;
    fruit1->prev = NULL;

    strcpy(fruit2->word,f2);
    fruit2->next = fruit3;
    fruit2->prev = fruit1;

    strcpy(fruit3->word, f3);
    fruit3->next = NULL;
    fruit3->prev = fruit2;

    printf("\n\nnow printing linked list of fruits: \n\n");
    printf("fruit1->word prints:  %s\n",fruit1->word);
    printf("fruit1->next->word prints:  %s\n",fruit1->next->word);
    printf("fruit1->prev->word prints:  %s\n",fruit1->prev->word);
    printf("fruit2->word prints:  %s\n",fruit2->word);
    printf("fruit2->next->word prints:  %s\n",fruit2->next->word);
    printf("fruit2->prev->word prints:  %s\n",fruit2->prev->word);
    printf("fruit3->next->word prints:  %s\n\n",fruit3->next->word);
    printf("fruit3->word prints:  %s\n\n",fruit3->word);
    printf("fruit3->prev->word prints:  %s\n\n",fruit3->prev->word);

    dllnode *band1 = malloc(sizeof(dllnode));
    dllnode *band2 = malloc(sizeof(dllnode));
    dllnode *band3 = malloc(sizeof(dllnode));

    char *b2 = "Nirvana"; // points to mudhoney next
    char *b3 = "Mudhoney";


    printf("strcpytest: \n");
    printf("band1->word prints %s\n",band1->word);
    printf("applying strcpy: \n");

    strcpy(band1->word,"Soundgarden"/*b1*/);
    band1->next = band2;
    band1->prev = NULL;

    printf("now band1->word prints %s\n",band1->word);


    printf("band2->word prints %s\n", band2->word);
    printf("applying strcpy: \n");
    strcpy(band2->word,b2);
    band2->next = band3;
    band2->prev = band1;

    printf("band3->word prints %s\n", band3->word);
    printf("applying strcpy: \n");
    strcpy(band3->word,b3);
    band3->next = NULL;
    band3->prev = band2;

    printf("band1->word prints %s\n", band1->word);
    printf("band1->next->word prints %s\n", band1->next->word);

    dllnode *prog1 = malloc(sizeof(dllnode));
    dllnode *prog2 = malloc(sizeof(dllnode));
    dllnode *prog3 = malloc(sizeof(dllnode));

    char *p1 = "Photoshop";
    char *p2 = "Maya";
    char *p3 = "Zbrush";

    strcpy(prog1->word, p1);
    prog1->next = prog2;
    prog1->prev = NULL;

    strcpy(prog2->word, p2);
    prog2->next = prog3;
    prog2->prev = prog1;

    strcpy(prog3->word, p3);
    prog3->next = NULL;
    prog3->prev = prog2;

    dllnode *table[3];
    table[0] = fruit1;
    table[1] = band1;
    table[2] = prog1;

    for (int i = 0; i < 3; i++)
    {
        printf("table[%i]->word prints: %s\n",i,table[i]->word);
        printf("table[%i]->next->word prints: %s\n",i,table[i]->next->word);
        printf("table[%i]->next->next->word prints: %s\n",i,table[i]->next->next->word);

    }

    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; table[i]->word[j] != '\0'; j++)
        {

            if (table[i]->word[j] == '\0')
            {
                printf("%c \n",table[i]->word[j]);
            }
            else
            {
                printf("%c \n", table[i]->word[j]);
            }
        }
    }

    printf("\n\n");

    printf("cursor word loop forwards\n");
    for (int i = 0; i < 3; i++) // how do i know how big table is?
    {
        dllnode *cursor = table[i];
        for (int j = 0; cursor != NULL; j++)
        {
            printf("%s ", cursor->word);
            cursor = cursor->next;
        }
    }
    printf("\n\n");

    printf("cursor word loop backwards\n");
    for (int i = 2; i >= 0; i--) // how do i know how big table is?
    {
        dllnode *cursor = table[i]->next->next;
        for (int j = 0; cursor != NULL; j++)
        {
            printf("%s ", cursor->word);
            cursor = cursor->prev;
        }
    }
    printf("\n\n");
    printf("testing the find function");

    bool resultm = find(table[2],"Maya");
    printf("now looking for a word with the find() function\n");
    printf("does the word maya appear in the table[2]?\n");
    printf("looking for the word Maya in table[2]\n");
    printf("find(table[2],resultm) prints: \n");
    printf("%d\n",resultm);
    printf("resultm prints:\n");
    if (resultm)
    {
        printf("Found!\n\n");
    }
    else
        printf("Not Found :(\n\n");

    printf("searching table[1] for papaya\n");
    bool resultp = find(table[0], "papaya");
    if (resultp)
    {
       printf("papaya found!\n");
    }
    else
        printf("papaya not found :(");

    bool results = find(table[1], "stairs");
    if (results)
    {
       printf("stairs found!\n");
    }
    else
        printf("stairs not found :(\n");

    printf("the words in table[1] are:\n\n");

    dllnode *cursor = table[1];
    for (int j = 0; cursor != NULL; j++)
    {
        printf("%s ", cursor->word);
        cursor = cursor->next;
    }
    printf("\n");

    printf("does the word boobs appear in table[1]?\n");
    bool resultb = find(table[1], "boobs");
    if (resultb)
    {
       printf("boobs found!\n");
    }
    else
        printf("boobs not found :(\n");

    printf("testing the insert function:\n");

    printf("the words in table[0] before insert() are:\n\n");

    dllnode *traverse = table[0];
    for (int j = 0; traverse != NULL; j++)
    {
        printf("%s ", traverse->word);
        traverse = traverse->next;
    }
    printf("\n\n");


    char *insword = "hereiam!";
    char *outword = table[0]->next->word;

    table[0] = insert(table[0], insword);


    printf("the words in table[0] after insert() are:\n\n");

    traverse = table[0];
    for (int j = 0; traverse != NULL; j++)
    {
        printf("%s ", traverse->word);
        traverse = traverse->next;
    }
    printf("\n\n");

    printf("testing the erase function:\n");
    printf("trying to erase the node stored at table[0]->next:\n");
    erase(table[0]->next);
    printf("the words in table[0] after erase() are: \n");

    /*
    delete is a key word and shouldn't be used?
    prints hereiam! avocado papaya
    apple has been erased
    */

    traverse = table[0];
    for (int j = 0; traverse != NULL; j++)
    {
        printf("%s ", traverse->word);
        traverse = traverse->next;
    }
    printf("\n\n");

    printf("testing the destroy() function: \n");
    printf("the words in table[1], before the destroy() function\n");

    //travel = table[1];
    for (dllnode *travel = table[1];travel != NULL; travel = travel->next)
    {
        printf("%s ",travel->word);
    }
    printf("\n");
    /*
    printf("the words in table[1], after the destroy() function\n");
    destroy(table[1]);
    for (dllnode *travel = table[1];travel != NULL; travel = travel->next)
    {
        printf("%s ",travel->word);
    }
    printf("\n");
    */
    printf("all the words each node of table before destroy print: \n");
    //for (int i = 0, dllnode *travel = table[i];travel != NULL, table[i] != NULL;i++, travel = travel->next)
    //for (int i = 0, dllnode *travel = table[i]; travel != NULL; travel = travel->next,i++)

    //for (int i = 0; table[i] != NULL; i++)
    for (int i = 0; i < 3; i++)
    {
        dllnode *travel = table[i];
        while (travel != NULL)
        //while (travel->next != NULL)
        {
            printf("%s ",travel->word);
            travel = travel->next;
        }

        //printf("all the words each each node of table print: ");
    }
    printf("\n\n");
    printf("all the words eachnode of table after destroy print: \n");
    //for (int i = 0; table[i] != NULL; i++)
    for (int i = 0; i < 2; i++)
    {
        dllnode *travel = table[i];
        //while (travel != NULL)
        /*
        the inner loop is concerned with the
        contents one one particular index
        it should loop through that linked list
        until it finds a NULL pointer
        */
        while (travel->next != NULL)
        {
            destroy(travel);
            travel = travel->next;
        }
    }
    //for (int i = 0; table[i] != NULL; i++)
    /*
    the value that i holds is
    not used to determine if you stop or not

    your outer for loop should not be concerned
    with the values stored in the table
    it's only job is to iterate over every index of
    the table
    */
    for (int i = 0; i < 2; i++)
    {
        dllnode *travel = table[i];
        while (travel != NULL)
        {
            printf("%s ",travel->word);
            travel = travel->next;
        }
    }
    printf("\n\n");

    printf("all the words in table after unload\n");
    printf("unloading table:\n");

    for (int i = 0; i < 2; i++)
    {
        unload(table[i]);
    }

    printf("printing table after unload\n");
    for (int i = 0; i < 2; i++)
    {
        dllnode *travel = table[i];
        while (travel != NULL)
        {
            printf("%s ",travel->word);
            travel = travel->next;
        }
    }
    printf("\n");
    printf("testing hash function!\nHashing absolute\n");
    char *phen = "absolute";
    int hp = hash(phen);
    printf("hash(phen) prints %i\n",hp);
    printf("phen prints %s\n", phen);
    // prints 5
    char a = 'a';
    char b = 'b';
    char s = 's';
    printf("char a = %c\nchar b = %c\nchar s = %c\n",a,b,s);
    printf("the integer values of a, b, and c are:\n");
    printf("a = %i\nb = %i\ns = %i\n",a,b,s);
    printf("the value of (a + b + s) = %i\n",(a + b + s));
    printf("the value of (a + b + s) modulus 26 = %i\n",(a + b + s)%26);
    int modtest = 310%26;
    printf("310 modulus 26 = %i\n",modtest);

    char *name = "Ja";
    //int hn = hash(name);
    printf("name prints %s\n",name);
    printf("hash(name) prints %i\n",hash(name));
    printf("name[0] prints: %i\n",name[0]);
    printf("name[1] prints: %i\n",name[1]);
    printf("name[0] + name[1] prints: %i\n",name[0]+name[1]);
    printf("171 modulus 26 prints %i\n", 171%26);
    printf("name[0] + name[1] modulus 26 prints: %i\n",(name[0]+name[1])%26);
    printf("size(table[1]) prints: ");

    int tabsize = size(table[1]);
    printf("%i\n",tabsize);
    // why does size print 2 and not 3?

    //unload(table[1]);

    //printf("hashing words into a hash table");


    free(prog1);
    free(prog2);
    free(prog3);
    free(band1);
    free(band2);
    free(band3);
    free(fruit1);
    free(fruit2);
    free(fruit3);
    //free(input);
}