#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<regex>


using namespace std;



template<class T1, class T2>
class Kolekcija {
    T1 * _elementi1;
    T2 * _elementi2;
    int _trenutnoElemenata;
public:
    int getTrenutno() { return _trenutnoElemenata; }
    Kolekcija()
    {
        _elementi1 = nullptr;
        _elementi2 = nullptr;
        _trenutnoElemenata = 0;
    }
    Kolekcija(Kolekcija & o)
    {
        _trenutnoElemenata = o._trenutnoElemenata;
        _elementi1 = new T1[_trenutnoElemenata];
        _elementi2 = new T2[_trenutnoElemenata];
        for (int i = 0; i < _trenutnoElemenata; i++)
        {
            _elementi1[i] = o._elementi1[i];
            _elementi2[i] = o._elementi2[i];
        }
    }
    ~Kolekcija() {
        delete[] _elementi1; _elementi1 = nullptr;
        delete[] _elementi2; _elementi2 = nullptr;
    }

    bool AddElement(T1 e1, T2 e2)
    {
        for (int i = 0; i < _trenutnoElemenata; i++)
        {
            if(_elementi1[i] == e1 && _elementi2[i] == e2)
                return false;
        }

        T1* temp1 = new T1[_trenutnoElemenata + 1];
        T2* temp2 = new T2[_trenutnoElemenata + 1];

        for (int i = 0; i < _trenutnoElemenata; i++)
        {
            temp1[i] = _elementi1[i];
            temp2[i] = _elementi2[i];
        }

        delete[] _elementi1;
        delete[] _elementi2;
        _elementi1 = temp1;
        _elementi2 = temp2;

        _elementi1[_trenutnoElemenata] = e1;
        _elementi2[_trenutnoElemenata++] = e2;
        return true;

    }
    bool RemoveElement(T1 e1)
    {
        for (int i = 0; i < _trenutnoElemenata; i++)
        {
            if (_elementi1[i] == e1)
            {

                for (int   j= i; j < _trenutnoElemenata-1; j++)
                {
                    _elementi1[j] = _elementi1[j + 1];
                    _elementi2[j] = _elementi2[j + 1];
                }
                _trenutnoElemenata--;

                T1* temp1 = new T1[_trenutnoElemenata];
                T2* temp2 = new T2[_trenutnoElemenata];

                for (int i = 0; i < _trenutnoElemenata; i++)
                {
                    temp1[i] = _elementi1[i];
                    temp2[i] = _elementi2[i];
                }

                delete[] _elementi1;
                delete[] _elementi2;
                _elementi1 = temp1;
                _elementi2 = temp2;

                return true;
            }
        }

        return false;
    }
    Kolekcija operator + (Kolekcija & k)
    {


    }
    /*1. AddElement :: omogucava dodavanje novog elementa u kolekciju. Osigurati automatsko prosiranje kolekcije prilikom dodavanja svakog novog elementa, te onemoguciti ponavljanje elemenata.
    2. RemoveElement :: na osnovu parametra tipa T1 uklanja elemente iz kolekcije i smanjuje velicinu niza. Ukoliko je potrebno, prilikom uklanjanja elementa izvrsiti dealokaciju. Prilikom uklanjanja elemenata ocuvati redoslijed njihovog dodavanja.
    3. operator+ :: vraca objekat tipa Kolekcija koji u sebi sadrzi sve elemente objekta koji je
    pozvao funkciju i objekta koji je proslijedjen kao parametar (takodjer tipa Kolekcija), pri cemu se elementi unutar kreirane kolekcije ne smiju
    ponavljati (ne smiju postojati dva ista elementa).*/

    T1 & operator [] (int i)
    {
        return _elementi1[i];
    }
    T1 & getElement1(int i)
    {
        return _elementi1[i];
    }
    T2 & getElement2(int i)
    {
        return _elementi2[i];
    }

