PR2 - W9 - Zadatak

#include<iostream>
using namespace std;

char * crtice = "\n===================================================\n";

class NedozvoljenaOperacija : public exception{
    int linijaKoda;
public:

    //Konstruktor sa dva parametra (poruka i linija koda u kojoj je greška nastala)
    NedozvoljenaOperacija(char * poruka, int lin) : exception(poruka)
    {
        linijaKoda = lin;
    }

    //Funkcija za ispis informacija o nastaloj grešci
    void ErrorInfo()
    {
        cout << "Greska: " << what() << " u liniji " << linijaKoda << "." << endl;
    }
};

//KATALOŠKA PRODAJA
class Proizvod
{
    char _sifra[10];
    char* _naziv;
    double _cijena;
    double _popust;
    int _stanje;
public:
    //Potrebne konstruktor i destruktor funkcije
    //U slučaju nedozvoljenih vrijednosti za cijenu i popust baciti izuzetak
    Proizvod(char* sifra = "---", char* naziv = "---", double cijena = 0, double popust = 0, int stanje = 0)
    {
        //Dopuniti dato rješenje
        if(cijena < 0)
            throw NedozvoljenaOperacija("Cijena je negativna", __LINE__);
        if(popust < 0 || popust > 100)
            throw NedozvoljenaOperacija("Popust nije validan (raspon 0 - 100)", __LINE__);

        strncpy_s(_sifra, sifra, 10);

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

        _cijena = cijena;
        _popust = popust;

        _stanje = stanje;
    }
    Proizvod (const Proizvod & original)
    {
        strncpy_s(_sifra, original._sifra, 10);

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

        _cijena = original._cijena;
        _popust = original._popust;

        _stanje = original._stanje;

    }

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

    char *  getSifra() { return _sifra; }
    int getStanje() { return _stanje; }
    double getCijena() { return _cijena; }
    double getPopust() { return _popust; }

    Proizvod & operator -= (int kolicina)
    {
        _stanje -= kolicina;
        return *this;
    }

    Proizvod & operator =(const Proizvod & obj)
    {
        if(this != &obj)
        {
            strncpy_s(_sifra, obj._sifra, 10);

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

            _cijena = obj._cijena;
            _popust = obj._popust;
        }
        return *this;
    }
    bool operator==(Proizvod & p)
    {
        if(strcmp(_sifra, p._sifra) == 0)
            return true;
        return false;
    }
    //Funkciju Info
    virtual void Info()
    {
        cout << "Sifra: " << _sifra << endl;
        cout << "Naziv: " << _naziv << endl;
        cout << "Cijena: " << _cijena << " KM" << endl;
        cout << "Popust: " << _popust << "%" << endl;
    }
};

