26.06.2018

#include"stdafx.h"
#include<iostream>
#include<tuple>
using namespace std;

enum VrstaAktivnosti { Tehnike, Kata, Borba };
const char *VrstaAktivnostiChar[] = { "Tehnike", "Kata", "Borba" };
enum Pojas { Zuti, Narandzasti, Zeleni, Plavi, Smedji, Crni };
const char *PojasChar[] = { "Zuti", "Narandzasti", "Zeleni", "Plavi", "Smedji", "Crni" };

struct Datum {
    int * _dan, *_mjesec, *_godina;
    void Unos(int d, int m, int g) {
        _dan = new int(d);
        _mjesec = new int(m);
        _godina = new int(g);
    }
    void Ispis() { cout << *_dan << "/" << *_mjesec << "/" << *_godina << endl; }
    void Dealociraj() { delete _dan; delete _mjesec; delete _godina; }
    int PretvoriUDane()
    {
        return *_godina * 365 + *_mjesec * 30 + *_dan;
    }
};

struct Aktivnost {
    unique_ptr<VrstaAktivnosti> _vrsta;
    Datum _datumIzvrsenja;
    char * _nazivOpis;
    int _ocjena; // 1 - 10
    void Unos(VrstaAktivnosti vrsta, Datum * datum, int ocjena, const char * nazivOpis) {
        _vrsta = make_unique<VrstaAktivnosti>(vrsta);//dodala
        _datumIzvrsenja.Unos(*datum->_dan, *datum->_mjesec, *datum->_godina);
        _ocjena = ocjena;
        int size = strlen(nazivOpis) + 1;
        _nazivOpis = new char[size];
        strcpy_s(_nazivOpis, size, nazivOpis);
    }
    void Ispis() {
        cout << VrstaAktivnostiChar[*_vrsta] << " " << _ocjena << " " << _nazivOpis;//dodala niz
        _datumIzvrsenja.Ispis();
        cout << endl;
    }
    void Dealociraj() {
        _datumIzvrsenja.Dealociraj();
        delete[] _nazivOpis; _nazivOpis = nullptr;
    }
};

