#include <math.h>
#include <stdio.h>
#include <progbase.h>
#include <progbase/console.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <stdbool.h>
#include <assert.h>
#include <time.h>

#define N 10

typedef struct PlanetInfo
{
	float orb_radius;
	float period_rotate;
} PlanetInfo;

typedef struct PlanetWithSputnik
{
	char Name[30];
	int sputnik_count;
	float mass;
}PlanetWithSputnik;

typedef struct Planet
{

	char Name[30];
	int sputnik_count;
	float mass;
	PlanetInfo add_info;
} Planet;

void PlanetToString(Planet *planet, char buf[200]);
void StringToPlanet(char buf[200], Planet *planet);
void PlanetArrayToString(Planet **planet, char buf[500]);
void StringToPlanetArray(char buf[500], Planet **planet);
int ArrSize(Planet **arr);
void RemoveAt(Planet **planet, int i);
void ReplaceAt(Planet **planet, int i, Planet *src);
void SetValue(Planet *p, char field[50], char value[50]);
void PlanetsSputnikCountLessX(Planet **&planets, int x);
void TestPlanetToString();      //done
void TestStringToPlanet();      //done
void TestPlanetArrayToString(); // done
void TestStringToPlanetArray(); //done
void TestRemoveAt();            // done
void TestReplaceAt();           //done
void TestSetValue();            //done
void Testing();
void LoadFromFile(char *filename, Planet **planets);
void SaveToFile(char *filename, Planet **planets);
void Action();
void Menu();
void ActMenu(Planet **planets, int c, Planet **planets2);
void AddUserPlanet(Planet **planets);
void RemoveUserPlanet(Planet **planets);
void ReplaceUserPlanet(Planet **planets);
void PrintPlanets(Planet **planets);
void ReplaceField(Planet **planets);
void FindPlanets(Planet **planets, Planet** planets2);
void SavePlanetsToFile(Planet **planets);

int main(int argc, char *argv[])
{
	if (argv[1] == NULL)
		Action();
	else if (strcmp(argv[1], "-t") == 0)
		Testing();
	else

		return 0;
}

void PlanetsSputnikCountLessX(Planet **&planets, int x)
{
	int k = 0;

		for (int i = 0; i < ArrSize(planets); i++)
			if (planets[i]->sputnik_count < x)
				k++;
		Planet ** planet2 = malloc(sizeof(Planet)*k);

		k = 0;
		for (int i = 0; i < ArrSize(planets); i++)
			if (planets[i]->sputnik_count < x)
				planet2[k++] = planets[i];

		for (int i = 0; i < ArrSize(planets); i++)
			if (planets[i] != NULL)
				free(planets[i]);

		planets = planet2;
	// puts("Press any key...");
	// getchar();
}

void Testing()
{
	void TestPlanetToString();
	void TestStringToPlanet();
	void TestPlanetArrayToString();
	void TestStringToPlanetArray();
	void TestRemoveAt();
	void TestReplaceAt();
	void TestSetValue();
}

void FindPlanets(Planet **planets, Planet** planets2)
{

	int x;
	Planet * planet1[10];
	printf("Input count of sattelites: ");
	scanf("%d", &x);
	getchar();
	PrintPlanetsSputnikCountLessX(planets, x, planet1);
}

void ReplaceField(Planet **planets)
{
	int i;
	printf("Input index of planet for field to replace: ");
	scanf("%d", &i);
	if (planets[i] == NULL || (i < 0) || (i >= N))
	{
		printf("Error input!");
		return;
	}

	char field[50];
	char newvalue[50];
	printf("Input field name: ");
	scanf("%s", field);
	printf("Input field value: ");
	scanf("%s", newvalue);

	SetValue(planets[i], field, newvalue);
}

