#ifndef FHW_TREE_HEADER
#define FHW_TREE_HEADER
/*
 * tree.h 
 */

typedef struct{
    char* name;
    float profit;
    int   childNodeCount;
}t_data;

typedef struct t_node{
    t_data  data;
    struct t_node** next;
}t_tree;

#ifndef PROFIT_ANTEIL
#define PROFIT_ANTEIL 0.5 /*die Haelfte geht an die Leute ueber uns*/
#endif

/*
 * Erstellt einen leeren Baum und liefert diesen zurueck
 * Das Funktionsergebnis ist der NULL-Zeiger
 */
t_tree* tree_makeEmptyTree(void);

/*
 * Erstellt einen Baum und liefert diesen zurueck
 * Die next Referenzen stehen auf NULL (kein Speicher alloziert)
 * Liefert bei Fehler NULL zurueck (wenn name leer oder profit <0)
 */
t_tree* tree_makeTree(char* name, float profit);

/*
 * Zerstoert einen Baum und gibt saemtlichen Speicher des Baumes wieder frei
 * Gibt NULL bei Erfolg  oder bei Misserfolg alten tree zurueck
 * Gibt auch NULL bei Fehler zurück, wenn tree nicht exisitert
 */
t_tree* tree_destroyTree(t_tree* tree);

/*
 * Fuegt einen einzelnen Knoten vor dem Element 'before' in einen Baum ein.
 * Ein Name darf nur einmal vorkommen !
 * Bei Fehler wird NULL zureuckgeliefert sonst der resultierende Tree
 * (Fehler wenn kein tree, keine before, kein name oder profit<0 oder name 
 * schon vorhanden)
 */
t_tree* tree_insertNode(t_tree* tree, t_tree* before, char* name, float profit);

/*
 * Ersetzt eine Node durch eine neue mit den angegebenen Parametern.
 * Die Referenzen der alten Node werden uebernommen.
 * Ein Name darf nur einmal vorkommen !
 * Achtet darauf, den Speicher der ersetzten Node ordentlich freizugeben.
 * Bei Fehler wird NULL zureuckgeliefert. sonst der resultierende Tree
 * (Fehler wenn kein tree, keine node, kein name, profit<0, name schon 
 * vorhanden, node nicht im tree vorhanden)
 */
t_tree* tree_replaceNode(t_tree* tree, t_tree* node, char* name, float profit);

/*
 * Entfernt eine Node aus einem Baum. Alle Referenzen des zu entfernenden 
 * Baumes werden dem darueberliegendem Node angehaengt.
 * Liefert den resultierenden Baum oder NULL bei Fehler zurueck
 * (Fehler bei kein tree, kein node, oder node nicht im Baum)
 * Achtet darauf den Speicher der gelöschten Node ordentlich freizugeben.
 */
t_tree* tree_removeNode(t_tree* tree, t_tree* node);

/*
 * Hanegt einer Node in einem Baum einen Tree als zusaetzliche Referenz an.
 * Wenn diese Node vorher keine Referenz hat, hat sie danach eine, wenn sie
 * vorher eine hat, hat sie danach 2,usw.
 * Eine Node darf nur einmal vorkommen !
 * Gibt den resultierenden Baum oder bei Fehler NULL zurueck
 * (Fehler bei kein tree, keine node, kein insertTree, node nicht in tree)
 */
t_tree* tree_appendTree(t_tree* tree, t_tree* node, t_tree* insertTree);

/*
 * Ersetzt eine Node durch den angegebenen 'replaceTree'. Die Referenzen 
 * des alten gehen verloren !
 * Achtet darauf, den Speicher der verlorengehenden Referenzen ordentlich
 * zu befreien.
 * Eine Node darf nur einmal vorkommen !
 * Gibt den resultierenden Baum oder bei Fehler NULL zurück
 * (Fehler bei kein tree, kein node, kein replaceTree, wenn node nicht in tree)
 */
t_tree* tree_replaceTree(t_tree* tree, t_tree* node, t_tree* replaceTree);

/*
 * Entfernt eine Node mitsamt seinen Referenzen aus einem Baum.
 * Gibt den resultierenden Baum zurueck oder NULL bei Fehler
 * (Fehler wenn kein tree, keine node, node nicht in tree)
 * Achtet darauf, den Speicher der verlorengehenden Referenzen ordentlich
 * zu befreien. 
 */
t_tree* tree_removeTree(t_tree* tree, t_tree* node);

/*
 * Prueft, ob ein Knoten in einem Baum vorhanden ist
 * Liefert 1 falls vorhanden, sonst 0, bei Fehler -1
 * (Fehler wenn kein tree, keine node)
 */
int tree_inTree(t_tree* tree, t_tree* node);

/*
 * Prueft, ob ein Knoten mit dem Namen 'name' im Baum vorhanden ist und gibt 
 * ihn zurueck oder NULL bei Fehler
 * (Fehler wenn kein tree, kein name)
 */
t_tree* tree_findName(t_tree* tree, char* name);

/*
 * Erhoeht den Profit eines Nodes um den uebergebenen profit*(1-PROFIT_ANTEIL).
 * Simuliert also somit ein gemachtes Geschaeft eines Node, der PROFIT_ANTEIL
 * an die Nodes ueber ihm die ihn referenzieren abdruecken muss, d.h. er selbst
 * behaelt nur 1-PROFIT_ANTEIL des angegebenen Profits.
 * Aktualisiert also auch die Profits der Nodes darueber, je unter beruecksich-
 * tigung der PROFIT_ANTEIL Abgabe an Nodes darueber
 * Der oberste muss natuerlich nichts mehr abgeben, behaelt also dann 100%
 * Gibt den resuliterenden Baum zureuck oder NULL bei Fehler
 * (Fehler wenn kein tree, kein name, profit<0, name nicht in tree)
 */
t_tree* tree_updateProfit(t_tree* tree, char *name, float profit);

/*
 * Ermittelt den von einem Node erzielten Profit.
 * Gibt den Profit oder -1.0 bei Fehler zureuck
 * (Fehler wenn kein tree, kein name, name nicht in tree)
 */
float tree_getNodeProfit(t_tree* tree,char* name);


/*
 * Ermittelt den im gesamten Baum erzielten Profit.
 * Gibt den Profit oder -1.0 bei Fehler zureuck
 * (Fehler wenn kein tree)
 */
float tree_getTreeProfit(t_tree* tree);


#endif