Zadatak :: KataloskaProdaja :: v1.0

#include<iostream>
#include<exception>

using namespace std;



class NedozvoljenaOperacija :public exception
{
    char* poruka;
    int linijaKoda;
public:
    //Konstruktor sa dva parametra (poruka i linija koda u kojoj je greška nastala)
    NedozvoljenaOperacija(char* poruka="<poruka>", int lin=-1)
    {
        int size = strlen(poruka) + 1;
        this->poruka = new char[size];
        strcpy_s(this->poruka, size, poruka);

        linijaKoda = lin;
    }

    //Funkcija za ispis informacija o nastaloj grešci
    void ErrorInfo()
    {
        cout << "GRESKA >>> " << poruka << " -- linija >>> " << linijaKoda << endl << endl;
    }
};

//KATALOŠKA PRODAJA
class Proizvod
{
    char _sifra[10];
    char* _naziv;
    double _cijena;
    double _popust;
public:
    //Potrebne konstruktor i destruktor funkcije
    //U slučaju nedozvoljenih vrijednosti za cijenu i popust baciti izuzetak
    Proizvod(char* sifra = "<sif>", char* naziv = "<naz>", double cijena=-1, double popust=-1)
    {
        //Dopuniti dato rješenje
        strncpy_s(_sifra, sifra, _TRUNCATE);

        int vel = strlen(naziv) + 1;
        _naziv = new char[vel];
        strcpy_s(_naziv, vel, naziv);

        _cijena = cijena;
        _popust = popust;
    }

    virtual ~Proizvod()
    {
        delete[] _naziv; _naziv = NULL;
    }

    Proizvod(const Proizvod& orig)
    {
        strncpy_s(_sifra, orig._sifra, _TRUNCATE);

        int vel = strlen(orig._naziv) + 1;
        _naziv = new char[vel];
        strcpy_s(_naziv, vel, orig._naziv);

        _cijena = orig._cijena;
        _popust = orig._popust;
    }


    Proizvod& operator=(const Proizvod& orig)
    {
        if (this == &orig)
            return *this;

        strncpy_s(_sifra, orig._sifra, _TRUNCATE);

        delete[] _naziv;

        int vel = strlen(orig._naziv) + 1;
        _naziv = new char[vel];
        strcpy_s(_naziv, vel, orig._naziv);

        _cijena = orig._cijena;
        _popust = orig._popust;

        return *this;
    }


    //Funkciju Info
    virtual void Info()
    {
        cout << "Sifra: " << _sifra << endl;
        cout << "Naziv: \t" << _naziv << endl;
        cout << "Cijena: " << _cijena << endl;
        cout << "Popust: " << _popust << endl;
    }

    char* GetSifra()const
    {
        int size = strlen(_sifra) + 1;
        char* sifra = new char[size];
        strcpy_s(sifra, size, _sifra);

        return sifra;
    }

    double GetCijena()const { return _cijena; }
    double GetPopust()const { return _popust; }

    friend ostream& operator<<(ostream&, const Proizvod&);
};

ostream& operator<<(ostream& COUT, const Proizvod& obj)
{
    cout << "Sifraa: " << obj._sifra << endl;
    cout << "Nazivv: \t" << obj._naziv << endl;
    cout << "Cijenaa: " << obj._cijena << endl;
    cout << "Popustt: " << obj._popust << endl;

    return COUT;
}

//Implementirati nasljeđivanje
class Odjeca :public Proizvod
{
    char* _velicine;        // 34, 36, 38 ili XS, S, M...
    char* _boje;            // crna, bijela, siva
public:
    //Potrebne konstruktor i destruktor funkcije

    Odjeca(char* sifra = "<sif>", char* naziv = "<naz>", double cijena = -1,
        double popust = -1, char* velicine = "<vel>", char* boje = "<boj>") :Proizvod(sifra, naziv, cijena, popust)
    {
        int vel = strlen(velicine) + 1;
        _velicine = new char[vel];
        strcpy_s(_velicine, vel, velicine);

        vel = strlen(boje) + 1;
        _boje = new char[vel];
        strcpy_s(_boje, vel, boje);
    }

    ~Odjeca() { delete[] _velicine, _boje; _velicine = _boje = NULL; }

    Odjeca(const Odjeca& orig) :Proizvod(orig)
    {
        int vel = strlen(orig._velicine) + 1;
        _velicine = new char[vel];
        strcpy_s(_velicine, vel, orig._velicine);

        vel = strlen(orig._boje) + 1;
        _boje = new char[vel];
        strcpy_s(_boje, vel, orig._boje);
    }

