#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <ctime>
#include <vector>
#include <windows.h>
#include <queue>
#include <string>
#include <conio.h>


using namespace std;



//DO DODANIA:
// modyfikacja, zeby wartosci windy mogly byc w generowaniu ludzi (wysokosc budynku itd)
// prywatnosc
////// zatrzymanie i wznowienie windy przyciskiem
// zjazd na srodkowe pietro, gdy nie ma chetnych
// podzielenie przyciskow na dziedziczace w gore i w dol
// inzynier ktory zmienia wlasciwosci windy


void ShowConsoleCursor(bool showFlag)
{
    HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);

    CONSOLE_CURSOR_INFO     cursorInfo;

    GetConsoleCursorInfo(out, &cursorInfo);
    cursorInfo.bVisible = showFlag; // set the cursor visibility
    SetConsoleCursorInfo(out, &cursorInfo);
}


class Elevator
{
public:
    int max_weight;
    int min_floor;
    int max_floor;
    int max_ppl;

    int curr_weight;
    int curr_floor;
    int curr_ppl;
    int direction;
    Elevator();

    void check_floor();
    void load(int);                // zaladowanie ludzi ktorzy chca jechac w tym samym kierunku co winda
    void unload(int);              // wyladowanie ludzi ktorzy znajduja sie na docelowym pietrze
    void switch_floor();           // wznoszenie lub opuszczanie windy
    void check_for_ppl();          // sprawdza, czy na aktualnym pietrze sa ppl_waiting ktorzy chca jechac w tym samym kierunku co winda
    void go_to_load();             // po wyladowaniu wszystkich ludzi szuka kolejnych (z kolejki do windy)

    friend ostream& operator<< (ostream&, Elevator const&);
    friend istream& operator>> (istream&, Elevator&);
};


class People
{
public:
    int starting_floor;
    int curr_floor;
    int desired_floor;
    int weight;
    int direction;
    bool is_waiting;

    void generate_ppl(int);
    friend ostream& operator<< (ostream&, People const&);
    friend istream& operator>> (istream&, People&);
};


vector <People> ppl_waiting;
vector <People> ppl_moving;

Elevator winda;
People p;

