/*
    Modelovati web server koji pruza informacije o vremenskoj prognozi.
    Server je predstavljen klasom Server. Server sadrzi podatke o prognoziranoj temperaturi na odredjeni dan, sto
    se prosledjuje u konstruktoru.

    Ponasanje klijenata koji pristupaju serveru predstavljeno je datom funkcijom klijent_f.
    Klijent pozivom metode posaljiZahtev salje zahtev serveru za dobijanjem temperature na odredjeni datum
    Datum za koji se temperatura trazi je parametar metode posaljiZahtev. Metoda posaljiZahtev kao rezultat
    vraca prognoziranu temperaturu za prosledjeni datum.

    Obradu zahteva vrsi posebna nit predstavljena funkcijom f_server. Ova nit poziva metodu obradiZahtev.
    Serverska nit ceka da se pojavi odredjeni zahtev. Nakon pojave zahteva, server vrsi obradu zahteva.

    Klijent i server komuniciraju preko bufera za komunikaciju. Za svaki zahtev otvara se poseban bufer za
    upis zahteva, odnosno odgovora.
*/

#include <thread>
#include <iostream>
#include <deque>
#include <map>
#include <string>
#include <vector>

using namespace std;
using namespace chrono;


struct Kanal {
    string zahtev;
    string odgovor;
    bool zavrseno;
    condition_variable c;
    Kanal(): zavrseno(false) {}
};

struct Vreme {
    string datum;
    string temperatura;
    Vreme() {}
    Vreme(string d, string t): datum(d), temperatura(t) {}
};

class Server {
    condition_variable c_naredba;
    mutex m;
    deque<Kanal*> kanali;
    map<string, Vreme> vremenski_uslovi;
    public:
        Server(vector<Vreme> podaci) {
            for (int i = 0; i < podaci.size(); ++i)
                vremenski_uslovi[podaci[i].datum] = podaci[i];
        }
        string posaljiZahtev(string novi_zahtev) {
            unique_lock<mutex> l(m);
            Kanal* k = new Kanal();
            k->zahtev = novi_zahtev;
            kanali.push_back(k);
            c_naredba.notify_one();

            while (!k->zavrseno)
                k->c.wait(l);

            return k->odgovor;
        }
        void obradiZahtev() {
            unique_lock<mutex> l(m);
            while (kanali.empty())
                c_naredba.wait(l);

            Kanal* k = kanali.front();
            kanali.pop_front();

            k->odgovor = vremenski_uslovi[k->zahtev].temperatura;
            k->zavrseno = true;
            k->c.notify_one();
        }
};

mutex term_mx;
void f_klijent(Server& s, string zahtev, string ip) {
    {
        unique_lock<mutex> l(term_mx);
        cout << "Klijent " << ip << " salje zahtev " << zahtev << endl;
    }
    string odgovor = s.posaljiZahtev(zahtev);
    unique_lock<mutex> l(term_mx);
    cout << "Odgovor klijentu " << ip << " je " << odgovor << endl;
}

void f_server(Server& s) {
    while (true) {
        s.obradiZahtev();
    }
}
const int BROJ_KLIJENATA = 5;
int main() {
    string ips[] = {"197.100.100.0","197.100.100.1",
        "197.100.100.2", "197.100.100.3", "197.100.100.4",};

    vector<Vreme> v;
    v.push_back(Vreme("01.01.2013", "13"));
    v.push_back(Vreme("02.01.2013", "10"));
    v.push_back(Vreme("03.01.2013", "9"));
    v.push_back(Vreme("04.01.2013", "7"));
    v.push_back(Vreme("05.01.2013", "12"));

    string zahtevi[] = {"05.01.2013", "01.01.2013",
        "05.01.2013", "03.01.2013", "03.01.2013"};

    Server s(v);
    thread klijenti[BROJ_KLIJENATA];
    thread serverska_nit(f_server, ref(s));
    serverska_nit.detach();
    for (int i = 0; i < BROJ_KLIJENATA; ++i)
        klijenti[i] = thread(f_klijent, ref(s), zahtevi[i], ips[i]);

    for (int i = 0; i < BROJ_KLIJENATA; ++i)
        klijenti[i].join();
}