void SavePlanetsToFile(Planet **planets)
{
	char filename[50];
	printf("Input file name: ");
	scanf("%s", filename);
	SaveToFile(filename, planets);
}
void ReplaceUserPlanet(Planet **planets)
{
	int i;
	printf("Input index of planet to replace: ");
	scanf("%d", &i);
	if (planets[i] == NULL || (i < 0) || (i >= N))
	{
		printf("Error input!");
		return;
	}

	printf("Input planet's name: ");
	scanf("%s", planets[i]->Name);
	printf("Input planet's sattelite count: ");
	scanf("%d", &planets[i]->sputnik_count);
	printf("Input planet's mass: ");
	scanf("%f", &planets[i]->mass);
	printf("Input planet's orb radius: ");
	scanf("%f", &planets[i]->add_info.orb_radius);
	printf("Input planet's period rotate: ");
	scanf("%f", &planets[i]->add_info.period_rotate);
}
void RemoveUserPlanet(Planet **planets)
{
	int i;
	printf("Input index of planet to delete: ");
	scanf("%d", &i);
	if (planets[i] == NULL || (i < 0) || (i >= N))
	{
		printf("Error input!\n");
		return;
	}

	RemoveAt(planets, i);
}

void AddUserPlanet(Planet **planets)
{
	int len = ArrSize(planets);
	if (len > N - 1)
	{
		printf("List if full!");
		return;
	}

	planets[len] = malloc(sizeof(Planet));

	printf("Input planet's name: ");
	scanf("%s", planets[len]->Name);
	getchar();
	int flag = true;
	printf("Input planet's sattelite count: ");
	do
	{
		flag = true;
		char a[20];
		fgets(a, 20, stdin);
		a[strlen(a) - 1] = '\0';
		int size = strlen(a);
		for (int i = 0; i < size; i++)
		{
			if (!isdigit(a[i]))
				flag = false;
		}
		if (flag && atoi(a) >= 0)
		{
			planets[len]->sputnik_count = atoi(a);
		}
		else
			flag = false;

	} while (!flag);
	printf("Input planet's mass: ");
	do
	{
		flag = true;
		char a[20];
		fgets(a, 20, stdin);
		a[strlen(a) - 1] = '\0';
		int size = strlen(a);
		for (int i = 0; i < size; i++)
		{
			if (!isdigit(a[i]) && a[i] != '.')
				flag = false;
		}
		if (flag && atof(a) >= 0)
		{
			planets[len]->mass = atof(a);
		}
		else
			flag = false;

	} while (!flag);
	printf("Input planet's orb radius: ");
	do
	{
		flag = true;
		char a[20];
		fgets(a, 20, stdin);
		a[strlen(a) - 1] = '\0';
		int size = strlen(a);
		for (int i = 0; i < size; i++)
		{
			if (!isdigit(a[i]) && a[i] != '.')
				flag = false;
		}
		if (flag && atof(a) >= 0)
		{
			planets[len]->add_info.orb_radius = atof(a);
		}
		else
			flag = false;

	} while (!flag);
	printf("Input planet's period rotate: ");
	do
	{
		flag = true;
		char a[20];
		fgets(a, 20, stdin);
		a[strlen(a) - 1] = '\0';
		int size = strlen(a);
		for (int i = 0; i < size; i++)
		{
			if (!isdigit(a[i]) && a[i] != '.')
				flag = false;
		}
		if (flag && atof(a) >= 0)
		{
			planets[len]->add_info.period_rotate = atof(a);
		}
		else
			flag = false;

	} while (!flag);
}
void Action()
{
	Planet *planets[N] = { NULL };
	Planet *planets2[N] = { NULL };
	int choise = 0;
	do
	{
		Console_clear();
		puts("1. Create empty list of planets\n2. Load planets from file\n3. Exit\nWaiting fot input...");
		scanf("%i", &choise);

		switch (choise)
		{
		case 2:
		{
			Console_clear();
			char filename[100] = "";
			puts("Input file name: ");
			scanf("%s", filename);
			getchar();
			LoadFromFile(filename, planets);
		}
		case 1:
		{
			do
			{
				Console_clear();
				PrintPlanets(planets);
				Menu();
				scanf("%i", &choise);
				getchar();
				ActMenu(planets, choise, planets2);
			} while (choise != 0);
			break;
		}
		case 3:
			Console_clear();
			puts("Bye bye...");
			sleepMillis(1500);
			choise = 3;
			break;
		default:
			break;
		}
	} while (choise != 3);
	Console_clear();
	for (int i = 0; i < ArrSize(planets); i++)
		free(planets[i]);
}

