/*
 * Schemat dziedziczenia klas
 *                  ZYWNOSC
 *               /           \
 *          OWOC               WARZYWO
 *        /      \            /      \
 *   JABLKO   POMARANCZA   MARCHEW   BURAK
 *
 */

#include <cstdlib>
#include <cstring>
#include <iostream>


using namespace std;

/*** ZYWNOSC ***/

/*
 * Klasa macierzysta dla pozostalych klas w programie
 * Przechowuje informacje o nazwie i wartosci odzywczej danego rodzaju zywnosci
 */
class Zywnosc {
protected:
    float wartosc_odzywcza;
    char * nazwa;
public:

    Zywnosc(const char * _nazwa, float w_odzywcza) : wartosc_odzywcza(w_odzywcza) {
        // przepisanie nazwy do zmiennej wlasnosci
        nazwa = new char[strlen(_nazwa)];
        strcpy(nazwa, _nazwa);
    }
    // akcesory wlasnosci

    float pokaz_w_odzywcza() {
        return wartosc_odzywcza;
    }

    char * pokaz_nazwe() {
        return nazwa;
    }
};

// Przeciazony operator wyprowadzenia na strumien wyjsciowy

ostream & operator <<(ostream & strumien, Zywnosc z) {
    strumien << z.pokaz_nazwe()
            << ", wartosc odzywcza: " << z.pokaz_w_odzywcza() << "kcal";
}

/*** WARZYWO ***/

/*
 * Klasa modelujaca warzywa. Rozszerza Zywnosc o informacje czy
 * warzywo jest swieze
 */
class Warzywo : public Zywnosc {
protected:
    bool swieze;
public:

    Warzywo(const char * _nazwa, float w_odzywcza, bool _swieze) :
    Zywnosc(_nazwa, w_odzywcza), swieze(_swieze) {
    }

    bool czy_swieze() {
        return swieze;
    }
};

ostream & operator <<(ostream & strumien, Warzywo w) {
    strumien << static_cast<Zywnosc> (w) << (w.czy_swieze() ? ", swieze" : ", mrozone");
}

/*** MARCHEW ***/

/*
 * Klasa marchwi, dziedziczy po Warzywie. Rozszerza je o dlugosc korzenia
 * i stosowny akcesor
 */
class Marchew : public Warzywo {
protected:
    float dlugosc_korzenia;
public:

    Marchew(float dl_korzenia, float w_odzywcza, bool _swieze) :
    Warzywo("Marchew", w_odzywcza, _swieze), dlugosc_korzenia(dl_korzenia) {
    }

    float daj_dl_korzenia() {
        return dlugosc_korzenia;
    }
};

ostream & operator <<(ostream & strumien, Marchew m) {
    strumien << static_cast<Warzywo> (m) << endl << "Korzen dlugosci: " << m.daj_dl_korzenia();
}


/*** BURAK ***/

/*
 * Dziedziczy po warzywie, rozszerza je o informacje czy jest cukrowy.
 * Zapewnia odpowiedni akcesor.
 */
class Burak : public Warzywo {
protected:
    bool cukrowy;
public:

    Burak(float _cukrowy, float w_odzywcza, bool _swieze) :
    Warzywo("Burak", w_odzywcza, _swieze), cukrowy(_cukrowy) {
    }

    bool czy_cukrowy() {
        return cukrowy;
    }
};

ostream & operator <<(ostream & strumien, Burak b) {
    strumien << static_cast<Warzywo> (b) << endl << (b.czy_cukrowy() ? "Nie jest cukrowy" : "Jest cukrowy");
}

/*** OWOC ***/

/*
 * Rozszerza Zywnosc o informacje czy jest cytrusowy i jaka ma witamine.
 * Zapewnia odpowiednie akcesory
 */
class Owoc : public Zywnosc {
protected:
    bool cytrusowy;
    char witamina;
public:

    Owoc(const char * _nazwa, float w_odzywcza, bool _cytrus, char _witamina) :
    Zywnosc(_nazwa, w_odzywcza), cytrusowy(_cytrus), witamina(_witamina) {
    }

    bool czy_jest_cytrusem() {
        return cytrusowy;
    }

    char pokaz_witamine() {
        return witamina;
    }
};

ostream & operator <<(ostream & strumien, Owoc o) {
    strumien << static_cast<Zywnosc> (o) << ", owoc "
            << (o.czy_jest_cytrusem() ? "cytrusowy" : "niecytrusowy")
            << endl << "Zawiera witamine " << o.pokaz_witamine();
}

/*** JABLKO ***/

/*
 * Modeluje klase jablka rozszerzajac Owoc o wlasnosc odmiana.
 */
class Jablko : public Owoc {
private:
    char * odmiana;
public:

    Jablko(const char * _odmiana, float w_odzywcza) :
    Owoc("Jablko", w_odzywcza, false, 'D') {
        odmiana = new char[strlen(_odmiana)];
        strcpy(odmiana, _odmiana);
    }

    char * pokaz_odmiane() {
        return odmiana;
    }
};

ostream & operator <<(ostream & strumien, Jablko j) {
    strumien << static_cast<Owoc> (j)
            << endl << "Odmiana: " << j.pokaz_odmiane();
}

/*** POMARANCZA ***/

/*
 * Dziedziczy po Owoc, rozszerza go o informacje czy to odmiana bezpestkowa
 */
class Pomarancza : public Owoc {
private:
    bool bezpestkowa;
public:

    Pomarancza(bool _bezpestkowa, float w_odzywcza) :
    Owoc("Pomarancza", w_odzywcza, true, 'C'),
    bezpestkowa(_bezpestkowa) {
    }

    bool czy_bezpestkowa() {
        return bezpestkowa;
    }
};

ostream & operator <<(ostream & strumien, Pomarancza p) {
    strumien << static_cast<Owoc> (p)
            << endl << "Odmiana " << (p.czy_bezpestkowa() ? "bezpestkowa" : "z pestkami");
}

int main(int argc, char** argv) {
    Jablko j("reneta królewska", 8);
    Pomarancza p(true, 10);
    Marchew m(4, 5, false);
    Burak b(false, 5, false);
    cout << "WPROWADZONA ZYWNOSC:"<< endl
            << j << endl << endl
            << p << endl << endl
            << m << endl << endl
            << b << endl;
    return (EXIT_SUCCESS);
}