#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)
// Die statische Variable (das Gedächtnis) muss außerhalb oder static innerhalb sein

/*
 * nextTreeData - Iterative In-Order Traversierung (wie strtok)
 * * Funktionsweise:
 * 1. Initialisierung (root != NULL):
 * - Löscht alten Stack.
 * - Wandert von root so weit nach LINKS wie möglich.
 * - Pushed alle Knoten auf dem Weg auf den Stack.
 * -> Das kleinste Element liegt nun oben.
 * * 2. Iteration (root == NULL):
 * - Pop: Nimmt oberstes Element vom Stack (aktuell kleinstes).
 * - Logik: Hat dieses Element einen RECHTEN Nachbarn?
 * -> JA: Gehe eins nach rechts, dann wieder alles nach LINKS pushen.
 * -> NEIN: Nichts tun (der Elternknoten liegt schon als nächstes auf dem Stack).
 * - Gibt die Daten des gepoppten Elements zurück.
 */
static StackNode *iteratorStack = NULL;

void *nextTreeData(TreeNode *root)
{
    // ============================================================
    // PHASE 1: Initialisierung (Neuer Baum wird übergeben)
    // ============================================================
    if (root != NULL)
    {
        // 1. Aufräumen: Falls noch Reste vom letzten Mal da sind
        if (iteratorStack != NULL) {
            clearStack(iteratorStack);
            iteratorStack = NULL; // Wichtig: Zeiger "erden"
        }
        
        // 2. Initial befüllen: "Push root and all left nodes"
        TreeNode *currentNode = root;
        while (currentNode != NULL)
        {
            // HIER war deine Frage: Ja, wir müssen iteratorStack aktualisieren!
            // Wir casten TreeNode* implizit zu void* für den Stack.
            iteratorStack = push(iteratorStack, currentNode);
            
            // Immer weiter nach links absteigen
            currentNode = currentNode->left;
        }
        
        // WICHTIG: Wir geben hier noch nichts zurück!
        // Der erste Aufruf initialisiert nur. Um das erste Element zu bekommen,
        // fällt der Code einfach weiter nach unten in Phase 2.
    }

    // ============================================================
    // PHASE 2: Iteration (Nächsten Wert holen)
    // ============================================================
    
    // Wenn der Stack leer ist (oder leer war), sind wir fertig.
    if (iteratorStack == NULL)
    {
        return NULL; 
    }

    // 1. Wir schauen uns das oberste Element an (der nächste Knoten in der Reihe)
    // Wir wissen, dass es ein TreeNode* ist, also casten wir.
    TreeNode *nodeToReturn = (TreeNode*) top(iteratorStack);
    
    // 2. Wir entfernen ihn vom Stack (er ist jetzt "verarbeitet")
    // Auch hier: pop gibt den neuen Head zurück, also variable aktualisieren!
    iteratorStack = pop(iteratorStack);

    // 3. Wir retten die Nutzer-Daten (z.B. den Integer), bevor wir weiterwandern
    void *userData = nodeToReturn->data;

    // 4. Nachfolger suchen (Die Logik für In-Order: Rechts, dann alles links)
    if (nodeToReturn->right != NULL)
    {
        TreeNode *currentNode = nodeToReturn->right;
        while (currentNode != NULL)
        {
            // Auch hier: Stack aktualisieren
            iteratorStack = push(iteratorStack, currentNode);
            currentNode = currentNode->left;
        }
    }

    // Wir geben die echten Daten zurück (nicht den Knoten, sondern den Inhalt)
    return userData;
}

// 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);
}