//  main.cpp

#include 
#include "albero.h"
#include "alberobin.h"
using namespace std;

int main(int argc, const char * argv[]) {
    Binalbero albero;
    int i;
    cout << "i vale: " << i << endl;
    albero.creaBinalbero();
    tipoelem dato = 10;
    albero.insRadice();
    albero.scriviNodo(dato, albero.radice());
    cout << "radice albero: " << albero.leggiNodo(albero.radice()) << endl;
    return 0;
}


//  albero.h

#ifndef albero_albero_h
#define albero_albero_h

//#include "lista.h"
#include "nodo.h"
class Albero {
public:
    int numeroNodi();
    int grado(Nodo);
    Nodo padre(Nodo);
    //Nodo figli(Nodo);
    Nodo figlioSinistro(Nodo);
    Nodo figlioDestro(Nodo);
    Nodo aggiungiNodo(Nodo); //inserisce nuovo nodo che restituisce in output
    void aggiungiSottoalbero(Albero, Nodo);
    Albero rimuoviSottoalbero(Nodo);

private:
    Nodo radice;
};

#endif


//  nodo.h

#ifndef albero_nodo_h
#define albero_nodo_h

typedef int tipoelem; //TODO: modificare con tipi più complessi
typedef bool boolean;

class Nodo {
public:
    ~Nodo(){
        padre = 0;
        delete figlioSinistro;
        delete figlioDestro;
    }
    tipoelem dato;
    Nodo * padre;
    Nodo * figlioSinistro; //primoFiglio in albero n-ario
    Nodo * figlioDestro;   // succFratello in albero n-ario
};

#endif


// alberobin.h
#ifndef albero_alberobin_h
#define albero_alberobin_h

#include 
#include "nodo.h"


class Binalbero{
public:
    Binalbero();
    ~Binalbero();
    void creaBinalbero();
    boolean binalberoVuoto();
    Nodo * radice();
    Nodo * padre(Nodo);
    Nodo * figlioSinistro(Nodo);
    Nodo * figlioDestro(Nodo);
    boolean sinistroVuoto(Nodo);
    boolean destroVuoto(Nodo);
    tipoelem leggiNodo(Nodo *);
    void scriviNodo(tipoelem, Nodo *);
    void insRadice();
    void insFiglioSinistro(Nodo);
    void insFiglioDestro(Nodo);
    void cancSottoBinalbero(Nodo *);
private:
    Nodo * albero;
};


//  alberobin.cpp

#include 
#include "alberobin.h"

Binalbero::Binalbero(){
    creaBinalbero();
}
Binalbero::~Binalbero(){};

void Binalbero::creaBinalbero(){
    albero = NULL;
}

boolean Binalbero::binalberoVuoto(){
    return (albero == NULL);
}

Nodo * Binalbero::radice(){
    if (!binalberoVuoto())
        return albero;
    else
        return NULL;
}

Nodo * Binalbero::padre(Nodo u){
    if(!binalberoVuoto() && (&u != albero))
        return u.padre;
    else return NULL;
}

Nodo * Binalbero::figlioSinistro(Nodo u){
    if(!binalberoVuoto() && (!sinistroVuoto(u)))
       return u.figlioSinistro;
    else return NULL;
}
Nodo * Binalbero::figlioDestro(Nodo u){
    if(!binalberoVuoto() && (!destroVuoto(u)))
        return u.figlioDestro;
    else return NULL;
}

boolean Binalbero::sinistroVuoto(Nodo u){
    return (u.figlioSinistro == NULL);
}
boolean Binalbero::destroVuoto(Nodo u){
    return (u.figlioDestro == NULL);
}

tipoelem Binalbero::leggiNodo(Nodo * u){
    return u->dato;
}

void Binalbero::scriviNodo(tipoelem nuovoDato, Nodo * u){
    u->dato = nuovoDato;
}

void Binalbero::insRadice(){
    if (binalberoVuoto()) {
        albero = new Nodo();
    }
}

void Binalbero::insFiglioSinistro(Nodo u){
    if (!binalberoVuoto() && sinistroVuoto(u)){
        Nodo * temp = new Nodo();
        u.figlioSinistro = temp;
        temp->padre = &u;
    }
}
void Binalbero::insFiglioDestro(Nodo u){
    if (!binalberoVuoto() && destroVuoto(u)){
        Nodo * temp = new Nodo();
        u.figlioDestro = temp;
        temp->padre = &u;
    }
}

void Binalbero::cancSottoBinalbero(Nodo * u){
    if (!binalberoVuoto()){
        if (u == albero)
            delete albero;
        else{
            Nodo * padre;
            padre = u->padre;
            if (u == padre->figlioSinistro) {
                padre->figlioSinistro = NULL;
            } else
                padre->figlioDestro = NULL;
            delete u;
        }
    }
}