struct KaratePojas {
    Datum * _datumPolaganja;//datum koji ce se evidentirati kao datum polaganja pojasa tj. kada su ispunjene sve aktivnosti/obaveze
    Pojas _pojas;
    Aktivnost * _listaIzvrsenihAktivnosti;
    int _trenutnoIzvrsenihAktivnosti;
    void Unos(Pojas pojas) {
        _listaIzvrsenihAktivnosti = nullptr;
        _trenutnoIzvrsenihAktivnosti = 0;
        _datumPolaganja = nullptr;
        _pojas = pojas;
    }
    void Dealociraj() {
        if (_datumPolaganja != nullptr)//dodala
            _datumPolaganja->Dealociraj(); _datumPolaganja = nullptr;
        for (size_t i = 0; i < _trenutnoIzvrsenihAktivnosti; i++)
            _listaIzvrsenihAktivnosti[i].Dealociraj();
        delete[] _listaIzvrsenihAktivnosti;
        _listaIzvrsenihAktivnosti = nullptr;
    }
    void Ispis() {
        if (_datumPolaganja != nullptr)//dodala
            _datumPolaganja->Ispis();
        cout << PojasChar[_pojas] << endl;//dodala niz
        for (size_t i = 0; i < _trenutnoIzvrsenihAktivnosti; i++)
            _listaIzvrsenihAktivnosti[i].Ispis();
    }
    bool DodajIzvrsenuAktivnost(Aktivnost *aktivnost)
    {
        if (_datumPolaganja != nullptr)
            return false;

        for (int i = 0; i < _trenutnoIzvrsenihAktivnosti; i++)
        {
            if (_listaIzvrsenihAktivnosti[i]._vrsta == aktivnost->_vrsta)
            {
                if (_listaIzvrsenihAktivnosti[i]._datumIzvrsenja.PretvoriUDane() == aktivnost->_datumIzvrsenja.PretvoriUDane() &&
                    _listaIzvrsenihAktivnosti[i]._ocjena < 6)
                    return true;

                if (abs((aktivnost->_datumIzvrsenja.PretvoriUDane()) - (_listaIzvrsenihAktivnosti[i]._datumIzvrsenja.PretvoriUDane()))< 15)
                    return false;
            }
        }

        if (aktivnost->_ocjena < 5)
            return false;

        Aktivnost *temp = new Aktivnost[_trenutnoIzvrsenihAktivnosti + 1];
        for (int i = 0; i <_trenutnoIzvrsenihAktivnosti; i++)
        {
            temp[i].Unos(*_listaIzvrsenihAktivnosti[i]._vrsta, &_listaIzvrsenihAktivnosti[i]._datumIzvrsenja, _listaIzvrsenihAktivnosti[i]._ocjena,
                _listaIzvrsenihAktivnosti[i]._nazivOpis);
            _listaIzvrsenihAktivnosti[i].Dealociraj();
        }
        temp[_trenutnoIzvrsenihAktivnosti].Unos(*aktivnost->_vrsta, &aktivnost->_datumIzvrsenja, aktivnost->_ocjena, aktivnost->_nazivOpis);
        _listaIzvrsenihAktivnosti = temp;
        _trenutnoIzvrsenihAktivnosti++;
        return true;
    }
    void Sortiraj()
    {
        bool prolaz = true;
        while (prolaz)
        {
            prolaz = false;
            for (int i = 0; i < _trenutnoIzvrsenihAktivnosti - 1; i++)
            {
                if (_listaIzvrsenihAktivnosti[i]._ocjena < _listaIzvrsenihAktivnosti[i + 1]._ocjena)
                {
                    swap(_listaIzvrsenihAktivnosti[i], _listaIzvrsenihAktivnosti[i + 1]);
                    prolaz = true;
                }
            }
        }
    }
    void IspisOcjena()
    {
        for (int i = 0; i < _trenutnoIzvrsenihAktivnosti; i++)
        {
            cout << _listaIzvrsenihAktivnosti[i]._ocjena << endl;
        }
    }
    bool DaLiJePolozen()
    {
        /* Karate pojas zahtijeva uspjesnu realizaciju svih planiranih aktivnosti, a one se za jedan povecavaju sa svakim novim pojasom, npr.
        zuti pojas: 1 x tehnika, 1 x kata, 1 x borba;   narandzasti pojas: 2 x tehnika, 2 x kata, 2 x borba; i td...
        Funkcija vraca false u slucaju da: su kandidatu u listu aktivnosti evidentirane tri negativno ocijenjene identicne vrste aktivnosti
        (npr. tri negativne ocjene iz borbi), onda se taj pojas ne moze smatrati uspjesno stecenim
        i, te ukoliko nedostaje bilo koja od aktivnosti zahtijevanih u okviru tog pojasa. Ukoliko je kandidat uspjesno realizovao sve aktivnost,
        datum polaganja se postavlja na datum posljednje uspjesno realizovane aktivnosti*/
        int brojacNegTehnika = 0, brojacNegKata = 0, brojacNegBorba = 0, brojacPozitivnih = 0;
        int lokacija = 0;
        for (int j = 0; j < _trenutnoIzvrsenihAktivnosti; j++)
        {
            if (_listaIzvrsenihAktivnosti[j]._ocjena < 6)
            {
                if (*_listaIzvrsenihAktivnosti[j]._vrsta == Tehnike)
                    brojacNegTehnika++;
                else if (*_listaIzvrsenihAktivnosti[j]._vrsta == Kata)
                    brojacNegKata++;
                else if (*_listaIzvrsenihAktivnosti[j]._vrsta == Borba)
                    brojacNegBorba++;
            }
            else brojacPozitivnih++;

            if (_listaIzvrsenihAktivnosti[j]._datumIzvrsenja.PretvoriUDane() > lokacija && _listaIzvrsenihAktivnosti[j]._ocjena > 5)
                lokacija = _listaIzvrsenihAktivnosti[j]._datumIzvrsenja.PretvoriUDane();
        }
        if (brojacNegTehnika < 3 && brojacNegKata < 3 && brojacNegBorba < 3 && brojacPozitivnih == 3)
        {
            for (int i = 0; i < _trenutnoIzvrsenihAktivnosti; i++)
            {
                if (_listaIzvrsenihAktivnosti[i]._datumIzvrsenja.PretvoriUDane() == lokacija)
                {
                    _datumPolaganja = new Datum();
                    _datumPolaganja->Unos(*_listaIzvrsenihAktivnosti[i]._datumIzvrsenja._dan, *_listaIzvrsenihAktivnosti[i]._datumIzvrsenja._mjesec,
                        *_listaIzvrsenihAktivnosti[i]._datumIzvrsenja._godina);
                }
            }
            return true;
        }
        return false;
    }
    float PretragaRekrzivno(const char *rijec, int i = 0, int brojac = 0, float prosjek = 0)
    {
        /*Funkcija vraca prosjecnu ocjenu svih uspjesno realizovanih aktivnosti koja u nazivu ili opisu sadrze vrijednost primljenog parametra. Ukoliko smatrate da
        je potrebno, mozete dodati i druge parametre za potrebe implementacije ove funkcije*/
        if (_trenutnoIzvrsenihAktivnosti == i)
            return prosjek / brojac;
        if (strstr(_listaIzvrsenihAktivnosti[i]._nazivOpis, rijec) != nullptr)
        {
            return PretragaRekrzivno(rijec, i + 1, brojac + 1, prosjek + _listaIzvrsenihAktivnosti[i]._ocjena);
        }
        return PretragaRekrzivno(rijec, i + 1, brojac, prosjek);
    }

};

