#include<omp.h>
#include<stdio.h>
#include <bits/stdc++.h>
#include <list>
#include <string>

using namespace std;
int *primz = 0;
int *nearPerfect = 0;
int g_d = 0;
int changedGlobal = 10;
//Code für primzahlberechnung aus dem Internet
void SieveOfEratosthenes(int num1, int num2) {
	bool pno[num2 + 1];
	memset(pno, true, sizeof(pno));
	for (int i = num1; i * i <= num2; i++) {
		if (pno[i] == true) {
			for (int j = i * 2; j <= num2; j += i)
				pno[j] = false;
		}
	}
	g_d = 0;
	for (int i = num1; i <= num2; i++) {
		if (pno[i])
			g_d++;
	}

	printf("%d: jo\n", g_d);
	primz = new int[g_d];
	printf("%d: jo\n", g_d);
	g_d = 0;
	for (int i = num1; i <= num2; i++) {
		if (pno[i]) {
			primz[g_d] = i;
			g_d++;
		}

	}
#pragma omp critical
	{
		changedGlobal = g_d;
	}

	printf("%d:DDDDDDDDDDDDDd \n", g_d);
}
int main(int argc, char* argv[]) {
	nearPerfect = new int[30000000]();  //automatisch mit 0 gefüllt
	int id;
	int counter = 1;  //array an stelle 0 wird nicht belegt
	int changeCounter = 0;
	int counterGive = 1;
	int counterRightSequence = 1;
	omp_set_num_threads(32);
	bool running = true;
	bool startBool = false;
#pragma omp parallel private(id)shared(changedGlobal)
	{
		bool change = false;
		int *primz2 = 0;
		int internGlobal = 0;
		int t = 0;
		int z = 0;
		bool bool3 = true;
		bool calculation = true;
		list<int> mylist;
		id = omp_get_thread_num();
		if (id == 0) {

			double start, end;
			start = omp_get_wtime();
			SieveOfEratosthenes(2, 100000);
			end = omp_get_wtime();
			printf("%f:30sekstart\n", end - start);
			printf("%d:30sekend\n", end);

#pragma omp critical
			{
				startBool = true;
			}

			while (changeCounter != 30) {
			}
			delete primz; //freed memory
			primz = NULL;
			SieveOfEratosthenes(2, 1000000);
			changedGlobal = g_d;
#pragma omp flush(changedGlobal)

			while (changeCounter != 60) {
			}
			delete primz; //freed memory
			primz = NULL;
			SieveOfEratosthenes(2, 2000000);
			changedGlobal = g_d;
#pragma omp flush(changedGlobal)

			printf("%d:ajajajjajaejeajea\n", end);

			startBool = true;
#pragma omp flush(startBool)
			while (running) {

			}
			printf("Thread %d verabschiedet sich \n", id);
			//	SieveOfEratosthenes(2,100000);

		} else if (id == 1) {

			double start, end;
			start = omp_get_wtime();
			printf("%d:30sek\n", start);
			while ((end - start) < 30.0f) {
				end = omp_get_wtime();
			}
#pragma omp atomic write
			running = false;

// #pragma omp atomic write slow
			startBool = false;
#pragma omp flush (startBool)

			printf("Thread %d verabschiedet sich \n", id);
		}

		else {
			while (running) {

				while (startBool) {
#pragma omp critical (hshs)
					{
						t = counterGive;
						counterGive++;

					}
					if (changedGlobal != internGlobal) {
						change = false;
					}

					if (!change) {
#pragma omp critical (hs)
						{
								primz2 = new int[g_d]; //schleife für größe des arrays
							for (int i = 0; i < g_d; i++) {
								primz2[i] = primz[i];
							}
							change = true;
							internGlobal = g_d;
							printf("%d   %d:internGlobal\n", internGlobal,
									changeCounter);
							changeCounter++;

						}

					}

					mylist.clear();
					calculation = true;
					z = -1;

					if (t >= 30000000) {
						startBool = false;
					}

					while (calculation) {
						// eine eins am ende noch addieren
						//wenn wir mehr zahlen als array elemente haben....
						z++;

						//nimmt sich die
						int arrVar = primz2[z];
						if (arrVar < (t / 2) + 1) {  //size of array

						} else {
							calculation = false;
						}

						if (t % arrVar == 0) {
							mylist.push_back(arrVar);
							int c = 2;
							bool3 = true;
							while (bool3) {
								if (arrVar * c >= (t / 2) + 1) {
									bool3 = false;
								} else if (t % (arrVar * c) == 0) {
									mylist.push_back(arrVar * c);
								}

								c++;
							}
						}

					}

					mylist.sort();
					mylist.unique();

					int erg = 1;
					for (auto v : mylist) {
						erg = erg + v;
					}
					int op = t - erg;
					if (op <= 0) {
						op = op * -1;
					}

#pragma omp critical (gff)
					{
						if (op <= 8) {
							nearPerfect[t] += t;
						} else {

							nearPerfect[t] += 1;
						}
					}

#pragma omp critical (aaaa)
					{
						if (nearPerfect[counter] == 0) {
						} else if (nearPerfect[counter] == 1) {
							counter++;
						} else {
							std::cout << counter << " counter\n";
							counter++;
						}
						if (nearPerfect[counter] == 0) {

						} else if (nearPerfect[counter] == 1) {
							counter++;
						} else {
							std::cout << counter << " counter\n";
							counter++;
						}
					}

				}


			}
			printf("Thread %d verabschiedet sich \n", id);
		}

	}

	cout << counter << " counter";
	cout << counterGive << " counterGive";
	printf("Countermenge %d\n", changeCounter);
	return 0;
}