#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "sortedcontainer.h"

int data_compare(data* d1, data* d2) {
    assert(d1);
    assert(d2);
    if(d1->age < d2->age) return -1;
    if(d1->age > d2->age) return 1;
    return strcmp(d1->name, d2->name);
}

// Do not change
void data_print(data* d, FILE* f) {
    fprintf(f, "%i %s", d->age, d->name);
}

data* data_new(int age, char const* name) {
    data* d = (data*)malloc(sizeof(data));
    d->age = age;
    strncpy(d->name, name, NAME_LENGTH);
    return d;
}

void data_delete(data* d) {
    free(d);
}

node* node_new(data* d) {
    struct node* new_node = (node*) malloc(sizeof(struct node));
    new_node->data = d;
    new_node->left = NULL;
    new_node->right = NULL;
    return new_node;
}

void node_delete(node* n) {
    if(n) {
        data_delete(n->data);
        free(n);
    }
}

sortedcontainer* sortedcontainer_new() {
    sortedcontainer* d = (sortedcontainer*)malloc(sizeof(sortedcontainer));
    d->root = NULL;
    return d;
}

void sortedcontainer_insert(sortedcontainer* sc, data* data) {
    if(!data) {
        return;
    }
    node* n = node_new(data);
    node* root = sc->root;
    if(!node) {
        sc->node = n;
    } else {
        sortedcontainer_insert_rec(root, n);
    }
}

void sortedcontainer_insert_rec(node* node, node* new_node) {
    data* data = node->data;
    data* new_data = new_node->data;
    bool isSmaller = data_compare(data, newData) <= 0;
    if(isSmaller) {
        if(node->left == NULL) {
            node->left = new_node;
        } else {
            sortedcontainer_insert_rec(node->left, new_node);
        }
    } else {
        if(node->right == NULL) {
            node->right = new_node;
        } else {
            sortedcontainer_insert_rec(node->right, new_node);
        }
    }
}

int sortedcontainer_erase(sortedcontainer* sc, data* data) {
    /// TODO

    if(n) {
        node* left = n->left;
        node* right = n->right;
        bool hasLeft = left;
        bool hasRight = right;
        if(hasLeft && !hasRight) {

        } else if(!hasLeft && hasRight) {

        } else if(hasLeft && hasRight) {
            n = left;
            left->
        } else {
            free(n);
        }
    return 0;
}

int sortedcontainer_contains(sortedcontainer* sc, data* data) {
    // Implement this
    (void)sc;
    (void)data;
    return 0;
}

// Do not change
static void node_printtree(node* n, int level, FILE* printFile) {
    fprintf(printFile, "%*s ", level, "");
    if(n) {
        data_print(n->data, printFile);
        fprintf(printFile, "\n");
        node_printtree(n->left, level+1, printFile);
        node_printtree(n->right, level+1, printFile);
    } else {
        fprintf(printFile, "(nil)\n");
    }
}

// Do not change
void sortedcontainer_print(sortedcontainer* sc, FILE* printFile) {
    node_printtree(sc->root, 0, printFile);
}

static void node_deletetree(node* n) {
    if(n) {
        node* left = n->left;
        node* right = n->right;
        node_delete(n);
        node_deletetree(left);
        node_deletetree(right);
    }
}

void sortedcontainer_delete(sortedcontainer* sc) {
    node_deletetree(sc->root);
    free(sc);
}

node* copy_construct_node(node* n) {
    if(!n) {
        return NULL;
    }
    struct node* copy = (node*) malloc(sizeof(struct node));
    copy->data = n->data;
    copy->left = n->left;
    copy->right = n->right;
}