struct Kandidat {
    char * _imePrezime;
    shared_ptr<KaratePojas> _pojasevi[6];
    void Unos(const char * imePrezime) {
        int size = strlen(imePrezime) + 1;
        _imePrezime = new char[size];
        strcpy_s(_imePrezime, size, imePrezime);
        for (size_t i = 0; i < 6; i++)
            _pojasevi[i] = nullptr;
    }
    void Dealociraj() {
        delete[] _imePrezime; _imePrezime = nullptr;
        for (size_t i = 0; i < 6; i++)
            if (_pojasevi[i] != nullptr) {
                _pojasevi[i]->Dealociraj();
                _pojasevi[i].reset();
            }
    }
    void Ispis() {
        cout << _imePrezime << endl;
        for (size_t i = 0; i < 6; i++)
            if (_pojasevi[i] != nullptr)
                _pojasevi[i]->Ispis();
    }
    bool DodajPojas(KaratePojas pojasZuti)
    {
        /*Karate pojasevi se moraju dodavati po redoslijedu tj. ne smije se dozvoliti dodavanje zelenog pojasa ukoliko prethodno nije dodan zuti i narandzasti.
        Za provjeru lokacije (unutar funkcije DodajPojas) na koju ce se dodati novi karate pojas, te da li su nizi pojasevi prethodno dodani koristiti lambda
        funkciju.pojasZuti, pojasNarandzasti, pojasZeleni;*/
        auto lambda = [pojasZuti, this]()->bool
        {
            for (int i = 0; i < 6; i++)
            {
                if (pojasZuti._pojas == Zuti)
                    return true;
                if (_pojasevi[i]->_pojas == Zuti && pojasZuti._pojas == Narandzasti)
                    return true;
                if (_pojasevi[i]->_pojas == Zuti && _pojasevi[i]->_pojas == Narandzasti && pojasZuti._pojas == Zeleni)
                    return true;
            }
            return false;
        };
        if (lambda() == true)
        {
            for (int i = 0; i < 6; i++)
            {
                _pojasevi[i] = make_shared<KaratePojas>();
                _pojasevi[i]->Unos(pojasZuti._pojas);
            }
            return true;
        }
    }
    pair<Pojas, float>GetNajbolji() {
        float prosjecna = 0, temp = 0;
        int brojac = 0;
        Pojas pojas;
        for (size_t i = 0; i < 6; i++)
        {
            if (_pojasevi[i] != nullptr)
            {
                for (size_t j = 0; j < _pojasevi[i]->_trenutnoIzvrsenihAktivnosti; j++)
                {
                    if (_pojasevi[i]->_listaIzvrsenihAktivnosti[j]._ocjena > 5)
                    {
                        temp += _pojasevi[i]->_listaIzvrsenihAktivnosti[j]._ocjena;
                        brojac++;
                    }
                }
                temp /= brojac;
                if (temp > prosjecna)
                {
                    prosjecna = temp;
                    pojas = _pojasevi[i]->_pojas;
                }
                brojac = 0;
                temp = 0;
            }
        }
        return make_pair(pojas, prosjecna);
    }
};

