#include <windows.h>
#include <iostream>
#include <string.h>
#include <math.h>
#include <fstream>
#include <vector>
#include <time.h>
#include <algorithm>


using namespace std;

CRITICAL_SECTION g_cs;

struct Proizvedenie {
public:
    int* x;
    int* y;
    int* z;
    int n;

    Proizvedenie() {
        n = 3;
        x = new int[n];
        y = new int[n];
        z = new int[n];
        for (int i = 0; i < n; ++i) {
            x[i] = (int)rand(); // RAND_MAX;
            y[i] = (int)rand(); // RAND_MAX;
            z[i] = (int)rand(); // RAND_MAX;
        }
    }
    ~Proizvedenie() {
        delete x;
        delete y;
        delete z;
    }
    friend ostream& operator<<(ostream& out, const Proizvedenie& myProizvedenie) {
        for (int i = 0; i < myProizvedenie.n - 1; ++i) {
            out << myProizvedenie.x[i] << " | " << myProizvedenie.y[i] << " | " << myProizvedenie.z[i] << "\t ";
        }
        out << "\t " << myProizvedenie.x[myProizvedenie.n - 1] << " | " << myProizvedenie.y[myProizvedenie.n - 1] << " | "<< myProizvedenie.y[myProizvedenie.n - 1] << "\t";
        return out;
    }

};


DWORD WINAPI proizvedenie(LPVOID arg);

struct myThread {
public:
    HANDLE handlerss;
    int solvedTasks;
    long time;
    long minT;
    long maxT;

    myThread() {
        handlerss = CreateThread(NULL, 0, proizvedenie, this, CREATE_SUSPENDED, NULL);
        if (handlerss == NULL)
            exit(GetLastError());
        solvedTasks = 0;
        time = 0;
        minT = MAXDWORD;
        maxT = -1;
    }
};

int taskCount = 100, threadCount = 13;
int thisTask = 0;
int errors = 0;
int notSol = 0;
vector<pair<Proizvedenie*, int>> tasks;

int proizvedenie(int* xp, int* yp, int* zp) // Функция вычисления
{
    int c = 0;
    int tmp[3];

    tmp[0] = xp[1] * yp[2] - xp[2] * yp[1];
    tmp[1] = xp[0] * yp[2] - xp[2] * yp[0];
    tmp[2] = xp[0] * yp[1] - xp[1] * yp[0];
    c = (tmp[0] * zp[0]) - (tmp[1] * zp[1]) + (tmp[2] * zp[2]);


    return c; // Возвращаю результат
}


DWORD WINAPI proizvedenie(LPVOID arg)
{
    myThread* thisThread = static_cast<myThread*>(arg);
    int myTask = 0;
    while (thisTask < taskCount) {
        int start = GetTickCount();
        EnterCriticalSection(&g_cs);
        if (thisTask < taskCount) {
            myTask = thisTask;
            ++thisTask;
        }
        LeaveCriticalSection(&g_cs);
        if (myTask < taskCount) {
            try {
                int* x = new int[3];
                int* y = new int[3];
                int* z = new int[3];
                int n;
                for (int i = 0; i < 3; i++) {
                    x[i] = tasks[myTask].first->x[i];
                    y[i] = tasks[myTask].first->y[i];
                    z[i] = tasks[myTask].first->z[i];
                }
                n = tasks[myTask].first->n;
                tasks.at(myTask).second = proizvedenie(x, y, z);
                thisThread->solvedTasks++;
            }
            catch (...) {
                tasks[myTask].second = INFINITE;
                errors++;
            }
            int end = GetTickCount();
            int taskT = abs(end - start);

            thisThread->time += taskT;
            if (thisThread->maxT < taskT)
                thisThread->maxT = taskT;
            if (thisThread->minT > taskT)
                thisThread->minT = taskT;

        }
    }
    return 0;
}


int main()
{
    system("color 0f");
    setlocale(LC_ALL, "Russian");
    cout << "Количество задач = ";
    cin >> taskCount;
    cout << "Количкство процессов = ";
    cin >> threadCount;
    for (int i = 0; i<taskCount; ++i) {
        tasks.push_back(*(new pair<Proizvedenie*, int>(new Proizvedenie(), INFINITE)));
    }

    myThread** proces = new myThread*[threadCount];
    HANDLE* handlersss = new HANDLE[threadCount];
    InitializeCriticalSection(&g_cs);
    for (int i = 0; i < threadCount; ++i) {
        proces[i] = new myThread();
        handlersss[i] = proces[i]->handlerss;
    }
    for (int i = 0; i < threadCount; ++i) {
        ResumeThread(handlersss[i]);
    }
    WaitForMultipleObjects(threadCount, handlersss, true, INFINITE);
    Sleep(100);
    for (int i = 0; i < threadCount; ++i) {
        CloseHandle(handlersss[i]);
    }
    DeleteCriticalSection(&g_cs);
    ofstream out("output.txt");
    int start = GetTickCount();
    for (int i = 0; i < taskCount; ++i) {
        out << *tasks.at(i).first << "\tОтвет: = ";
        if (tasks.at(i).second == INFINITE)
            out << "Ошибка" << endl;
        else
            out << tasks.at(i).second << endl;
    }
    int end = GetTickCount();
    out.close();
    int time = end - start;

    cout << "Решенных задач:\t" << taskCount - (errors + notSol) << endl;
    cout << "Количество задач, у которых нет решения :\t" << notSol << endl;
    cout << "Количество задач, у которых возникла ошибка при вычислении:\t" << errors << endl;

    cout << endl;
    cout << "Статистика для каждого потока:" << endl;
    cout << "Номер\t" << "Задач выполнено\t" << "Затреченное время\t" << "Минимальное\t" << "Максимальное" << endl;
    for (int i = 0; i < threadCount; ++i) {
        if (proces[i]->minT == MAXDWORD)
            proces[i]->minT = 0;
        if (proces[i]->maxT == -1)
            proces[i]->maxT = 0;
        cout << i + 1 << "\t" << proces[i]->solvedTasks << "\t\t" << proces[i]->time << "\t\t\t" << proces[i]->minT << "\t\t" << proces[i]->maxT << endl;
    }

    cout << endl;

    cout << "Время, потраченное на решение вех задач и запись данных в файл: " << time << " милисекунд" << endl;
    system("pause");
    return 0;
}