#include "R_B_Strom.h"
#include <assert.h>

R_B_Strom::R_B_Strom()
{
    koren_ = NULL;
}

R_B_Strom::R_B_Strom(Zbozi * zbozi)
{
    Uzel * temp = new Uzel(zbozi);
    koren_ = temp;
}

R_B_Strom::~R_B_Strom()
{

}

Uzel * R_B_Strom::prarodic(Uzel * uzel)
{
    assert(uzel != NULL);
    assert(uzel->rodic_ != NULL);
    assert(uzel->rodic_->rodic_ != NULL);
    return uzel->rodic_->rodic_;
}

Uzel * R_B_Strom::sourozenec(Uzel * uzel)
{
    assert(uzel != NULL);
    assert(uzel->rodic_ != NULL);
    if (uzel == uzel->rodic_->levyPotomek_)
        return uzel->rodic_->pravyPotomek_;
    return uzel->rodic_->levyPotomek_;
}

Uzel * R_B_Strom::stryc(Uzel * uzel)
{
    assert(uzel != NULL);
    assert(uzel->rodic_ != NULL);
    assert(uzel->rodic_->rodic_ != NULL);
    return sourozenec(uzel->rodic_);
}

Barva R_B_Strom::barva_uzlu(Uzel * uzel)
{
    return uzel == NULL ? CERNA : uzel->barva_;
}

void R_B_Strom::nahrad_uzel(Uzel * puvodni, Uzel * novy)
{
    if (puvodni->rodic_ == NULL)
    {
        koren_ = novy;
    }
    else
    {
        if (puvodni == puvodni->rodic_->levyPotomek_)
            puvodni->rodic_->levyPotomek_ = novy;
        else
            puvodni->rodic_->pravyPotomek_ = novy;
    }
    if (novy != NULL)
    {
        novy->rodic_ = puvodni->rodic_;
    }
}

void R_B_Strom::leva_rotace(Uzel * uzel)
{
    Uzel * R = uzel->pravyPotomek_;
    nahrad_uzel(uzel, R);
    uzel->pravyPotomek_ = R->levyPotomek_;
    if (R->levyPotomek_ != NULL)
    {
        R->levyPotomek_->rodic_ = uzel;
    }
    R->levyPotomek_ = uzel;
    uzel->rodic_ = R;
}

void R_B_Strom::prava_rotace(Uzel * uzel)
{
    Uzel * L = uzel->levyPotomek_;
    nahrad_uzel(uzel, L);
    uzel->levyPotomek_ = L->pravyPotomek_;
    if (L->pravyPotomek_ != NULL)
    {
        L->pravyPotomek_->rodic_ = uzel;
    }
    L->pravyPotomek_ = uzel;
    uzel->rodic_ = L;
}

#pragma region Vkladani_do_stromu
void R_B_Strom::vloz_prvek(Zbozi * zbozi)
{
    Uzel * prvek = new Uzel(zbozi);

    if (koren_ == NULL)
    {
        koren_ = prvek;
    }
    else
    {
        Uzel * temp = koren_;
        while (true)
        {
            if (temp->identifikacniCislo_ == prvek->identifikacniCislo_)
            {
                temp->cenaZaJeden_ = prvek->cenaZaJeden_;
                temp->pocetKusu_ += prvek->pocetKusu_;
                temp->cenaCelkem_ = temp->get_cena_celkem();
                return;
            }
            else if (temp->identifikacniCislo_ < prvek->identifikacniCislo_)
            {
                if (temp->levyPotomek_ == NULL)
                {
                    temp->levyPotomek_ = prvek;
                    break;
                }
                else
                    temp = temp->levyPotomek_;
            }
            else
            {
                if (temp->pravyPotomek_ == NULL)
                {
                    temp->pravyPotomek_ = prvek;
                    break;
                }
                else
                    temp = temp->pravyPotomek_;
            }
        }
        prvek->rodic_ = temp;
    }
    vloz_prvek_pripad1(prvek);
    over_vlastnosti();
}
void R_B_Strom::vloz_prvek_pripad1(Uzel * vkladany)
{

}
void R_B_Strom::vloz_prvek_pripad2(Uzel * vkladany)
{

}
void R_B_Strom::vloz_prvek_pripad3(Uzel * vkladany)
{

}
void R_B_Strom::vloz_prvek_pripad4(Uzel * vkladany)
{

}
void R_B_Strom::vloz_prvek_pripad5(Uzel * vkladany)
{

}
#pragma endregion NENÍ HOTOVÉ!

#pragma region Overeni_vlastnosti_stromu
void R_B_Strom::over_vlastnosti()
{
    over_vlastnost_1();
    over_vlastnost_2();
    over_vlastnost_3();
    over_vlastnost_4();
}

void R_B_Strom::over_vlastnost_1(Uzel * uzel)
{
    assert(barva_uzlu(uzel) == CERVENA || barva_uzlu(uzel) == CERNA);
    if (uzel == NULL)
        return;
    over_vlastnost_1(uzel->levyPotomek_);
    over_vlastnost_1(uzel->pravyPotomek_);
}

void R_B_Strom::over_vlastnost_2()
{
    assert(barva_uzlu(koren_) == CERNA);
}

void R_B_Strom::over_vlastnost_3(Uzel * uzel)
{
    if (barva_uzlu(uzel) == CERVENA)
    {
        assert(barva_uzlu(uzel->levyPotomek_) == CERNA);
        assert(barva_uzlu(uzel->pravyPotomek_) == CERNA);
        assert(barva_uzlu(uzel->rodic_) == CERNA);
    }
    if (uzel == NULL)
        return;
    over_vlastnost_3(uzel->levyPotomek_);
    over_vlastnost_3(uzel->pravyPotomek_);
}

void R_B_Strom::over_vlastnost_4()
{
    int cesta = -1;
    over_vlastnost_4_pomocnik(koren_, 0, &cesta);
}

void R_B_Strom::over_vlastnost_4_pomocnik(Uzel * uzel, int pocet, int * cerna_cesta)
{
    if (barva_uzlu(uzel) == CERNA)
    {
        pocet++;
    }
    if (uzel == NULL)
    {
        if (*cerna_cesta == -1)
        {
            *cerna_cesta = pocet;
        }
        else
        {
            assert(pocet == *cerna_cesta);
        }
        return;
    }
    over_vlastnost_4_pomocnik(uzel->levyPotomek_, pocet, cerna_cesta);
    over_vlastnost_4_pomocnik(uzel->pravyPotomek_, pocet, cerna_cesta);
}
#pragma endregion