void main() {

    //BROJ I VRSTA PARAMETARA MORAJU BITI IDENTICNI KAO U PRIMJERIMA
    //STAVITE KOMENTAR NA DIJELOVE CODE-A KOJE NE BUDETE IMPLEMENTIRALI
    Datum datumPolaganja1, datumPolaganja2, datumPolaganja3, datumPolaganja4;
    datumPolaganja1.Unos(10, 6, 2018);
    datumPolaganja2.Unos(18, 6, 2018);
    datumPolaganja3.Unos(22, 3, 2018);
    datumPolaganja4.Unos(22, 7, 2018);

    Aktivnost aktivnost1, aktivnost2, aktivnost3, aktivnost4, aktivnost5;
    aktivnost1.Unos(Tehnike, &datumPolaganja1, 6, "Tehnike za zuti pojas");
    //aktivnost1.Ispis();
    aktivnost2.Unos(Kata, &datumPolaganja1, 8, "Taiki joko shodan - zuti pojas");
    //aktivnost2.Ispis();
    aktivnost3.Unos(Borba, &datumPolaganja1, 2, "Jednostavne borbene tehnike sa partnerom");
    aktivnost4.Unos(Borba, &datumPolaganja1, 6, "Jednostavne borbene tehnike sa partnerom");
    aktivnost5.Unos(Borba, &datumPolaganja4, 6, "Jednostavne borbene tehnike sa partnerom");

    KaratePojas pojasZuti, pojasNarandzasti, pojasZeleni;
    pojasZuti.Unos(Zuti);
    pojasNarandzasti.Unos(Narandzasti);
    pojasZeleni.Unos(Zeleni);

    /*Na osnovu vrijednosti primljenog parametra osigurati dodavanje novoizvrsene aktivnosti za potrebe stjecanja odredjenog pojasa. Broj aktivnosti nije ogranicen.
    Identicna aktivnost se moze dodati jedino u slucaju kada je prethodna (identivna aktivnost po vrsti i datumu izvrsenja) imala ocjenu manju od 6.
    Uspjesnom aktivnoscu se smatraju one aktivnosti koje imaju ocjenu vecu od 5, a svaka naredna identicna aktivnost, bez obzira da li je uspjesna ili ne,
    moze biti dodana jedino ako je proslo najmanje 15 dana od izvrsenja prethodne. Onemoguciti dodavanje aktivnosti uspjesno polozenom pojasu.*/
    if (pojasZuti.DodajIzvrsenuAktivnost(&aktivnost1))
        cout << "Aktivnost uspjesno dodana!" << endl;
    if (pojasZuti.DodajIzvrsenuAktivnost(&aktivnost2))
        cout << "Aktivnost uspjesno dodana!" << endl;
    if (pojasZuti.DodajIzvrsenuAktivnost(&aktivnost3))
        cout << "Aktivnost uspjesno dodana!" << endl;
    if (pojasZuti.DodajIzvrsenuAktivnost(&aktivnost4))//15 dana...
        cout << "Aktivnost uspjesno dodana!" << endl;
    if (pojasZuti.DodajIzvrsenuAktivnost(&aktivnost5))
        cout << "Aktivnost uspjesno dodana!" << endl;

    pojasZuti.Ispis();
    //Koristeci neki od obradjenih algoritama, po ocjeni sortirati aktivnosti u okviru odredjenog pojasa
    pojasZuti.Sortiraj();
    pojasZuti.IspisOcjena();

    /* Karate pojas zahtijeva uspjesnu realizaciju svih planiranih aktivnosti, a one se za jedan povecavaju sa svakim novim pojasom, npr.
    zuti pojas: 1 x tehnika, 1 x kata, 1 x borba;   narandzasti pojas: 2 x tehnika, 2 x kata, 2 x borba; i td...
    Funkcija vraca false u slucaju da: su kandidatu u listu aktivnosti evidentirane tri negativno ocijenjene identicne vrste aktivnosti
    (npr. tri negativne ocjene iz borbi), onda se taj pojas ne moze smatrati uspjesno stecenim
    i, te ukoliko nedostaje bilo koja od aktivnosti zahtijevanih u okviru tog pojasa. Ukoliko je kandidat uspjesno realizovao sve aktivnost,
    datum polaganja se postavlja na datum posljednje uspjesno realizovane aktivnosti*/
    if (pojasZuti.DaLiJePolozen())
        pojasZuti.Ispis();

    /*Funkcija vraca prosjecnu ocjenu svih uspjesno realizovanih aktivnosti koja u nazivu ili opisu sadrze vrijednost primljenog parametra. Ukoliko smatrate da
    je potrebno, mozete dodati i druge parametre za potrebe implementacije ove funkcije*/
    cout << "Prosjecna ocjena za zuti pojas -> " << pojasZuti.PretragaRekrzivno("pojas") << endl;

    //ispisuje sve dostupne podatke o pojasu
    pojasZuti.Ispis();

    Kandidat jasmin;
    jasmin.Unos("Jasmin Azemovic");

    /*Karate pojasevi se moraju dodavati po redoslijedu tj. ne smije se dozvoliti dodavanje zelenog pojasa ukoliko prethodno nije dodan zuti i narandzasti.
    Za provjeru lokacije (unutar funkcije DodajPojas) na koju ce se dodati novi karate pojas, te da li su nizi pojasevi prethodno dodani koristiti lambda
    funkciju.*/
    if (jasmin.DodajPojas(pojasZuti))
        cout << "Pojas uspjesno dodan!" << endl;
    if (jasmin.DodajPojas(pojasZeleni))//prethodno je trebao biti dodan narandzasti pojas
        cout << "Pojas uspjesno dodan!" << endl;
    if (jasmin.DodajPojas(pojasNarandzasti))
        cout << "Pojas uspjesno dodan!" << endl;

    float prosjek = 0;
    Pojas pojas;
    //Funkcija GetNajbolji vraca par koji sadrzi oznaku i prosjecnu ocjenu (uspjesno okoncanih aktivnosti) pojasa sa najvecim prosjekom
    tie(pojas, prosjek) = jasmin.GetNajbolji();
    cout << "Najbolji rezultat od " << prosjek << " je ostvaren tokom stjecanja pojasa " << pojas << endl;


    datumPolaganja1.Dealociraj(), datumPolaganja2.Dealociraj(), datumPolaganja3.Dealociraj(), datumPolaganja4.Dealociraj();
    aktivnost1.Dealociraj(), aktivnost2.Dealociraj(), aktivnost3.Dealociraj(), aktivnost4.Dealociraj(), aktivnost5.Dealociraj();
    pojasZuti.Dealociraj(), pojasNarandzasti.Dealociraj(), pojasZeleni.Dealociraj();
    jasmin.Dealociraj();

    system("pause");
}