#include <pthread.h>
#include <iostream>
#include <vector>
#include <math.h>
#include <cstdlib>
#include <Windows.h>
#include <fstream>

using namespace std;
pthread_barrier_t barr;

class Arrays//класс хранит масив
{
	vector<	vector <int>> myArray_;
	int size_;
	int maxValue_;
public:
	Arrays(int size, int val) :size_(size), maxValue_(val)
	{
		myArray_.resize(size_);
		for (int j = 0; j < size_; j++)
		{
			myArray_[j].resize(size_);
		}
	}

	void createArray()//задаем случайные значения для массива
	{
		for (int j=0; j < size_; j++)
		{
			for (int i = 0; i < size_; i++)
			{
				myArray_[j][i] = (rand()%(maxValue_+1));
			}
		}
	}

	int getElement(int i, int j)
	{
		return myArray_[i][j];
	}

	//печатаем массив
	void outArray(ostream &os)
	{
		os << "\narray\n";
		for (int i = 0; i < size_; i++)
		{
			for (int j = 0; j < size_; j++)
			{
				os << myArray_[i][j]<<" ";
			}
			os<< "\n";
		}
	}
};

struct AllArrays
{
	vector < Arrays> myArray;
	int threadQty_;
	vector <int> result;
	int size_;
	int maxValue_;

	AllArrays(int num, int size, int maxValue) :size_(size), maxValue_(maxValue),threadQty_(num)
	{
		myArray.reserve(threadQty_);
		for (int numThr = 0; numThr < threadQty_; numThr++)
		{
			myArray.push_back(Arrays(size_, maxValue_));
		}
	}


	void printAll(ostream &os)
	{
		for (int i = 0; i < threadQty_; i++)
		{
			myArray[i].outArray(os);
		}
		os << "\n";
	}

	void printResult(ostream &os)
	{
		os << "result: ";

		for (int i = 0; i < result.size(); i++)
		{
			os << result[i] << " ";
		}
		os << "\n";
	}


	void checkArray()//???????
	{
		vector<vector<int>> buff;
		buff.resize(threadQty_);
		for(int j=0;j<size_;j++)//проход по строкам
		{
			for (int i = 0; i < threadQty_; i++)//проход по массивам
			{
				buff[i].resize(size_);
				for (int k = 0; k < size_; k++)
				{
					buff[i][k] =myArray[i].getElement(j,k) ;
				}
			}

			int value;
			int checkValue;
			for (int val = 0; val < maxValue_; val++)
			{
				checkValue = 0;
				for (int l = 0; l < threadQty_; l++)
				{
					for (int h = 0; h < size_; h++)
					{
						if (val == buff[l][h])
						{
							checkValue++;
							break;
						}
					}
				}

				if (checkValue == threadQty_)
				{
					result.push_back(j);
					break;
				}
			}
		}
	}


};

struct NumArray
{
	int num_;
	AllArrays *Arrays_;
	int maxvalue_;
	NumArray(int num, AllArrays *arrays,int myRand):num_(num),Arrays_(arrays), maxvalue_(myRand)
	{}

};

void* arraythread(void* arg)
{
	NumArray &myArray = *(NumArray*)arg;
	AllArrays *ptrArray = myArray.Arrays_;
	int numThread = myArray.num_;
	srand(123 * numThread + (numThread+2) *(-12*numThread));
	ptrArray->myArray[numThread].createArray();
	pthread_barrier_wait(&barr);//1 барьер=массивы заполены значениями


	return(0);
}

int main()
{
	const int threadQty = 2;
	int maxValue = 99;
	AllArrays myArray(threadQty,10, maxValue);
	AllArrays *ptrArray = &myArray;
	pthread_t thread[threadQty];
	vector <NumArray> num;
	num.reserve(threadQty);
	pthread_barrier_init(&barr, NULL, threadQty + 1);//создаем барьер

	for (int i = 0; i < threadQty; i++)
	{
		num.push_back(NumArray(i, ptrArray, maxValue));
		pthread_create(&thread[i], NULL, arraythread, &num[i]);//запускаем потоки
	}

	pthread_barrier_wait(&barr);
	myArray.checkArray();
	myArray.printResult(cout);
	myArray.printAll(cout);

	for (int i = 0; i < threadQty; i++)
	{
		pthread_join(thread[i], NULL);//ожидаем завершения потоков
	}

	//myArray.result(cout);//печатаем результат в файлл

	system("pause");
	return 0;
}