//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 = "---", char* naziv = "---", double cijena = 0, double popust = 0, int stanje = 0, char * velicine = "---", char * boje = "---")
        : Proizvod(sifra, naziv, cijena, popust, stanje)
    {
        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(const Odjeca & original) : Proizvod(original)
    {
        int vel = strlen(original._velicine) + 1;
        _velicine = new char[vel];
        strcpy_s(_velicine, vel, original._velicine);

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

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

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


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

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

        _trenutnoProizvoda = 0;
    }

    ~Katalog()
    {
        delete[] _naslov;
        _naslov = NULL;
        delete[] _vrijediDo;
        _vrijediDo = NULL;
        for(int i = 0; i < _trenutnoProizvoda; i++) {
            delete _proizvodi[i];
            _proizvodi[i] = NULL;
        }
    }
    //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

    void DodajProizvod(Proizvod & p)
    {
        if(_trenutnoProizvoda == 100)
            throw NedozvoljenaOperacija("Niz je popunjen", __LINE__);
        for(int i = 0; i < _trenutnoProizvoda; i++)
            if(p == *_proizvodi[i])
                throw NedozvoljenaOperacija("Proizvod vec postoji", __LINE__);
        Odjeca * pok;
        pok = dynamic_cast<Odjeca*>(&p);
        if(pok != NULL)
            _proizvodi[_trenutnoProizvoda++] = new Odjeca(*pok);
        else
            _proizvodi[_trenutnoProizvoda++] = new Proizvod(p);
    }

    //Funkciju za uklanjanje proizvoda iz kataloga na osnovu sifre
    //Ukoliko se ne pronađe traženi proizvod baciti izuzetak
    void UkloniProizvod(char* sifra)
    {
        for(int i = 0; i < _trenutnoProizvoda; i++)
        {
            if(strcmp(_proizvodi[i]->getSifra(), sifra) == 0) {
                delete _proizvodi[i];
                for(int j = i;  j < _trenutnoProizvoda - 1; j++) {
                    _proizvodi[j] = _proizvodi[j + 1];
                }
                _trenutnoProizvoda--;
                return;
            }
        }
        throw NedozvoljenaOperacija("Proizvod s navedenom sifrom nije nadjen", __LINE__);
    }
    //Preklopiti operator za ispis kataloške ponude
    friend ostream & operator<< (ostream &, Katalog &);
};
ostream & operator<< (ostream & cout, Katalog & k)
{
    cout << "Naslov: " << k._naslov << endl;
    cout << "Vrijedi do: " << k._vrijediDo << endl;
    cout << crtice << "\t .:: Proizvodi u katalogu ::." << crtice;
    if(k._trenutnoProizvoda == 0)
        cout << "Nema proizvoda!" << endl;
    else
        for(int i = 0; i < k._trenutnoProizvoda; i++) {
            k._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 max)
    {
        _size = max;
        _top = 0;
        _elements = new T[_size];
    }
    ~Stack()
    {
        delete [] _elements;
        _elements = NULL;
    }


    //Provjeravaju stanje na stack-u, prazan ili popunjen
    //Iskoristiti prilikom implementacije funkcija Push i Pop
    bool IsEmpty()const
    {
        return _top == 0;
    }
    bool IsFull()const
    {
        return _top == _size;
    }
    //Dodaje novi element na stack
    void Push(const T& element)
    {
        if(IsFull())
            throw NedozvoljenaOperacija("Stack je pun", __LINE__);
        _elements[_top++] = element;
    }

    //Uzima posljednji element sa stack-a
    T Pop(){
        if(IsEmpty())
            throw NedozvoljenaOperacija("Stack je prazan", __LINE__);
        return _elements[--_top];
    }

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

    //Vraća element sa stack-a na poziciji indeks (pozicije počinju od 1)
    T operator[](int indeks)const{
        if(indeks < 1 || indeks > _top)
            throw NedozvoljenaOperacija("Nije validan indeks", __LINE__);
        return _elements[indeks - 1];
    }

    //Operator za ispis elemenata na stack-u
    friend ostream& operator <<<>(ostream &, Stack<T> &);
};

template<class T>
ostream& operator << (ostream &, Stack<T> & s)
{
    for(int i = 0; i < _top; i++) {
        cout << _elements[i];
        cout << "----------------------";
    }
    return cout;
}