void ActMenu(Planet **planets, int c, Planet **planets2)
{
	switch (c)
	{
	case 1:
		Console_clear();
		AddUserPlanet(planets);
		Console_clear();
		break;
	case 2:
		Console_clear();
		RemoveUserPlanet(planets);
		Console_clear();
		break;
	case 3:
		Console_clear();
		ReplaceUserPlanet(planets);
		Console_clear();
		break;
	case 4:
		Console_clear();
		ReplaceField(planets);
		Console_clear();
		break;
	case 5:
		// Planet **planets2;
		Console_clear();

		FindPlanets(planets, planets2);
		Console_clear();
		break;
	case 6:
		Console_clear();
		SavePlanetsToFile(planets);
		Console_clear();


		break;
	case 7:
		PrintPlanets(planets2);
		break;
	default:
		break;
	}
}
void PrintPlanets(Planet **planets)
{
	if (ArrSize(planets) != 0)
	{
		puts("Your list\n-------------------------------------------");
		for (int i = 0; i < ArrSize(planets); i++)
			printf("(Planet %i)\n Name: %s Sattelites: %i Mass: %.2f Radius: %.2f Period: %.2f\n", i, planets[i]->Name, planets[i]->sputnik_count, planets[i]->mass,
				planets[i]->add_info.orb_radius, planets[i]->add_info.period_rotate);
		puts("-------------------------------------------");
	}
	else
		puts("This list is empty");
}
void Menu()
{
	printf("1. Add new planet\n");
	printf("2. Remove planet at index\n");
	printf("3. Edit planet at index\n");
	printf("4. Edit planet field at index\n");
	printf("5.  planet sattelites count less than X\n");
	printf("6. Save To File\n");
	printf("0. Exit\n");
	printf("7. Print planet sattelites count less than X\n");
}
void SaveToFile(char *filename, Planet **planets)
{
	FILE *f = fopen(filename, "w");

	char buf[200];
	for (int i = 0; i < ArrSize(planets); i++)
	{
		PlanetToString(planets[i], buf);
		fputs(buf, f);
	}

	fclose(f);
}

void LoadFromFile(char *filename, Planet **planets)
{

	FILE *f = fopen(filename, "r");

	if (f == 0)
		return;
	int count_planets_in_file = 0;
	char buf[200];
	while (fgets(buf, 200, f))
		count_planets_in_file++;
	rewind(f);

	for (int i = 0; i < count_planets_in_file; i++)
		planets[i] = malloc(sizeof(Planet));

	int i = 0;
	while (fgets(buf, 200, f))
	{
		StringToPlanet(buf, planets[i]);
		i++;
	}

	fclose(f);
}

void TestSetValue()
{
	Planet *planets[N] = { NULL };

	char buf[500] = "Venera;8;4.50;14.60;13.00\nMars;8;6.50;14.60;13.00\n";
	StringToPlanetArray(buf, planets);

	SetValue(planets[0], "Name", "Venera-12");
	SetValue(planets[1], "sputnik_count", "5");
	assert(strcmp(planets[0]->Name, "Venera-12") == 0);
	assert(planets[1]->sputnik_count == 5);

	free(planets[0]);
	free(planets[1]);
}