    //Funkciju Info
    void Info()
    {
        Proizvod::Info();
        cout << "Velicine: " << _velicine << endl;
        cout << "Boje: " << _boje << endl;
    }

    friend ostream& operator<<(ostream&, Odjeca&);
};

ostream& operator<<(ostream& COUT, Odjeca& obj)
{
    obj.Info();
    cout << "Velicine: " << obj._velicine << endl;
    cout << "Boje: " << obj._boje << endl;

    return COUT;
}

class Katalog
{
    char* _naslov;
    char* _vrijediDo;   //Datum
    Proizvod* _proizvodi[100];
    int _trenutnoProizvoda;
public:
    //Potrebne konstruktor i destruktor funkcije
    Katalog(char* naslov="<nas>", char* vrijediDo="<vri>")
    {
        int size = strlen(naslov) + 1;
        _naslov = new char[size];
        strcpy_s(_naslov, size, naslov);

        size = strlen(vrijediDo) + 1;
        _vrijediDo = new char[size];
        strcpy_s(_vrijediDo, size, vrijediDo);

        for (int i = 0; i < 100; i++)
            _proizvodi[i] = NULL;

        _trenutnoProizvoda = 0;
    }
    ~Katalog()
    {
        delete[] _naslov, _vrijediDo;
        for (int i = 0; _proizvodi[i] != NULL; i++){
            delete _proizvodi[i];
            _proizvodi[i] = nullptr;
        }
    }

    // Kreirati funkciju za dodavanje proizvoda u katalog i pri tome provjeriti da li se radi
    //      o objektu izvedene ili osnovne klase (rezervisati memoriju za odgovarajući tip).
    // U slučaju prekoračenja baciti izuzetak
    // Onemogućiti dodavanje identičnih proizvoda u jedan katalog
    // Proizvode razlikovati po šifri
    bool DodajUKatalog(Proizvod& obj)
    {
        if (_trenutnoProizvoda == 100)
            throw NedozvoljenaOperacija("Mjesta za proizvode su popunjena.", __LINE__);

        //bool isJedinstven = true;

        for (int i = 0; i < _trenutnoProizvoda; i++)
            if (strcmp(_proizvodi[i]->GetSifra(), obj.GetSifra()) == 0)
                return false;


        Odjeca* pok = NULL;
        pok = dynamic_cast<Odjeca*>(&obj);

        if (pok != NULL)
            _proizvodi[_trenutnoProizvoda++] = new Odjeca(*pok);
        else
            _proizvodi[_trenutnoProizvoda++] = new Proizvod(obj);


        return true;
    }

    //bool UporediSifre(char* s1, char* s2)
    //{
    //  return (strcmp(s1, s2) == 0);
    //}

    // Funkciju za uklanjanje proizvoda iz kataloga na osnovu sifre
    // Ukoliko se ne pronađe traženi proizvod baciti izuzetak
    bool UkloniIzKataloga(char* sifra)
    {
        for (int i = 0; i < _trenutnoProizvoda; i++)
        {
            if (strcmp(_proizvodi[i]->GetSifra(), sifra) == 0)
            {
                for (int j = i; j < _trenutnoProizvoda - 1; j++)
                    _proizvodi[j] = _proizvodi[j + 1];

                _trenutnoProizvoda--;
                _proizvodi[_trenutnoProizvoda] = new Proizvod;

                return true;
            }
        }

        return false;
    }


    //Preklopiti operator za ispis kataloške ponude
    friend ostream& operator<<(ostream&, const Katalog&);
};

ostream& operator<<(ostream& COUT, const Katalog& obj)
{
    COUT << "\tKATALOG " << obj._naslov << " <vrijedi do: " << obj._vrijediDo << ">" << endl;
    COUT << "=========================================\n" << endl;

    for (int i = 0; i < obj._trenutnoProizvoda; i++)
    {
        COUT << i << ". ";
        obj._proizvodi[i]->Info();
        COUT << "-------------------------------------" << endl;
    }

    return COUT;
}


//Sve funkcije implementirati van klase
//Baciti izuzetak po potrebi
template<class T>
class Stack
{
    int _size;
    int _top;
    T* _elements;
public:
    //Konstruktor postavlja početne vrijednosti i alocira dinamički niz elemenata tipa T
    Stack(int vel);
    ~Stack();

    //Provjeravaju stanje na stack-u, prazan ili popunjen
    //Iskoristiti prilikom implementacije funkcija Push i Pop
    bool IsEmpty()const;
    bool IsFull()const;

    //Dodaje novi element na stack
    void Push(const T& element);

