#include <iostream>
#include <algorithm>
using namespace std;


/****************************************************************************
1. SVE KLASE TREBAJU POSJEDOVATI ADEKVATAN DESTRUKTOR
2. NAMJERNO IZOSTAVLJANJE KOMPLETNIH I/ILI POJEDINIH DIJELOVA DESTRUKTORA KOJI UZROKUJU RUNTIME ERROR ÆE BITI OZNACENO KAO "RE"
3. SPAŠAVAJTE PROJEKAT KAKO BI SE SPRIJEÈILO GUBLJENJE URAÐENOG ZADATKA
4. NAZIVI FUNKCIJA, TE BROJ I TIP PARAMETARA MORAJU BITI IDENTIÈNI ONIMA KOJI SU KORIŠTENI U TESTNOM CODE-U, OSIM U SLUÈAJU DA POSTOJI ADEKVATAN RAZLOG ZA NJIHOVU MODIFIKACIJU. OSTALE, POMOÆNE FUNKCIJE MOŽETE IMENOVATI I DODAVATI PO ŽELJI.
5. BEZ OBZIRA NA TO DA LI SU ISPITNI ZADACI URAÐENI, SVI STUDENTI KOJI SU PRISTUPILI ISPITU MORAJU PREDATI SVOJ RAD
6. ZA POTREBE TESTIRANJA, UNUTAR MAIN FUNKCIJE MOZETE DODAVATI NOVE TESTNE PODATKE
****************************************************************************/
//narednu liniju code-a ignorisite, osim u slucaju da vam bude predstavljala smetnje u radu
#pragma warning(disable:4996)