    friend ostream & operator <<(ostream & c, const Kolekcija & k) {
        c << "Trenutno: " << k._trenutnoElemenata << endl;
        for (int i = 0; i < k._trenutnoElemenata; i++)
        {
            c<< k._elementi1[i] << " " << k._elementi2[i] << endl;
        }
        return c;
    }
};
int brojac = 0;
class Student {
    const int _brojIndeksa;
    string _ime;
    string _prezime;
    string _korisnickomIme;
    string _lozinka;
    /*1. potrebne funkcije
    NAPOMENE:
    2. lozinka mora postovati sljedeca pravila:
    2.a: sadrzi kombinaciju slova, brojeva i nekog od specijalnih znakova
    2.b: ne smije sadrzavati niti ime niti prezime
    2.c: sadrzi minimalno 6 znakova
    postivanje navedenih pravila se mora osigurati prije kreiranje objekta tipa Student*/
public:
    Student(string ime="---", string prezime="---", string username="---", string password="---"):_brojIndeksa(++brojac)
    {
        _ime = ime;
        _prezime = prezime;
        _korisnickomIme = username;
        _lozinka = password;
    }
    bool operator == (Student & o)
    {
        return _ime == o._ime && _prezime == o._prezime;
    }
    Student & operator = (Student & o)
    {
        if (this != &o)
        {
            int(_brojIndeksa) = o._brojIndeksa;
            _ime = o._ime;
            _prezime = o._prezime;
            _korisnickomIme = o._korisnickomIme;
            _lozinka = o._lozinka;
        }
        return *this;
    }

    friend ostream & operator <<(ostream & c, const Student & s)
    {
        c << "Ime i prezime: " << s._ime << " " << s._prezime << endl;
        return c;
    }

};
class Ispit {
protected:
    char * _opis;//npr. PR2::Integralni::30.01.2015
                 /*tip string u kolekciji sluzi kao napomena vezana za ponasanje studenta na ispitu gdje ce se evidentirati utisci dezurnog nastavnika
                 npr. kasnio, dosao bez indeksa, izbacen zbog prepisivanja*/
    Kolekcija<Student, string> * _listaStudenata;
    /*1. AddStudent :: dodaje podatke o studentu koji je pristupio ispitu uz odgovarajucu napomenu (napomena nije obavezna).Studentu nije dozvoljeno da
    dva puta pristupi istom ispitu, a u slucaju da pokusa pristupiti automatski se dodaje adekvatna napomena (npr. ponovo pokusao pristupiti). */

public:
    Kolekcija<Student, string>* getListuStudenata() { return _listaStudenata; }
    Ispit(string opis = "---")
    {
        _opis = new char[strlen(opis.c_str()) + 1];
        strcpy_s(_opis, strlen(opis.c_str()) + 1, opis.c_str());

        _listaStudenata = new Kolekcija<Student, string>;
    }
    Ispit(Ispit & o)
    {
        _opis = new char[strlen(o._opis) + 1];
        strcpy_s(_opis, strlen(o._opis) + 1, o._opis);
        _listaStudenata = new Kolekcija<Student, string>(*o._listaStudenata);
    }
    ~Ispit()
    {
        delete[] _opis; _opis = nullptr;
        delete _listaStudenata; _listaStudenata = nullptr;
    }
    Ispit & operator = (Ispit & o)
    {
        if (this != &o)
        {
            delete[] _opis;
            delete _listaStudenata;

            _opis = new char[strlen(o._opis) + 1];
            strcpy_s(_opis, strlen(o._opis) + 1, o._opis);
            _listaStudenata = new Kolekcija<Student, string>(*o._listaStudenata);
        }
        return *this;
    }

    bool AddStudent(Student & s, string napomena="---")
    {
        if (_listaStudenata->AddElement(s, napomena))
            return true;
        else
        {
            cout<<  "Ponovo pokusao pristupiti" << endl;
            return false;
        }

    }

