#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <thread>
#include <ctime>
#include <cstdlib>
#include <mutex>
#include <atomic>
#include <iomanip>
#include <fstream>

using namespace std;

/*
Zad.1 - Zegar
Stwórz klasę zawierającą zmienną typu time_t oraz operator(),
w którym zostanie umieszona nieskończona pętla przedstawiająca czas w konsoli.
Następnie stwórz wątek z tą klasą jako parametrem.
*/


class T
{
    time_t czas;
public:
    void operator()()
    {
        time(&czas);
        while (1)
        {
            cout << ctime(&czas);
            this_thread::sleep_for(chrono::milliseconds(100));
            time(&czas);
            system("cls");
        }
    }
};


/*
Zad.2 - ID watku na przemian
Stwórz funkcje z parametrem n tworzącą dwa wątki. Dany wątek ma wypisywać własne id.
Oba wątki mają być wykonywane naprzemiennie z wykorzystaniem globalnej zmiennej typu bool.
*/

bool _switch = true;
void thread1(int n)
{
    thread::id this_id = this_thread::get_id();
    for (int i = 0; i < n; i++)
    {
        while (!_switch)
            this_thread::yield();
        cout << "something... by " << this_id << " thread" << endl;
        _switch = false;
    }
}
void thread2(int n)
{
    thread::id this_id = this_thread::get_id();
    for (int i = 0; i < n; i++)
    {
        while (_switch)
            this_thread::yield();
        cout << "something... by " << this_id << " thread" << endl;
        _switch = true;
    }
}
void sync(const int n)
{
    thread t1(thread1, n);
    thread t2(thread2, n);
    t1.join();
    t2.join();
}

/*
Zad. 3 - Dostep do pliku z uzyciem mutexu
Utworz dwie funkcje dzialajace na dwoch osobnych watkach, ktore na przemian wpisuja do tego samwgo pliku ciag liczb od 0 do 10.
Do synchronizacji wykorzystaj zmienna typu mutex oraz funkcje this_thread::sleep_for(chrono::milliseconds()).
*/

mutex mtx;
fstream file;
void foo_one()
{
    for (int i = 0; i < 10; i++)
    {
        mtx.lock();
        file.open("data.txt", ios::app | ios::in);
        if (file.is_open())
        {
            file << "foo_one: " << i << endl;
        }
        file.close();
        mtx.unlock();
        this_thread::sleep_for(chrono::milliseconds(250));
    }
}

void foo_two()
{
    for (int i = 0; i < 10; i++)
    {
        mtx.lock();
        file.open("data.txt", ios::app | ios::in);
        if (file.is_open())
        {
            file << "foo_two: " << i << endl;
        }
        file.close();
        mtx.unlock();
        this_thread::sleep_for(std::chrono::milliseconds(250));
    }
}

/*
Zad. 4 - "Przeciaganie liny" miedzy watkami
Zadeklaruj globalna zmienna int X, zainicjalizuj ja wartoscia 50. Zadeklaruj globalna zmienna atomowa typu int, zainicjuj ja 0.
Utworz dwie funkcje, ktore dzialaja na dwoch roznych watkach. Maja one dodawac lub odejmowac (na zmiane!) od X
losowa liczbe z przedzialu <1,10> - tak dlugo, jak wartosc X znajduje sie w przedziale (0,100).
Dodawana lub odejmowana liczba powinna byc zmienna atomowa, ktorej aktualna wartosc jest losowana w kazdym z watkow za pomoca funkcji rand().
*/


int X = 50;
atomic<int> random = 0;
bool flag = true;

void dodawaj()
{
    thread::id this_id = this_thread::get_id();
    while (X > 0 && X < 100)
    {
        random = (1 + (rand() % 10));
        if (flag == true)
        {
            this_thread::sleep_for(std::chrono::milliseconds(100));
            X += random;
            cout << "Thread #" << this_id << "\tpoints: " << X << endl;
            flag = false;
        }
        else
            this_thread::yield();
    }

}

void odejmuj()
{
    thread::id this_id = this_thread::get_id();
    while (X > 0 && X < 100)
    {
        random = (1 + (rand() % 10));
        if (flag == false)
        {
            this_thread::sleep_for(std::chrono::milliseconds(100));
            X -= random;
            cout << "Thread #" << this_id << "\tpoints: " << X << endl;
            flag = true;
        }
        else
            this_thread::yield();
    }
}

int main()
{
    /// zadanie 1
    //T clock;

    //thread t(clock);
    //t.join();

    /// zadanie 2
    //sync(5);

    /// zadanie 3
    //thread thread_1(foo_one);
    //thread thread_2(foo_two);
    //thread_1.join();
    //thread_2.join();

    /// zadanie 4
    //srand(time(NULL));

    //thread t41(dodawaj);
    //thread t42(odejmuj);
    //t41.join();
    //t42.join();

    system("pause");
    return 0;
}