const char* crt = "\n----------------------------------------------------\n";
class Datum
{
    int* _dan, * _mjesec, * _godina;
public:
    Datum(int d, int m, int g)
    {
        _dan = new int(d);
        _mjesec = new int(m);
        _godina = new int(g);
    }
    Datum(const Datum& d)
    {
        _dan = new int(*d._dan);
        _mjesec = new int(*d._mjesec);
        _godina = new int(*d._godina);
    }
    ~Datum()
    {
        delete _dan; _dan = nullptr;
        delete _mjesec; _mjesec = nullptr;
        delete _godina; _godina = nullptr;
    }
    friend ostream& operator<<(ostream& COUT, Datum obj)
    {
        COUT << *obj._dan << "/" << *obj._mjesec << "/" << *obj._godina << endl;
        return COUT;
    }
    Datum& operator=(const Datum& drugi);
};
Datum& Datum::operator=(const Datum& drugi)
{
    if (this != &drugi)
    {
        delete _dan;
        _dan = new int(*drugi._dan);
        delete _mjesec;
        _mjesec = new int(*drugi._mjesec);
        delete _godina;
        _godina = new int(*drugi._godina);
    }
    return *this;
}
template<class T, int velicina>
class FITArray
{
    T _niz[velicina];
    int _trenutno;
    bool _dozvoliDupliciranje; // nizIntegera ovo je false
public:
    //OSTALE FUNKCIJE CLANICE DEFINISATI VAN TEMPLATE KLASE
    FITArray(bool dozvoliDupliciranje = true) { _dozvoliDupliciranje = dozvoliDupliciranje; _trenutno = 0; }
    FITArray(const FITArray& obj);
    int GetTrenutno() { return _trenutno; }
    T* GetNiz() { return _niz; }
    template<typename T, int velicina>
    friend ostream& operator<<(ostream& COUT, const FITArray<T, velicina>& obj);
    bool operator += (T vrijednost);
    bool operator -= (T vrijednost);
    FITArray<T, velicina>& operator=(FITArray<T, velicina>& drugi);
    FITArray<T, velicina> operator()(int, int);
};
template<typename T, int velicina>
FITArray<T, velicina>& FITArray<T, velicina>::operator=(FITArray<T, velicina>& drugi)
{
    _trenutno = drugi._trenutno;
    _dozvoliDupliciranje = drugi._dozvoliDupliciranje;
    for (int i = 0; i < _trenutno; i++)
    {
        _niz[i] = drugi._niz[i];
    }
    return *this;

}
template<typename T, int velicina>
ostream& operator<<(ostream& COUT, const FITArray<T,velicina>& obj)
{
    for (int i = 0; i < obj._trenutno; i++)
        COUT << obj._niz[i] << " ";
    return COUT;
}
template<class T, int velicina>
bool FITArray<T, velicina>::operator+=(T vrijednost)
{
    if (_trenutno == velicina) return false;
    if (!_dozvoliDupliciranje)
        for (int i = 0; i < _trenutno; i++)
            if (_niz[i] == vrijednost)
                return false;
    _niz[_trenutno++] = vrijednost;
    return true;
}
template<class T, int velicina>
bool FITArray<T, velicina>::operator-=(T vrijednost)
{
    for (int i = 0; i < _trenutno; i++)
    {
        if (_niz[i] == vrijednost)
        {
            for (int j = i; j < _trenutno - 1; j++)
                _niz[j] = _niz[j + 1];
            _trenutno--;
            return true;
        }
    }
    return false;
}
template<class T, int velicina>
FITArray<T, velicina>::FITArray(const FITArray<T, velicina>& obj) : _trenutno(obj._trenutno), _dozvoliDupliciranje(obj._dozvoliDupliciranje)
{
    for (int i = 0; i < _trenutno; i++)
        _niz[i] = obj._niz[i];
}
template<class T, int velicina>
FITArray<T, velicina> FITArray<T, velicina>::operator ()(int OD, int DO)
{
    FITArray<T, velicina> temp(_dozvoliDupliciranje);
    if (OD >= 0 && OD < _trenutno)
    {
        if (DO > _trenutno) DO = _trenutno;
        for (int i = OD; i < DO; i++)
            temp += _niz[i];

    }
    return temp;
}
class PolozeniPredmet
{
    char* _naziv;
    int _ocjena;
    Datum _datumPolaganja;
public:
    PolozeniPredmet() : _naziv(nullptr), _ocjena(5), _datumPolaganja(1, 1, 2000) {}
    PolozeniPredmet(const Datum& d, const char* naziv, int ocjena);
    PolozeniPredmet(const PolozeniPredmet& p);
    PolozeniPredmet& operator =(const PolozeniPredmet& p);
    ~PolozeniPredmet() { delete[] _naziv; _naziv = nullptr; }
    int GetOcjena() const { return _ocjena; }
    friend bool operator ==(const PolozeniPredmet& p1, const PolozeniPredmet& p2);
    friend ostream& operator<<(ostream& COUT, const PolozeniPredmet& obj)
    {
        COUT << obj._naziv << "(" << obj._ocjena << ")" << obj._datumPolaganja << endl;
        return COUT;
    }
};
PolozeniPredmet::PolozeniPredmet(const Datum& d, const char* naziv, int ocjena) : _datumPolaganja(d)
{


    _ocjena = ocjena;
    _naziv = new char[strlen(naziv) + 1];
    strcpy_s(_naziv, strlen(naziv) + 1, naziv);

}
PolozeniPredmet::PolozeniPredmet(const PolozeniPredmet& p) : _naziv(new char[strlen(p._naziv) + 1]), _ocjena(p._ocjena), _datumPolaganja(p._datumPolaganja)
{
    strcpy_s(_naziv, strlen(p._naziv) + 1, p._naziv);
}
PolozeniPredmet& PolozeniPredmet::operator=(const PolozeniPredmet& p)
{
    if (this != &p)
    {
        delete [] _naziv ;
        _naziv = new char[strlen(p._naziv) + 1];
        strcpy_s(_naziv, strlen(p._naziv) + 1, p._naziv);
        _ocjena = p._ocjena;
        _datumPolaganja = p._datumPolaganja;

    }

    return *this;

}
bool operator==(const PolozeniPredmet& p1, const PolozeniPredmet& p2)
{
    return (strcmp(p1._naziv, p2._naziv) == 0) ;

}