    //Uzima posljednji element sa stack-a
    T Pop();


    //Vraća broj elemenata na stack-u
    int GetSize()const;

    //Vraća element sa stack-a na poziciji indeks (pozicije počinju od 1)
    T operator[](int indeks)const;

    //Operator za ispis elemenata na stack-u
    void Info();

    friend ostream& operator<< <>(ostream& COUT, Stack<T>& obj)
    {
        Odjeca* pok = NULL;

        for (int i = 0; i < obj.GetSize(); i++)
        {
            //cout << i << ". " << &obj._elements[i] << endl;

            pok = dynamic_cast<Odjeca*>( &(obj._elements[i]) );

            if (pok != NULL){
                cout << "Odjeca called" << endl;
                pok->Info();
            }
            else{

                COUT << obj._elements[i] << endl;
            }
        }
        return COUT;
    }


    friend ostream& operator<< <>(ostream& COUT, Stack<Odjeca>& obj)
    {
        COUT << "Test odjeca" << endl;

        return COUT;
    }

    T GetElements(){ return _elements[2]; }

};

template<class T>
Stack<T>::Stack(int vel = 20)
{
    _size = vel;
    _top = 0;
    _elements = new T[_size];
}

template<class T>
Stack<T>::~Stack(){ delete _elements; _elements = nullptr; }

//template<class T>
//Stack<T>::Stack(const Stack<T>& orig)
//{
//  _size = orig._size;
//  _top = orig._top;
//  _elements = new T[_size];
//  for (int i = 0; i < _size; i++)
//      _elements[i] = orig._elements[i];
//}

/** ==================================================== **/

template<class T>
void Stack<T>::Push(const T& e)
{
    if (IsFull())
        throw NedozvoljenaOperacija("Stack je pun, nije moguce dodati novi element", __LINE__);

    _elements[_top++] = e;
}

template<class T>
T Stack<T>::Pop()
{
    if (IsEmpty())
        throw NedozvoljenaOperacija("Stack je prazan, nije moguce ukloniti element.", __LINE__);

    return _elements[_top--];
}

/** ==================================================== **/

template<class T>
T Stack<T>::operator[](int indeks)const
{
    if (indeks < 0 || indeks > _size || indeks > _top)
        throw NedozvoljenaOperacija("Nije moguce dohvatanje s te pozicije!", __LINE__);

    return _elements[indeks];
}

/** ==================================================== **/

template<class T>
bool Stack<T>::IsEmpty()const { return _top == 0; }

template<class T>
bool Stack<T>::IsFull()const { return _top == _size; }

template<class T>
int Stack<T>::GetSize()const { return _top; }


template<class T>
void Stack<T>::Info()
{
    for (int i = 0; i < _top; i++)
        cout << _elements[i] << endl;
}

/** ==================== S T A C K ================== **/


class Uposlenik
{
    char* _imePrezime;
    char* _radnoMjesto;
public:
    //Potrebne konstruktor i destruktor funkcije
    Uposlenik(char* imePrezime="<ime prezime>", char* radnoMjesto="<radno mjesto>")
    {
        int vel = strlen(imePrezime) + 1;
        _imePrezime = new char[vel];
        strcpy_s(_imePrezime, vel, imePrezime);

        vel = strlen(radnoMjesto) + 1;
        _radnoMjesto = new char[vel];
        strcpy_s(_radnoMjesto, vel, radnoMjesto);
    }

    ~Uposlenik() { delete[] _imePrezime, _radnoMjesto; _imePrezime = _radnoMjesto = NULL; }

    Uposlenik(const Uposlenik& orig)
    {
        int vel = strlen(orig._imePrezime) + 1;
        _imePrezime = new char[vel];
        strcpy_s(_imePrezime, vel, orig._imePrezime);

        vel = strlen(orig._radnoMjesto) + 1;
        _radnoMjesto = new char[vel];
        strcpy_s(_radnoMjesto, vel, orig._radnoMjesto);
    }

    char* GetRadnoMjesto()const { return _radnoMjesto; }

};