int main(){
    srand(time(0));
    ShowConsoleCursor(false);

    clock_t TimeZero = clock();


    int ppl_generated = 0;
    double deltaTime = 0;
    double secondsToDelay = 0;
    bool exit = false;
    bool if_generate = false;
    int randomized;

    cin >> winda;
    cout << "###########################################################################################################################" << endl;
    cout << "#          INFORMACJE WSTEPNE O DZIALANIU WINDY:                                                                          #" << endl;
    cout << "#          1. Winda zaczyna z pietra 0 i porusza sie 1 pietro na sekunde.                                                 #" << endl;
    cout << "#          2. Winda nie jest sprawiedliwa! (lub moze i jest?) Gdy pojawi sie czlowiek numer 1, winda jedzie do niego.     #" << endl;
    cout << "#             natomiast gdy na jej drodze pojawi sie czlowiek numer 2, najpierw spelnia jego zadanie!                     #" << endl;
    cout << "#          3. Zasady mozliwosci wejscia do windy:                                                                         #" << endl;
    cout << "#              3.1 Winda musi miec wolne miejsce na czlowieka;                                                            #" << endl;
    cout << "#              3.2 Ciezar pasazera nie moze byc wiekszy niz wolny dopuszczalny ciezar w windzie;                          #" << endl;
    cout << "#              3.3 Czlowiek moze wsiasc do windy tylko, gdy chce jechac w tym samym kierunku co winda.                    #" << endl;
    cout << "#          4. Gdy nie ma ani ludzi w windzie, ani ludzi czekajacych na nia, winda zawsze zjedzie na pietro srodkowe.      #" << endl;
    cout << "#          5. Zatrzymaj winde LPM, a wznow ja PPM!                                                                        #" << endl;
    cout << "#          6. Wartosci windy mozna podac na poczatku programu, odkomentowujac linie 111                                   #" << endl;
    cout << "#          7. Czestotliwosc generowania ludzi mozna zmienic modyfikujac randomizer w linii 135                            #" << endl;
    cout << "#          8. Winda moze wygenerowac kilku ludzi z tej samej rodziny (beda startowac i jechac na to samo pietro)          #" << endl;
    cout << "#          9. Aby rozpoczac symulacje windy, nacisnij S!                                                                  #" << endl;
    cout << "###########################################################################################################################" << endl;


    while( getch() == 's' )
    {
        while(!exit) {
            deltaTime = (clock() - TimeZero) / CLOCKS_PER_SEC;

            if(deltaTime > secondsToDelay)
            {

                cout << "######################################################### NOWY SCREEN! #########################################################" << endl;
                randomized = rand()%101;
                if(randomized > 80)
                {
                    if(randomized >= 92)
                    {
                        p.generate_ppl(1);
                        ppl_generated = 1;
                    }
                    else if(randomized >= 85 && randomized <= 91)
                    {
                        p.generate_ppl(2);
                        ppl_generated = 2;
                    }
                    else if(randomized >= 82 && randomized <= 84)
                    {
                        p.generate_ppl(3);
                        ppl_generated = 3;
                    }
                    else if(randomized >= 80 && randomized <= 81)
                    {
                        p.generate_ppl(4);
                        ppl_generated = 4;
                    }

                    switch(ppl_generated)
                    {
                    case 1: cout << "1 nowy czlowiek wygenerowany!" << endl; break;
                    case 2: cout << "2 nowych ludzi wygenerowanych!" << endl; break;
                    case 3: cout << "3 nowych ludzi wygenerowanych!" << endl; break;
                    case 4: cout << "4 nowych ludzi wygenerowanych!" << endl; break;

                    }
                }

                cout << "~~~~~~~~~~~~~~~~~~~~~~~"  << endl;
                cout << "INFORMACJE O WINDZIE:" << endl;
                cout << "~~~~~~~~~~~~~~~~~~~~~~~"  << endl;
                cout << winda << endl;

                cout << "~~~~~~~~~~~~~~~~~~~~~~~"  << endl;
                cout << "CZEKAJACY LUDZIE:" << endl;
                cout << "~~~~~~~~~~~~~~~~~~~~~~~"  << endl;
                if(ppl_waiting.size() == 0)
                {
                    cout << "BRAK" << endl << endl;
                }
                for(int i = 0; i < ppl_waiting.size(); i++)
                {
                    cout << ppl_waiting[i] << endl;
                }
                cout << endl;
                cout << "~~~~~~~~~~~~~~~~~~~~~~~"  << endl;
                cout << "PORUSZAJACY SIE LUDZIE:" << endl;
                cout << "~~~~~~~~~~~~~~~~~~~~~~~"  << endl;
                if(ppl_moving.size() == 0)
                {
                    cout << "BRAK" << endl << endl;
                }

                for(int i = 0; i < ppl_moving.size(); i++)
                {
                    cout << ppl_moving[i] << endl;
                }
                cout << endl;

                cout <<  "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"  << endl;
                winda.check_for_ppl();
                winda.switch_floor();
                winda.check_floor();
                cout <<  "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"  << endl;
                for(int i = 0; i < 5; i++)
                    cout << endl;

                deltaTime = clock();
                TimeZero = clock();
            }
        }
    }

    return 0;
}





Elevator::Elevator()
{
    max_weight = 1000;
    min_floor = 0;
    max_floor = 10;
    max_ppl = 8;

    curr_weight = 0;
    curr_floor = 0;
    curr_ppl = 0;
    direction = 0;
}

void Elevator::check_floor()
{
    for(int i = 0; i < ppl_moving.size(); i ++)
    {
        if(ppl_moving[i].desired_floor == winda.curr_floor)
            unload(i);
    }

    for(int i = 0; i < ppl_waiting.size(); i ++)
    {
        if( i == 0 && ppl_waiting[i].curr_floor == winda.curr_floor && winda.curr_weight + ppl_waiting[i].weight <= winda.max_weight
                && winda.curr_ppl < winda.max_ppl && ppl_moving.size() == 0)
                {
                    load(i);
                    cout << "Wsiadl czlowiek w kolejce jako: " << i << endl;
                }
        else if(ppl_waiting[i].curr_floor == winda.curr_floor && winda.curr_weight + ppl_waiting[i].weight <= winda.max_weight
                && winda.curr_ppl < winda.max_ppl && winda.direction == ppl_waiting[i].direction)
                {
                    load(i);
                    cout << "Wsiadl czlowiek w kolejce jako: " << i << endl;
                }
        else
        {
            if(ppl_waiting[i].curr_floor == winda.curr_floor)
            {
                cout << "Czlowiek " << i+1 << " nie moze wsiasc do windy!";
                if(winda.direction != ppl_waiting[i].direction)
                    cout << " Jedzie nie w tym kierunku." << endl;
                else if(winda.curr_weight + ppl_waiting[i].weight <= winda.max_weight)
                    cout << " Jest za ciezki." << endl;
                else if(winda.curr_ppl < winda.max_ppl)
                    cout << " W windzie jest za duzo ludzi." << endl;
            }
        }
    }
}