class Student
{
    static int _indeksCounter; //sluzi za odredjivanje narednog broja indeksa koji ce biti dodijeljen studentu, pocevsi od 160000
    const int _indeks;
    char* _imePrezime;
    FITArray<PolozeniPredmet, 40> _polozeniPredmeti;
public:
    Student(const char* imePrezime);
    ~Student()
    {
        delete[] _imePrezime; _imePrezime = nullptr;
    }
    void DodajPredmet(const PolozeniPredmet& predmet);
    double GetProsjek();
    friend ostream& operator<<(ostream& COUT, Student& obj)
    {
        COUT << obj._indeks << " " << obj._imePrezime << endl << obj._polozeniPredmeti;
        return COUT;
    }
    Student& operator=(Student& s);
};
int Student::_indeksCounter(160000);
void Student::DodajPredmet(const PolozeniPredmet& predmet)
{
    _polozeniPredmeti += predmet;
}
double Student::GetProsjek()
{
    double prosjek=0,suma=0;

    for (int i = 0; i < _polozeniPredmeti.GetTrenutno(); i++)
    {
        suma += _polozeniPredmeti.GetNiz()[i].GetOcjena();
    }
    prosjek = suma / _polozeniPredmeti.GetTrenutno();
    return prosjek;
}


Student::Student(const char* imePrezime) : _indeks(_indeksCounter++)
{
    if (!imePrezime) return;

    int size = strlen(imePrezime) + 1;
    _imePrezime = new char[size];
    strcpy_s(_imePrezime, size, imePrezime);
}
Student& Student::operator=(Student& s)
{
    if (this != &s)
    {
        _polozeniPredmeti = s._polozeniPredmeti;
    }
    return *this;
}
int main()
{
    const int max = 20;

    Datum jucer(20, 11, 2017), danas(21, 11, 2017), sutra(22, 11, 2017);
    cout << jucer << danas << sutra << endl;
    jucer = danas;
    cout << jucer << danas << sutra << endl;
    ////parametar tipa bool odredjuje da li je u nizu dozvoljeno dupliciranje elemenata
    FITArray<int, max> nizIntegera(false);

    for (size_t i = 0; i < max - 1; i++)
        nizIntegera += i;//dodaje novog clana niza
    if (!(nizIntegera += 6))//pokusavamo dodati dupli clan niza
        cout << "Element nije dodan u niz" << endl;

    cout << crt << nizIntegera << crt; //ispisuje sve clanove niza

    nizIntegera -= 9; //uklanja clan niza sa vrijednoscu 9
    nizIntegera -= 17;
    FITArray<int, max> noviNizIntegera(nizIntegera);

    cout << crt << noviNizIntegera << crt;

    ////// parametri odredjuju lokacije (indekse u nizu) elemenata OD - DO koje je potrebno vratiti. u
    ////// slucaju da u nizu ne postoji trazeni broj elemenata funkcija treba da vrati sve element od lokacije
    ////// OD pa do posljednje dostupnog elementa
    cout << "Clanovi niza od lokacije 2 do lokacije 5 su -> " << noviNizIntegera(2, 5) << crt;
    Student adel("Adel Handzic"), jasmin("Jasmin Azemovic");
    cout << adel << " " << jasmin << endl;
    PolozeniPredmet prII(jucer, "PRII", 8), prIII(sutra, "PRIII", 7);
    cout << prII << endl;
    adel.DodajPredmet(prII);
    adel.DodajPredmet(prIII);
    cout << adel << endl;
    //////vraca prosjecnu ocjenu studenta
    cout << "Prosjecna ocjena -> " << adel.GetProsjek() << crt;

    jasmin = adel;
    cout << jasmin << endl;
    cout << "Prosjecna ocjena -> " << jasmin.GetProsjek() << crt;
    return 0;
}