    friend ostream & operator <<(ostream &c, const Ispit & i)
    {
        c << "Opis: " << i._opis << endl;
        c << "Lista studenata: ";
        c << *i._listaStudenata << endl;
        return c;
    }

    bool operator == (Ispit & o)
    {
        return strcmp(_opis, o._opis) == 0;
    }
};
class Predmet {
    char * _nazivPredmeta;
    char * _profesor;
    //1. potrebne funkcije
public:
    Predmet(string nazivPredmeta = "---", string profesor="---")
    {
        _nazivPredmeta = new char[strlen(nazivPredmeta.c_str()) + 1];
        strcpy_s(_nazivPredmeta, strlen(nazivPredmeta.c_str()) + 1, nazivPredmeta.c_str());

        _profesor = new char[strlen(profesor.c_str()) + 1];
        strcpy_s(_profesor, strlen(profesor.c_str()) + 1, profesor.c_str());
    }
    Predmet(Predmet & o)
    {
        _nazivPredmeta = new char[strlen(o._nazivPredmeta) + 1];
        strcpy_s(_nazivPredmeta, strlen(o._nazivPredmeta)+ 1, o._nazivPredmeta);

        _profesor = new char[strlen(o._profesor) + 1];
        strcpy_s(_profesor, strlen(o._profesor) + 1, o._profesor);
    }
    ~Predmet()
    {
        delete[] _nazivPredmeta; _nazivPredmeta = nullptr;
        delete[] _profesor; _profesor = nullptr;
    }
    Predmet & operator = (Predmet & o)
    {
        if (this != &o)
        {
            delete[] _nazivPredmeta;
            delete[] _profesor;

            _nazivPredmeta = new char[strlen(o._nazivPredmeta) + 1];
            strcpy_s(_nazivPredmeta, strlen(o._nazivPredmeta) + 1, o._nazivPredmeta);

            _profesor = new char[strlen(o._profesor) + 1];
            strcpy_s(_profesor, strlen(o._profesor) + 1, o._profesor);
        }
        return *this;
    }
    bool operator == (Predmet & o)
    {
        return strcmp(_nazivPredmeta, o._nazivPredmeta) == 0 && strcmp(_profesor, o._profesor) == 0;
    }
    friend ostream & operator <<(ostream &c, const Predmet & p)
    {
        c << "Predmet: " << p._nazivPredmeta << ", Profesor: " << p._profesor << endl;
        return c;

    }
};
class SkolskaGodina {
    char * _skolskaGodina;//npr.2014/2015
    Kolekcija<Predmet, Ispit> * _odrzaniIspiti;
public:
    SkolskaGodina(string skolskaGodina)
    {
        _skolskaGodina = new char[strlen(skolskaGodina.c_str()) + 1];
        strcpy_s(_skolskaGodina, strlen(skolskaGodina.c_str()) + 1, skolskaGodina.c_str());
        _odrzaniIspiti = new Kolekcija<Predmet, Ispit>;
    }
    SkolskaGodina(SkolskaGodina & o)
    {
        _skolskaGodina = new char[strlen(o._skolskaGodina) + 1];
        strcpy_s(_skolskaGodina, strlen(o._skolskaGodina) + 1, o._skolskaGodina);
        _odrzaniIspiti = new Kolekcija<Predmet, Ispit>(*o._odrzaniIspiti);
    }
    ~SkolskaGodina()
    {
        delete[] _skolskaGodina; _skolskaGodina = nullptr;
        delete _odrzaniIspiti;
    }

    bool AddIspit(Predmet & p, Ispit & i)
    {
        return _odrzaniIspiti->AddElement(p,i);
    }

    bool RemoveIspit(Ispit & obj)
    {
        for (int i = 0; i < _odrzaniIspiti->getTrenutno(); i++)
        {
            if(_odrzaniIspiti->getElement2(i) == obj)
            {
                if (_odrzaniIspiti->getElement2(i).getListuStudenata()->getTrenutno() == 0)
                {
                    return _odrzaniIspiti->RemoveElement((*_odrzaniIspiti)[i]);
                }
            }

        }
        return false;
    }

