/**
 * Inserts new word from dictionary into trie
 */
void insert_word(char *word)
{
    int word_len = strlen(word) + 1, curr_letter;
    trie *traversal = root;

    for (int i = 0; i < word_len; i++)
    {
        // convert current letter/apostrophe from ascii alphabet value (96-122) to array-like (0-26) value
        // if uppercase - calculate it for lowercase letter
        if (word[i] < 96)
            curr_letter = tolower(word[i]) % 97;
        else
            curr_letter = word[i] % 97;

        // if next letter node is empty - malloc it
        if (traversal->children[curr_letter] == NULL)
        {
            traversal->children[curr_letter] = malloc(sizeof(trie));
        }

        // travel to next letter in trie until end of word
        if (word[i] != '\0')
            traversal = traversal->children[curr_letter];
    }

    traversal->is_word = true;
}

/**
 * Returns true if word is in dictionary else false.
 */
bool check(const char *word)
{
    // variable for iterating through every letter of word, and a traversal pointer
    int word_len = strlen(word), curr_letter;
    trie *traversal = root;

    // go through every letter node for word until an empty node
    for (int i = 0; i < word_len; i++)
    {
        // current letter index in trie array, if uppercase - calculate it for lowercase letter
        if (word[i] < 96)
            curr_letter = tolower(word[i]) % 97;
        else
            curr_letter = word[i] % 97;

        // if next letter's node is null - word is misspelled, else go to next node
        if (traversal->children[curr_letter] == NULL)
            return false;
        else
            traversal = traversal->children[curr_letter];
    }

    if (traversal->is_word)
        return true;
    else
        return false;
}

/**
 * Count total words in trie
 */
int count_words_trie(trie *curr_trie)
{
    trie *traversal = curr_trie;

    // search parent for non-null node
    for (int i = 0; i < ALPHABET_LENGTH; ++i)
    {
        // if found - search children for non-null node
        if (traversal->children[i] != NULL)
            count_words_trie(traversal->children[i]);
    }

    if (traversal->is_word == true)
        word_count++;

    return word_count;
}


bool destroy_trie(trie *curr_trie)
{
    bool success = false;
    trie *traversal = curr_trie;

    // search parent for non-null node
    for (int i = 0; i < ALPHABET_LENGTH; ++i)
    {
        // if found - search children for non-null node
        if (traversal->children[i] != NULL)
            destroy_trie(traversal->children[i]);
    }

    free(traversal);
    success = true;
    return success;
}