#include "namesarchive.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

typedef struct node
{
    char *name;
    struct node *left;
    struct node *right;
} Node;

static Node *root = NULL;

static Node *createNameNode(const char *name)
{
    Node *newNode = NULL;
    
    if(name != NULL)
    {
        newNode = calloc(1, sizeof(Node));

        if(newNode != NULL)
        {
            newNode->name = malloc(sizeof(char) * (strlen(name)+1));

            if(newNode->name != NULL)
                strcpy(newNode->name, name);
            else
            {
                free(newNode);
                newNode = NULL;
            }
        }
    }

    return newNode;
}

static Node *addNameRec(Node* root, const char *newName)
{
    if(root == NULL)
        root = createNameNode(newName);
    else if(strcmp(newName, root->name) <= 0)
        root->left = addNameRec(root->left, newName);
    else
        root->right = addNameRec(root->right, newName);

    return root;
}

void addName(const char *name)
{
    root = addNameRec(root, name);
}

static void printNamesRec(Node *root)
{
    if(root != NULL)
    {
        printNamesRec(root->left);
        printf("%s\n", root->name);
        printNamesRec(root->right);
    }
}

void printNames()
{
    printNamesRec(root);
}

static void disposeNode(Node *node)
{
    if(node != NULL)
        free(node->name);
    free(node);
}

static Node *removeNameRec(Node *root, const char *name)
{
    if(root != NULL)
    {
        if(strcmp(name, root->name) < 0)
            root->left = removeNameRec(root->left, name);
        else if(strcmp(name, root->name) > 0)
            root->right = removeNameRec(root->right, name);
        else
        {
            if(root->left == NULL)
            {
                Node *nodeToRemove = root;
                root = root->right;
                disposeNode(nodeToRemove);
            }
            else if(root->right == NULL)
            {
                Node *nodeToRemove = root;
                root = root->left;
                disposeNode(nodeToRemove);
            }
            else
            {
                Node *succParent = root;
                Node *succ = succParent->right;

                while(succ->left != NULL)
                {
                    succParent = succ;
                    succ = succ->left;
                }

                if(succParent == root)
                {
                    succParent->right = succ->right;
                }
                else
                {
                    succParent->left = succ->right;
                }

                free(root->name);
                root->name = succ->name;
                free(succ);
            }
        }
    }
    return root;
}

void removeName(const char *name)
{
    root = removeNameRec(root, name);
}

static void clearNodeRec(Node *node)
{
    if(node != NULL)
    {
        clearNodeRec(node->left);
        clearNodeRec(node->right);
        disposeNode(node);
    }
}

void clearArchive()
{
    clearNodeRec(root);
    root = NULL;
}