void TestReplaceAt()
{
	Planet *planets[N] = { NULL };
	planets[0] = malloc(sizeof(Planet));
	planets[1] = malloc(sizeof(Planet));
	char buf[500] = "Venera;8;4.50;14.60;13.00\nMars;8;6.50;14.60;13.00\n";
	StringToPlanetArray(buf, planets);

	Planet p = { "Neptun", 9, 8.5,{ 24.6, 23.0 } };

	ReplaceAt(planets, 1, &p);

	assert(strcmp(planets[1]->Name, "Neptun") == 0);
	assert(planets[1]->sputnik_count == 9);
	free(planets[0]);
	free(planets[1]);
}

void TestRemoveAt()
{
	Planet *planets[N] = { NULL };
	planets[0] = malloc(sizeof(Planet));
	planets[1] = malloc(sizeof(Planet));
	planets[2] = malloc(sizeof(Planet));
	char buf[500] = "Venera;8;4.50;14.60;13.00\nMars;8;6.50;14.60;13.00\nNeptun;9;8.50;24.60;23.00\n";
	StringToPlanetArray(buf, planets);
	RemoveAt(planets, 1);
	assert(strcmp(planets[1]->Name, "Neptun") == 0);

	free(planets[0]);
	free(planets[1]);
}
void TestPlanetArrayToString()
{
	Planet *planets[N] = { NULL };
	planets[0] = malloc(sizeof(Planet));
	planets[1] = malloc(sizeof(Planet));
	planets[2] = malloc(sizeof(Planet));
	strcpy(planets[0]->Name, "Venera");
	strcpy(planets[1]->Name, "Mars");
	strcpy(planets[2]->Name, "Neptun");
	planets[0]->mass = 4.5;
	planets[0]->sputnik_count = 8;
	planets[0]->add_info.orb_radius = 14.6;
	planets[0]->add_info.period_rotate = 13;

	planets[1]->mass = 6.5;
	planets[1]->sputnik_count = 8;
	planets[1]->add_info.orb_radius = 14.6;
	planets[1]->add_info.period_rotate = 13;

	planets[2]->mass = 8.5;
	planets[2]->sputnik_count = 9;
	planets[2]->add_info.orb_radius = 24.6;
	planets[2]->add_info.period_rotate = 23;

	//s;fsdsdsd
	char buf[500] = "";
	PlanetArrayToString(planets, buf);

	assert(strcmp(buf, "Venera;8;4.50;14.60;13.00\nMars;8;6.50;14.60;13.00\nNeptun;9;8.50;24.60;23.00\n") == 0);

	free(planets[0]);
	free(planets[1]);
	free(planets[2]);
}

void TestStringToPlanetArray()
{
	Planet *planets[N] = { NULL };

	char buf[500] = "";

	strcpy(buf, "Venera;8;4.50;14.60;13.00\nMars;8;6.50;14.60;13.00\nNeptun;9;8.50;24.60;23.00\n");
	StringToPlanetArray(buf, planets);

	assert(planets[0]->sputnik_count == 8);
	assert(strcmp(planets[1]->Name, "Mars") == 0);
	assert(planets[2]->add_info.period_rotate == 23.0);

	free(planets[0]);
	free(planets[1]);
	free(planets[2]);
}

void TestStringToPlanet()
{
	char buf[100];
	Planet *p = malloc(sizeof(Planet));
	strcpy(buf, "Venera;10;5.60;3.20;16.00\n");
	StringToPlanet(buf, p);
	//-----------------
	strcpy(buf, "Venera;10;5.60;3.20;16.00\n");
	StringToPlanet(buf, p);
	assert(p->sputnik_count == 10);
	//------------

	free(p);
}