void Elevator::load(int i)
{
    winda.curr_ppl ++;
    winda.curr_weight += ppl_waiting[i].weight;
    ppl_moving.push_back(ppl_waiting[i]);
    ppl_waiting.erase(ppl_waiting.begin() + i);

    cout << "Winda zabrala kolejnego pasazera. Teraz jest " << winda.curr_ppl << " ludzi i wazy " << winda.curr_weight << "kg" << endl;
}

void Elevator::unload(int i)
{
    winda.curr_ppl --;
    winda.curr_weight -= ppl_moving[i].weight;
    cout << "Hurra! Winda wyladowala pasazera. Teraz jest " << winda.curr_ppl << " ludzi i wazy " << winda.curr_weight << "kg" << endl;
    ppl_moving.erase(ppl_moving.begin() + i);
    if(ppl_waiting.size() == 0)
        winda.direction = 0;
}

void Elevator::switch_floor()
{
    if(winda.direction == 1 && winda.curr_floor != winda.max_floor)
    {
        winda.curr_floor ++;
    }
    else if(winda.direction == -1 && winda.curr_floor != winda.min_floor)
    {
        winda.curr_floor --;
    }
    cout << "Winda jest na " << winda.curr_floor << " pietrze i ";
    switch(winda.direction)
    {
        case 1: cout << "jedzie w gore." << endl; break;
        case 0: cout << "stoi w miejscu." << endl; break;
        case -1: cout << "jedzie w dol." << endl; break;
    }
}

void Elevator::check_for_ppl()
{
    if(ppl_moving.size() != 0)
    {
        if(winda.curr_floor > ppl_moving[0].desired_floor)
            winda.direction = -1;
        else
            winda.direction = 1;
    }
    else if(ppl_waiting.size() != 0)
    {
        if(winda.curr_floor > ppl_waiting[0].curr_floor)
            winda.direction = -1;
        else
            winda.direction = 1;
    }
    else if(winda.curr_floor != winda.max_floor/2)
    {
        if(winda.curr_floor > 5)
            winda.direction = -1;
        else
            winda.direction = 1;
    }
    else
        winda.direction = 0;
}


istream& operator>> (istream &wejscie, Elevator& e)
{
    cout << "Podaj ilosc pieter w windzie: ";
    wejscie >> e.max_floor;
    cout << "Podaj maksymalna ilosc ludzi w windzie: ";
    wejscie >> e.max_ppl;
    cout << "Podaj maksymalna ladownosc windy: ";
    wejscie >> e.max_weight;
    return wejscie;
}

ostream& operator<< (ostream &wyjscie, Elevator const& e)
{
    wyjscie << "Ladownosc: " << e.curr_weight << "/" << e.max_weight << endl;
    wyjscie << "Pojemnosc: " << e.curr_ppl << "/" << e.max_ppl << endl;
    wyjscie << "Pietro: " << e.curr_floor << endl;
    return wyjscie;
}

void People::generate_ppl(int x)
{
    People p;
    p.starting_floor = rand()%(winda.max_floor)+1;
    do
    {
        p.desired_floor = rand()%(winda.max_floor)+1;
    }
    while(p.desired_floor == p.starting_floor);

    p.curr_floor = p.starting_floor;
    if(p.starting_floor < p.desired_floor)
        p.direction = 1;
    else
        p.direction = -1;
    for(int i = 0; i < x; i++)
    {
        p.weight = rand()%80+40;
        ppl_waiting.push_back(p);
    }
}

istream& operator>> (istream &wejscie, People& p)
{
    cout << "Podaj wage: ";
    wejscie >> p.weight;
    cout << "Podaj startowe pietro: ";
    wejscie >> p.starting_floor;
    p.curr_floor = p.starting_floor;
    cout << "Podaj docelowe pietro: ";
    wejscie >> p.desired_floor;
    return wejscie;
}

ostream& operator<< (ostream &wyjscie, People const& p)
{
    wyjscie << "Waga: " << p.weight << endl;
    wyjscie << "Startowe pietro: " << p.starting_floor<< endl;
    //wyjscie << "Aktualne pietro: " << p.curr_floor<< endl;
    wyjscie << "Docelowe pietro: " << p.desired_floor << endl;
    return wyjscie;
}