    int GetBrojIzlazakaByPredmet(Student & s, Predmet & p)
    {
        int brIzlazaka = 0;

        for (int i = 0; i < _odrzaniIspiti->getTrenutno(); i++)
        {
            if (_odrzaniIspiti->getElement1(i) == p)
            {
                for (int j = 0; j < _odrzaniIspiti->getElement2(i).getListuStudenata()->getTrenutno(); j++)
                {
                    if (_odrzaniIspiti->getElement2(i).getListuStudenata()->getElement1(j) == s)
                        brIzlazaka++;
                }
            }
        }
        return brIzlazaka;
    }

    /*1. AddIspit::dodate podatke o odrzanom ispitu na odredjenom predmetu
    2. RemoveIspit::uklanja podatke o odrzanom ispitu, ali samo pod uslovom da tom ispitu nije pristupio niti jedan student
    3. GetBrojIzlazakaByPredmet::vraca podatak o tome koliko je puta trazeni student izasao na ispit iz odredjenog predmeta u toku skolske godine
    4. operator()::vraca sve studente koji u napomeni posjeduju sadrzaj koji je proslijedjen kao parametar (npr.listu svih studenata koji u napomeni
    posjeduju sadrzaj "bez indeksa")
    5. operator<<::ispisuje sve dostupne podatke o odrzanim ispitima i studentima koji su im pristupili*/


    vector<Student> & operator() (string tekst)
    {
        vector<Student> vec;
        for (int i = 0; i < _odrzaniIspiti->getTrenutno(); i++)
        {
            for (int j = 0; j < _odrzaniIspiti->getElement2(i).getListuStudenata()->getTrenutno(); j++)
            {
                if (_odrzaniIspiti->getElement2(i).getListuStudenata()->getElement2(j) == tekst) {
                    vec.push_back(_odrzaniIspiti->getElement2(i).getListuStudenata()->getElement1(j));
                    cout << "Dodan student " << _odrzaniIspiti->getElement2(i).getListuStudenata()->getElement1(j) << endl;
                }
            }
        }
        return vec;
    }

    friend ostream & operator <<(ostream & c, const SkolskaGodina & sk)
    {
        c << "Skolska godina: " << sk._skolskaGodina << endl;
        c << "Odrzani ispiti: " << endl;
        c << *sk._odrzaniIspiti << endl;
        return c;
    }
};
void main() {
    //izbjegavajte koristenje vlastitog imena i prezimena
    //provjeriti validnost izvrsenja svih dostupnih funkcionalnosti na objektu tipa SkolskaGodina
    Predmet p("Programiranje", "Denis Music");
    Ispit ispitIzPR("Ispit iz programiranja");
    Student haris("Haris", "Hercegovac", "HH", "hdusad");
    Student nihad("Nihad", "Tahunic", "NT", "fudsfds");
    Student almin("Almin", "Latovic", "AL", "djksafjsd");

    ispitIzPR.AddStudent(haris,"kupus");
    ispitIzPR.AddStudent(nihad);
    ispitIzPR.AddStudent(almin, "kupus");
    Ispit ispitIzDM("Diskretna");
    ispitIzDM.AddStudent(nihad);


    SkolskaGodina sg("2014/2015");
    sg.AddIspit(p, ispitIzDM);
    sg.AddIspit(p, ispitIzPR);
    sg.RemoveIspit(ispitIzPR);

    cout << sg.GetBrojIzlazakaByPredmet(nihad, p) << endl;
    cout << sg << endl;

    cout << "--------------------------------------------" << endl;

    vector<Student> vektorStudent = sg("kupus");

    cout << "SIZE: " << vektorStudent.size() << endl;
    for (int i = 0; i < vektorStudent.size(); i++)
    {
        cout << vektorStudent[i] << endl;
    }





}