void TestPlanetToString()
{
	Planet *p = malloc(sizeof(Planet));
	p->mass = 5.6;
	strcpy(p->Name, "Venera");
	p->sputnik_count = 10;
	p->add_info.orb_radius = 3.2;
	p->add_info.period_rotate = 16;

	char str[100];
	PlanetToString(p, str);
	assert(strcmp("Venera;10;5.60;3.20;16.00\n", str) == 0);
	free(p);
	//------------------------
	p = malloc(sizeof(Planet));
	p->mass = 125.6;
	strcpy(p->Name, "Mars");
	p->sputnik_count = 10;
	p->add_info.orb_radius = 3.2;
	p->add_info.period_rotate = 16;
	PlanetToString(p, str);
	assert(strcmp("Venera;10;5.125.60;3.20;16.00\n", str) == 0);
	free(p);
	//------------------------

	p = malloc(sizeof(Planet));
	p->mass = 125.6;
	strcpy(p->Name, "Neptun");
	p->sputnik_count = 5;
	p->add_info.orb_radius = 3.8;
	p->add_info.period_rotate = 26;
	PlanetToString(p, str);
	assert(strcmp("Venera;10;5.125.60;3.20;16.00\n", str) == 0);
	free(p);

	p = malloc(sizeof(Planet));
	p->mass = 125.6;
	strcpy(p->Name, "Pluton");
	p->sputnik_count = 8;
	p->add_info.orb_radius = 5.9;
	p->add_info.period_rotate = 45;
	PlanetToString(p, str);
	assert(strcmp("Venera;10;5.125.60;3.20;16.00\n", str) == 0); //?
	free(p);
}

void SetValue(Planet *p, char field[50], char value[50])
{
	if (strcmp(field, "Name") == 0)
		strcpy(p->Name, value);
	else if (strcmp(field, "sputnik_count") == 0)
		sscanf(value, "%d", &p->sputnik_count);
	else if (strcmp(field, "mass") == 0)
		sscanf(value, "%f", &p->mass);
	else if (strcmp(field, "orb_radius") == 0)
		sscanf(value, "%f", &p->add_info.orb_radius);
	else if (strcmp(field, "period_rotate") == 0)
		sscanf(value, "%f", &p->add_info.period_rotate);
}

void PlanetArrayToString(Planet **planet, char buf[500])
{
	int len = 0;
	while (planet[len] != NULL)
		++len;

	for (int i = 0; i < len; i++)
	{
		char str[100] = "";

		PlanetToString(planet[i], str);
		strcat(buf, str);
	}
}



void ReplaceAt(Planet **planet, int i, Planet *src)
{
	if ((planet[i] == NULL) || (i < 0) || (i > ArrSize(planet)))
		return;

	*planet[i] = *src;
}

void StringToPlanetArray(char buf[500], Planet **planet)
{

	int pcount = 0;
	for (int i = 0; i < strlen(buf); i++)
		if (buf[i] == '\n')
			pcount++;
	char *oneplanet = strtok(buf, "\n");
	for (int i = 0; i < pcount; i++)
	{
		Planet *p = malloc(sizeof(Planet));
		StringToPlanet(oneplanet, p);
		planet[i] = p;
		oneplanet = strtok(NULL, "\n");
	}
}

void PlanetToString(Planet *planet, char buf[200])
{

	sprintf(buf, "%s;%i;%.2f;%.2f;%.2f\n", planet->Name, planet->sputnik_count, planet->mass,
		planet->add_info.orb_radius, planet->add_info.period_rotate);
}

void StringToPlanet(char buf[200], Planet *planet)
{

	sscanf(buf, "%[^;];%i;%f;%f;%f", planet->Name, &planet->sputnik_count, &planet->mass,
		&planet->add_info.orb_radius, &planet->add_info.period_rotate);
}

int ArrSize(Planet **planets)
{
	int len = 0;

	while (planets[len] != NULL)
		++len;

	return len;
}

void RemoveAt(Planet **planet, int i)
{

	if ((planet[i] == NULL) || (i < 0) || (i > ArrSize(planet)))
		return;

	Planet *temp = planet[i];
	for (int j = i + 1; j <= ArrSize(planet); j++)
		planet[j - 1] = planet[j];

	free(temp);

}