class Narudzba
{
    int _brojNarudzbe;
    char* _datumIsporuke;
    Uposlenik* _uposlenik;
    Stack<Proizvod>* _proizvodi;
    int _brojProizvoda;
public:
    //Potrebne konstruktor i destruktor funkcije
    //Narudžbu može izdati samo uposlenik sa radnim mjestom "Prodavač".
    //  U suprotnom baciti izuzetak.
    Narudzba(int brNarudz = -1, char* datumIsporuke = "<datum isporuke>", Uposlenik uposlenik=Uposlenik())
    {
        if (!strcmp(uposlenik.GetRadnoMjesto(), "Prodavac") == 0)
            throw NedozvoljenaOperacija("Narudzba ne moze biti kreirana!", __LINE__);

        _brojNarudzbe = brNarudz;

        int size = strlen(datumIsporuke) + 1;
        _datumIsporuke = new char[size];
        strcpy_s(_datumIsporuke, size, datumIsporuke);

        _uposlenik = new Uposlenik(uposlenik);

        _proizvodi = new Stack<Proizvod>(100);

        _brojProizvoda = 0;
    }

    Stack<Proizvod>* GetProizvodi(){ return _proizvodi; }

    // Kreirati funkciju za dodavanje proizvoda narudžbe
    //  Ukoliko proizvod više nije dostupan baciti izuzetak.
    //  Dozvoliti dodavanje istog proizvoda više puta (po potrebi dopuniti atribute odgovarajuće klase)
    void NaruciProizvod(const Proizvod& obj)
    {
        _proizvodi->Push(obj);
        _brojProizvoda++;
    }

    // Funkciju za uklanjanje proizvoda iz narudžbe


    // Dodati funkciju za proračun ukupne cijene narudžbe
    //  Voditi računa o mogućnosti dodavanja više istih proizvoda
    //  Uračunati popust u slučaju da je definisan
    double Obracunaj()
    {
        double cijena = 0, popust = 0, ukupnoSPopustom = 0;

        for (int i = 0; i < _brojProizvoda; i++)
        {
            cijena = (*_proizvodi)[i].GetCijena();
            popust = (*_proizvodi)[i].GetPopust();
            ukupnoSPopustom += cijena - (cijena * popust);
        }

        return ukupnoSPopustom;
    }

    // Preklopiti operator za ispis podataka o narudžbi zajedno sa cijenom
    friend ostream& operator<<(ostream&, Narudzba&);
};

ostream& operator<<(ostream& COUT, Narudzba& obj)
{
    COUT << "Br. narudzbe: " << obj._brojNarudzbe << endl;
    COUT << "Narudzbu izdao: " << obj._uposlenik->GetRadnoMjesto() << endl;
    COUT << "Isporuciti na dan: " << obj._datumIsporuke << endl;
    COUT << "Ukupno proizvoda: " << obj._brojProizvoda << endl << endl;
    COUT << "===== PROIZVODI U NARUDZBI =====" << endl;

    //obj._proizvodi->Info();
    COUT << *obj._proizvodi;

    COUT << "UKUPNO S OBRACUNATIM POPUSTOM: " << obj.Obracunaj() << endl;

    return COUT;
}

void main()
{
    try{


        Katalog kat("\"LJETO 2016\"", "30.04.2016");

        Proizvod p1("gz214", "Stolna lampa", 49, 0.03);
        Proizvod p2("rd874", "Stolica kuhinjska", 74, 0.04);
        Odjeca o1("od765", "Dukserica", 45, 0.15, "XS, S, M, XL", "crna, crvena, bijela");
        Proizvod p3("iu852", "Vjesalica zidna", 8, 0.12);
        Odjeca o2("od112", "Majica", 35, 0.05, "M, S, X, XL, XXL", "crna, plava, zelena, bijela");

        // Dodati minimalno 5 proizvoda u katalog
        kat.DodajUKatalog(p1);
        kat.DodajUKatalog(p2);
        kat.DodajUKatalog(p3);
        //kat.DodajUKatalog(o2);
        //kat.DodajUKatalog(o1);

        kat.UkloniIzKataloga("rd874");

        // Ispisati ponudu kupcu
        cout << kat << endl;



        Uposlenik u("Denis Kajdic", "Prodavac");

        Narudzba narudzba(1, "11.3.2016", u);

        narudzba.NaruciProizvod(p1);
        narudzba.NaruciProizvod(p3);
        narudzba.NaruciProizvod(o2);

        Stack<Proizvod>* foo = narudzba.GetProizvodi();

        cout << "===========================" << endl;
        cout << foo->GetElements() << endl;
        cout << "===========================" << endl;

        cout << narudzba << endl;

        cout << "\n";

    }
    catch(NedozvoljenaOperacija& err){
        err.ErrorInfo();
    }

    cout << endl;



    // Omogućiti kreiranje narudžbe na osnovu izbora kupca
}



/*
Stack<double> stek(4);
stek.Push(3.14);
stek.Push(287.00);
stek.Push(54.08);
stek.Push(22.74);
stek.Push(11.02);
stek.Info();
stek.Push(8.89);
stek.Info();


*/