#include <string.h>
#include "stack.h"
#include "bintree.h"

//TODO: binären Suchbaum implementieren
/*  * `addToTree`: fügt ein neues Element in den Baum ein (rekursiv),
    * `clearTree`: gibt den gesamten Baum frei (rekursiv),
    * `treeSize`: zählt die Knoten im Baum (rekursiv),
    * `nextTreeData`: Traversierung mit Hilfe des zuvor implementierten Stacks. */



//Hilfsfunktion für addToTree. Erstellt eine treenode.
static TreeNode* createTreeNode(const void *data, size_t dataSize)
{
    TreeNode* newNode = calloc(1, sizeof(TreeNode));
    if(!newNode)
    {
        return NULL;
    }
    newNode ->data = malloc(dataSize);
    if(!newNode->data)
    {
        free(newNode);
        return NULL;
    }
    memcpy(newNode -> data, data, dataSize);
    return newNode;
}

// Adds a copy of data's pointer destination to the tree using compareFct for ordering. Accepts duplicates
// if isDuplicate is NULL, otherwise ignores duplicates and sets isDuplicate to 1 (or to 0 if a new entry is added). (auf 1 wenn duplikat geaddet)
TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFctType compareFct, int *isDuplicate)
{
    if(!root)
    {
        TreeNode *newNode = createTreeNode(data, dataSize);
        if(isDuplicate != NULL)
        {
            *isDuplicate = 0;
        }
        return newNode;
    }
    int compare = compareFct(data, root-> data);
    if(compare < 0)
    {
        root -> left = addToTree(root -> left, data, dataSize, compareFct, isDuplicate);
    }
    else if(compare > 0)
    {
        root -> right = addToTree(root -> right, data, dataSize, compareFct, isDuplicate);
    }
    else
    {
        if(isDuplicate != NULL)
        {
            *isDuplicate = 1;
            return root;
        }
        //Konvention: rechts ist >= also das Duplikat wird nach rechts verfrachtet.
        root -> right = addToTree(root -> right, data, dataSize, compareFct, isDuplicate);
    }
    return root;
}


// Iterates over the tree given by root. Follows the usage of strtok. If tree is NULL, the next entry of the last tree given is returned in ordering direction.
// Use your implementation of a stack to organize the iterator. Push the root node and all left nodes first. On returning the next element,
// push the top node and push all its left nodes.
// Wir brauchen eine statische Variable, die überdauernd existiert
// (Alternativ kann man diese auch global ausserhalb definieren)
static Stack *iteratorStack = NULL; 

void *nextTreeData(TreeNode *root)
{
    // --- FALL 1: Initialisierung (Neuer Baum wird übergeben) ---
    if (root != NULL)
    {
        // Falls noch ein alter Stack da ist: Aufräumen!
        // (Hängt von deiner stack.h ab, ob es clearStack oder ähnlich gibt)
        if (iteratorStack != NULL) {
            clearStack(iteratorStack); // oder freeStack, je nach Implementierung
            iteratorStack = NULL;      // Sicherstellen, dass er leer ist
        }
        
        // Neuen Stack erstellen (falls nötig)
        // Angenommen, du hast eine Funktion wie createStack() oder initStack()
        if (iteratorStack == NULL) {
            iteratorStack = createStack(); // oder wie deine Init-Funktion heißt
        }

        // Jetzt: "Push root and all left nodes"
        TreeNode *currentNode = root;
        while (currentNode != NULL)
        {
            push(iteratorStack, currentNode); // Achtung: Funktionsname aus stack.h prüfen
            currentNode = currentNode->left;
        }
        
        // Bei strtok gibt der erste Aufruf oft schon das erste Element zurück.
        // Wir fallen also einfach in den Code unten rein (kein return hier).
    }

    // --- FALL 2: Fortsetzung (root ist NULL) ---
    // Wenn der Stack leer ist, sind wir fertig mit dem Baum
    if (iteratorStack == NULL || stackIsEmpty(iteratorStack)) // Name aus stack.h prüfen
    {
        return NULL;
    }

    // 1. Nimm das oberste Element (das ist "dran")
    TreeNode *nodeToReturn = pop(iteratorStack); // Name aus stack.h prüfen
    
    // Daten sichern, bevor wir weitermachen
    void *data = nodeToReturn->data;

    // 2. Vorbereiten für das NÄCHSTE Mal:
    // Wenn wir rechts abbiegen können, tun wir das.
    // Die Regel ist: Einmal rechts, dann immer links runter.
    if (nodeToReturn->right != NULL)
    {
        TreeNode *currentNode = nodeToReturn->right;
        
        while (currentNode != NULL)
        {
            push(iteratorStack, currentNode);
            currentNode = currentNode->left;
        }
    }

    return data;
}

// Releases all memory resources (including data copies).

// Gibt den gesamten Speicher (Knoten + Daten) frei
void clearTree(TreeNode *root)
{
    // 1. Abbruchbedingung: Wenn der Knoten existiert, müssen wir was tun.
    // Wenn er NULL ist, machen wir einfach gar nichts (return void).
    if (root)
    {
        // 2. Rekursion: Erst tief in den Baum absteigen (Post-Order)
        clearTree(root->left);
        clearTree(root->right);

        // 3. Jetzt sind die Kinder weg. Wir kümmern uns um den aktuellen Knoten.
        
        // Erst den Inhalt (die Datenkopie) löschen!
        // (free(NULL) ist in C erlaubt, daher müssen wir nicht zwingend auf NULL prüfen,
        // aber es schadet auch nicht).
        free(root->data); 

        // 4. Dann den Container (den Knoten selbst) löschen
        free(root);
    }
}

// Returns the number of entries in the tree given by root.
unsigned int treeSize(const TreeNode *root)
{
    // Abbruchbedingung: Wenn kein Knoten da ist, ist die Größe 0
    if (root == NULL)
    {
        return 0;
    }

    // Rekursionsschritt:
    // 1 (für den aktuellen Knoten) + alles im linken Baum + alles im rechten Baum
    return 1 + treeSize(root->left) + treeSize(root->right);
}