class Uposlenik
{
    char* _imePrezime;
    char* _radnoMjesto;
public:
    //Potrebne konstruktor i destruktor funkcije
    Uposlenik(char* imePrezime, char* radnoMjesto)
    {
        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(const Uposlenik& original)
    {
        int vel = strlen(original._imePrezime) + 1;
        _imePrezime = new char[vel];
        strcpy_s(_imePrezime, vel, original._imePrezime);

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

    char * getRadnoMjesto() const { return _radnoMjesto; }

    ~Uposlenik()
    {
        delete[] _imePrezime;
        _imePrezime = NULL;
        delete[] _radnoMjesto;
        _radnoMjesto = NULL;
    }
    friend ostream& operator << (ostream&, Uposlenik&);
};

ostream& operator << (ostream& cout, Uposlenik& obj)
{
    cout << obj._imePrezime << " - " << obj._radnoMjesto << endl;
    return cout;

}
class Narudzba
{
    int _brojNarudzbe;
    char* _datumIsporuke;
    Uposlenik* _uposlenik;
    Stack<Proizvod>* _proizvodi;
    int * _kolicineProizvoda;
    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 brojNarudzbe, char * datumIsporuke, Uposlenik & u, int brojProizvoda)
    {
        if(strcmp(u.getRadnoMjesto(), "Prodavac") != 0)
            throw NedozvoljenaOperacija("Radnik mora biti 'Prodavac'", __LINE__);
        if(brojProizvoda < 1)
            throw NedozvoljenaOperacija("Broj proizvoda po narudzbi mora biti najmanje 1", __LINE__);

        _brojNarudzbe = brojNarudzbe;

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

        _brojProizvoda = brojProizvoda;

        _uposlenik = new Uposlenik(u);
        _proizvodi = new Stack<Proizvod>(_brojProizvoda);
        _kolicineProizvoda = new int[_brojProizvoda];
    }
    //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 DodajProizvod(Proizvod &p, int kolicina = 1)
    {
        if(p.getStanje() < kolicina)
            throw NedozvoljenaOperacija("Nema dovoljno na stanju", __LINE__);
        for(int i = 1; i <= _proizvodi->GetSize(); i++)
            if((*_proizvodi)[i] == p) {
                _kolicineProizvoda[i-1] += kolicina;
                return;
            }
            _proizvodi->Push(p);
            _kolicineProizvoda[_proizvodi->GetSize() - 1] = kolicina;
            p -= kolicina;
    }

    //Funkciju za uklanjanje proizvoda iz narudžbe
    void UkloniProizvod()
    {
        _proizvodi->Pop();
    }
    //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 getUkupno()
    {
        double ukupno = 0, popust = 0;
        for(int i = 1; i <= _proizvodi->GetSize(); i++) {
            if((*_proizvodi)[i].getPopust() > 0) {
                popust = (*_proizvodi)[i].getCijena() * (*_proizvodi)[i].getPopust()/100;
                ukupno += ((*_proizvodi)[i].getCijena() * _kolicineProizvoda[i-1]) - popust * _kolicineProizvoda[i-1];
            }
            else
                ukupno += (*_proizvodi)[i].getCijena() * _kolicineProizvoda[i-1];
        }
        return ukupno;
    }


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

ostream& operator << (ostream& cout, Narudzba& obj)
{
    cout << "Broj narudzbe: " << obj._brojNarudzbe << endl;
    cout << "Datum isporuke: " << obj._datumIsporuke << endl;
    cout << "Uposlenik: " << *obj._uposlenik<< endl;
    cout << crtice << "\t .:: Proizvodi ::." << crtice;
    for(int i = 1; i <= obj._proizvodi->GetSize(); i++)
    {
        (*obj._proizvodi)[i].Info();
        cout << "Kolicina: " << obj._kolicineProizvoda[i-1] << endl;
        cout <<"---------------------------" << endl;
    }
    cout << crtice << "Ukupan iznos: " << obj.getUkupno() <<" KM." << endl;
    return cout;
}

void main()
{
    //Dodati minimalno 5 proizvoda u katalog
    //Ispisati ponudu kupcu
    //Omogućiti kreiranje narudžbe na osnovu izbora kupca

    Katalog k("Mepas Daily Shopping", "15.1.2015. god.");
    Proizvod p1("1111", "Milka", 2.20, 0, 30);
    Proizvod p2("2222", "Juice", 2.80, 0, 50);
    Proizvod p3("3333", "Pizza", 6, 0, 30);
    Odjeca o1("4444", "Majica", 35, 10, 20, "S, M, L", "crna, bijela");
    Odjeca o2("5555", "Hlace", 60, 10, 15, "39/40, 41/42", "crna, siva");
    Odjeca o3("6666","Zimska jakna", 90, 0, 20,"L, XL, XXL", "crna, plava");
    Odjeca o4("7777","Kosulja", 55, 0, 30,"M, L, XL", "crvena, siva");

    k.DodajProizvod(p1);
    k.DodajProizvod(p2);
    k.DodajProizvod(p3);
    k.DodajProizvod(o1);
    k.DodajProizvod(o2);
    k.UkloniProizvod("4444");
    k.DodajProizvod(o3);
    k.DodajProizvod(o4);

    cout << k << endl;

    try {
        //Ovdje nece biti uhvacen izuzetak osim ako se ne doda vise elemenata
        //nego sto u stek moze stati (max = 6 u ovom slucaju), a dodali smo 4
        //jer smo jedan obrisali, za testiranje ispisa greske smanjite max na 3
        //ili nize

        Narudzba n(1, "30.12.2014. god.", Uposlenik("Igor B.", "Prodavac"), 6);

        n.DodajProizvod(p1, 5);
        n.DodajProizvod(p1, 5);
        n.DodajProizvod(p3, 10);
        n.DodajProizvod(o2, 10); // do ovog artikla iznos je: 622 KM
        n.DodajProizvod(o4, 1); // do ovog artikla iznos je: 677 KM
        n.UkloniProizvod();

        cout << n << endl; // ukupno 622 KM jer smo uklonili zadnji proizvod

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

    cout << crtice << "Hvatanje izuzetaka..." << crtice;
    try
    {
        //Cijena ne smije biti negativna
        Proizvod test("1234", "Test", -20, 0, 5);
    }
    catch(NedozvoljenaOperacija& n)
    {
        n.ErrorInfo();
    }

    try
    {
        //Proizvod ne smije imati popust veci od 100 (u ovom slucaju 120)
        //niti manji od 0
        Proizvod testP("1234", "Test", 20, 120, 5);
    }
    catch(NedozvoljenaOperacija& n)
    {
        n.ErrorInfo();
    }

    try
    {
        //Radnik mora biti prodavac da bi narudzba bila kreirana
        Narudzba testN(2, "22.1.2015. god.", Uposlenik("Almin L.", "Menadzer"),20);
    }
    catch(NedozvoljenaOperacija& n)
    {
        n.ErrorInfo();
    }

}