#define _USE_MATH_DEFINES
#include "math.h"
#include <stdlib.h>
#include <stdio.h>
#include <locale.h>
#include <time.h>
#include <stdbool.h>

#define N 15*15*2 // должно быть таким, что бы из этого числа, разделенного на два, извлекался корень
#define NHalf N / 2
#define WireWidth (int)sqrt(NHalf) // число осциляторов в строке/столбце одного слоя
//#define K 1

const double omega_rand_glial_min = 0;
const double omega_rand_glial_max = 1;

const double omega_rand_neuron_min = 3;
const double omega_rand_neuron_max = 4;

const double theta_rand_min = 0;
const double theta_rand_max = 2 * M_PI;

double A[N][N];
double omega[N];
double theta[N];
double sigma[N];

int RandomI(int min, int max)
{
	return ((double)rand() / (RAND_MAX - 1)) * (max - min) + min;
}

double RandomD(double min, double max)
{
	return ((double)rand() / RAND_MAX) * (max - min) + min;
}

double kuramoto(int i, double theta[N])
{
	double sum = 0;

	for (int j = 0; j < N; j++)
	{
		sum += A[i][j] * sin(theta[j] - theta[i]);
	}

	return omega[i] + (double)sigma[i] * sum;
}

void RungeKutta(double dt, double theta[N], double theta_next[N])
{
	double k[N][4];

	// k1
	for (int i = 0; i < N; i++)
		k[i][0] = kuramoto(i, theta) * dt;

	double theta_k1[N];
	for (int i = 0; i < N; i++)
		theta_k1[i] = theta[i] + k[i][0] / 2;

	// k2
	for (int i = 0; i < N; i++)
		k[i][1] = kuramoto(i, theta_k1) * dt;

	double theta_k2[N];
	for (int i = 0; i < N; i++)
		theta_k2[i] = theta[i] + k[i][1] / 2;

	// k3
	for (int i = 0; i < N; i++)
		k[i][2] = kuramoto(i, theta_k2) * dt;

	double theta_k3[N];
	for (int i = 0; i < N; i++)
		theta_k3[i] = theta[i] + k[i][2] / 2;

	// k4
	for (int i = 0; i < N; i++)
		k[i][3] = kuramoto(i, theta_k3) * dt;

	for (int i = 0; i < N; i++)
		theta_next[i] = theta[i] + (k[i][0] + 2 * k[i][1] + 2 * k[i][2] + k[i][3]) / 6;
}

void CopyArray(double source[N], double target[N])
{
	for (int i = 0; i < N; i++)
		target[i] = source[i];
}

bool CheckSameLine(int i, int j)
{
	return i / WireWidth == j / WireWidth;
}

bool IsWireNeighbors(int i, int j)
{
	if (CheckSameLine(i, j) && (i == j - 1 || i == j + 1))
		return true;

	if (i == j - WireWidth || i == j + WireWidth)
		return true;

	return false;
}

void FillWireMatrix()
{
	for (int i = 0; i < NHalf; i++)
	{
		for (int j = 0; j < NHalf; j++)
		{
			if (i == j)
			{
				A[i][j] = 0;
				continue;
			}

			if (i > j)
			{
				A[i][j] = A[j][i];
				continue;
			}

			A[i][j] = IsWireNeighbors(i, j) ? 1 : 0;
		}
	}
}

void FillRandomMatrix()
{
	for (int k = 0; k < N; k++)
	{
		int i, j;

		do
		{
			i = RandomI(NHalf, N);
			j = RandomI(NHalf, N);
		} while (i == j);

		A[i][j] = 1;
		A[j][i] = 1;
	}
}

void Connect(int i, int j)
{
	A[i][j] = 1;
	A[j][i] = 1;
}

void FillLayerConnectionMatrix()
{
	//int min = 0;
	//int max = NHalf;
	//int layerOffset = NHalf;

	int min = NHalf;
	int max = N;
	int layerOffset = -NHalf;

	for (int i = min; i < max; i++)
	{
		int nextLayerIndex = i + layerOffset;
		Connect(i, nextLayerIndex);

		int leftIndex = i - 1;
		if (leftIndex >= min && CheckSameLine(leftIndex, i))
			Connect(leftIndex, nextLayerIndex);

		int rightIndex = i + 1;
		if (rightIndex < max && CheckSameLine(rightIndex, i))
			Connect(rightIndex, nextLayerIndex);

		int upIndex = i - WireWidth;
		if (upIndex >= min)
			Connect(upIndex, nextLayerIndex);

		int downIndex = i + WireWidth;
		if (downIndex < max)
			Connect(downIndex, nextLayerIndex);
	}
}

int main()
{
	srand(time(NULL));

	for (int i = 0; i < N / 2; i++)
		omega[i] = RandomD(omega_rand_glial_min, omega_rand_glial_max);

	for (int i = N / 2; i < N; i++)
		omega[i] = RandomD(omega_rand_neuron_min, omega_rand_neuron_max);

	for (int i = 0; i < N / 2; i++)
		sigma[i] = 1.900;

	for (int i = N / 2; i < N; i++)
		sigma[i] = 1.900;

	for (int i = 0; i < N; i++)
		theta[i] = RandomD(theta_rand_min, theta_rand_max);

	FILE *fp0;
	fp0 = fopen("A.txt", "w+");

	FillWireMatrix();
	FillRandomMatrix();
	//FillLayerConnectionMatrix();

	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < N; j++)
		{
			/*printf("i: %d\n", i);
			printf("j: %d\n", j);
			printf("A: %d\n", A[i][j]);*/
			fprintf(fp0, "%d\t", (int)A[i][j]);
		}
		fprintf(fp0, "\n");
	}
	fclose(fp0);

	//Пишем в файл число связей у каждого осциллятора в четвертом квадранте
	FILE *fp3;
	fp3 = fopen("links.txt", "w+");
	for (int i = NHalf; i < N; i++)
	{
		int links_count = 0;
		for (int j = NHalf; j < N; j++)
		{
			if (A[i][j] == 1)
			{
				links_count++;
			}
		}
		fprintf(fp3, "%d\n", (int)links_count);

	}
	fclose(fp3);

	const double t_start = 0;
	const double t_max = 10; //2000
	const double dt = 0.05; //0.05

	double t = t_start;

	FILE *fp1;
	fp1 = fopen("omega.txt", "w+");
	for (int i = 0; i < N; i++)
	{
		fprintf(fp1, "%f\n", omega[i]);
	}
	fclose(fp1);

	FILE *fp2;
	fp2 = fopen("results.txt", "w+");
	//setlocale(LC_NUMERIC, "French_Canada.1252");

	clock_t start_rk4, end_rk4;
	start_rk4 = clock();

	while (t < t_max + dt)
	{
		fprintf(fp2, "%f\t", t);
		for (int i = 0; i < N; i++)
		{
			fprintf(fp2, i == N - 1 ? "%f" : "%f\t", theta[i]);
		}
		fprintf(fp2, "\n");

		double theta_next[N];

		RungeKutta(dt, theta, theta_next);
		CopyArray(theta_next, theta);

		t += dt;
		printf("Progress: %d%%\n", (int)(100 * (t - t_start) / (t_max - t_start)));
	}

	end_rk4 = clock();
  double extime_rk4 = (double)(end_rk4 - start_rk4) / CLOCKS_PER_SEC;
  printf("\nExecution time is %f seconds\n ", extime_rk4);


	fclose(fp2);
}