#include "dane.h"
#include "struktury.h"
#include <stdlib.h>
#include <stdio.h>


void CzyscEkran()
{
	//system("clear"); //linux
	system("cls"); //windows
}

void ZamienZnak(char str[], char znakZ, char znakNa)
{
	int i;

	for (i = 0; i < strlen(str); ++i) 
		if (str[i] == znakZ) str[i] = znakNa;
}


//Wczytuje bazê danych z pliku
void WczytajDane()
{
	FILE *Plik;
	int i;
	struct ZlecenieStruct *zlecenie = NULL, *zleceniePoprzednie = NULL;
	struct FirmaStruct *firma = NULL, *firmaPoprzednie = NULL;
	char nazwaZlecenia[MaksDlugoscNazwyZlecenia];
	char nazwaFirmy[MaksDlugoscNazwyFirmy];
	

	listaFirm = NULL;
	listaZlecen = NULL;
	
	if ((Plik = fopen(NazwaPlikuZlecenia, "r")) != NULL)
	{
		while(fscanf(Plik, "%s",
				nazwaZlecenia) != EOF)
		{
			zlecenie = malloc(sizeof(struct ZlecenieStruct));
			ZamienZnak(nazwaZlecenia, '_', ' ');
			strcpy(zlecenie->nazwa, nazwaZlecenia);
			zlecenie->nastepny = NULL;
			if (zleceniePoprzednie != NULL)
				zleceniePoprzednie->nastepny = zlecenie;
			else
				listaZlecen = zlecenie;
			zleceniePoprzednie = zlecenie;
		}
		fclose(Plik);
	}
	ostatnieZlecenieNaLiscie = zlecenie;

	if ((Plik = fopen(NazwaPlikuFirmy, "r")) != NULL)
	{
		while(fscanf(Plik, "%s", nazwaFirmy) != EOF)
		{
			firma = malloc(sizeof(struct FirmaStruct));
			ZamienZnak(nazwaFirmy, '_', ' ');
			strcpy(firma->nazwa, nazwaFirmy);
			for (i = 0; i < IloscDniWHistorii; ++i)
				fscanf(Plik, "%d", &(firma->historia[i])); 	
			firma->nastepny = NULL;
			if (firmaPoprzednie != NULL)
				firmaPoprzednie->nastepny = firma;
			else
				listaFirm = firma;
			firmaPoprzednie = firma;
		}
		fclose(Plik);
	}
	ostatniaFirmaNaLiscie = firma;
}

//Zwalnianie pami?i zajmowanej przez listy
void ZwolnijPamiec()
{
	struct ZlecenieStruct *zlecenie;
	struct FirmaStruct *firma;

	zlecenie = listaZlecen;
	if (listaZlecen != NULL) listaZlecen = listaZlecen->nastepny;
	while (zlecenie != NULL)
	{
		free(zlecenie);
		zlecenie = listaZlecen;
		if (listaZlecen != NULL) listaZlecen = listaZlecen->nastepny;
	}

	firma = listaFirm;
	if (listaFirm != NULL) listaFirm = listaFirm->nastepny;
	while (firma != NULL)
	{
		free(firma);
		firma = listaFirm;
		if (listaFirm != NULL) listaFirm = listaFirm->nastepny;
	}
}

//Zapisuje bazê danych i kasuje ja z pamiêci
void ZapiszDane()
{
	struct ZlecenieStruct *zlecenie;
	struct FirmaStruct *firma;
	FILE *Plik;
	int i;

	if ((Plik = fopen(NazwaPlikuZlecenia, "w")) != NULL)
	{
		zlecenie = listaZlecen;
		while (zlecenie != NULL)
		{
			ZamienZnak(zlecenie->nazwa, ' ', '_');
			fprintf(Plik, "%s ",
				zlecenie->nazwa);
			zlecenie = zlecenie->nastepny;
		}
		fclose(Plik);
	}
	if ((Plik = fopen(NazwaPlikuFirmy, "w")) != NULL)
	{
		firma = listaFirm;
		while (firma != NULL)
		{
			ZamienZnak(firma->nazwa, ' ', '_');
			fprintf(Plik, "%s ", firma->nazwa);
			for (i = 0; i < IloscDniWHistorii; ++i)
				fprintf(Plik, "%d ", firma->historia[i]);
			firma = firma->nastepny;
		}
		fclose(Plik);
	}
	ZwolnijPamiec();
}

//Wywietla lisê firm
void MenuHistoriaKursow()
{
	struct FirmaStruct *firma;
	int wyswietlonych = 0;
	int i;

	firma = listaFirm;
	CzyscEkran();
	printf("|----------------------------------------------------------------|\n");
	printf("| Historia kursow:                                               |\n");
	printf("|----------------------------------------------------------------|\n");
	printf("|     Nazwa      |             Notowania                         |\n");
	printf("|                |                                               |\n");
	while (firma != NULL)
	{
		if (wyswietlonych >= MaksLiczbaLiniiNaStronie)
		{
			wyswietlonych = 1;
			printf("|                |                                               |\n");
			printf("|----------------------------------------------------------------|\n");
			printf("\n  Nastêpna strona ->");
			getchar();
			CzyscEkran();
			printf("|----------------------------------------------------------------|\n");
			printf("| Historia kursow:                                               |\n");
			printf("|----------------------------------------------------------------|\n");
			printf("|     Nazwa      |             Notowania                         |\n");
			printf("|                |                                               |\n");
		}
		else ++wyswietlonych;

		printf("|%15s |", firma->nazwa);
		for (i = 0; i < IloscDniWHistorii - 1; ++i)
		{
            //printf(" %4d", firma->historia[i]);
            if (firma->historia[i] != 0 && firma->historia[i + 1] != 0)
            {
               if (firma->historia[i] >= firma->historia[i + 1])
                  printf("%3d +%2d%% ", 
	                          firma->historia[i], 
            				((firma->historia[i] - firma->historia[i + 1]) * 100 ) / firma->historia[i + 1]);
		        else printf("%3d -%2d%% ", 
          				      firma->historia[i], 
         					((firma->historia[i + 1] - firma->historia[i]) * 100 ) / firma->historia[i + 1]);
        	}
            else printf("%3d      ", firma->historia[i]);
        }
        printf("%3d       ", firma->historia[IloscDniWHistorii - 1]);
		printf(" |\n");
	
		firma = firma->nastepny;
	}
	printf("|                |                                               |\n");
	printf("|----------------------------------------------------------------|\n");
	gets(str);
}

void MenuListaZlecen()
{
	struct ZlecenieStruct *zlecenie;
	int wyswietlonych = 0;

	zlecenie = listaZlecen;
	CzyscEkran();
	printf("|-------------------------|\n");
	printf("| Lista klientow          |\n");
	printf("|-------------------------|\n");
	printf("|                         |\n");
	while (zlecenie != NULL)
	{
		if (wyswietlonych >= MaksLiczbaLiniiNaStronie)
		{
			wyswietlonych = 1;
			printf("|                         |\n");
			printf("|-------------------------|\n");
			printf("\n  Nastepna strona ->");
			getchar();
			CzyscEkran();
			printf("|-------------------------|\n");
			printf("| Lista zlecen            |\n");
			printf("|-------------------------|\n");
			printf("|                         |\n");
		}
		else ++wyswietlonych;
		printf("|%24s |\n", zlecenie->nazwa);
		zlecenie = zlecenie->nastepny;
	}
	printf("|                         |\n");
	printf("|-------------------------|\n");
	gets(str);
}


//Wywietla listê zleceñ
void ListaZlecen(const char *nazwaFirmy)
{
	struct ZlecenieStruct *zlecenie;
	int wyswietlonych = 0;

	zlecenie = listaZlecen;
	CzyscEkran();
	printf("|---------------------------------------------------------------|\n");
	printf("| Lista zlecen                                                  |\n");
	printf("|---------------------------------------------------------------|\n");
	printf("|   Nazwa klienta   |   Nazwa Firmy  | Operacja | Ilosc | Cena  |\n");
	printf("|                   |                |          |       |       |\n");
	while (zlecenie != NULL)
	{
		if (zlecenie->aktywny)
		{
			if (wyswietlonych >= MaksLiczbaLiniiNaStronie)
			{
				wyswietlonych = 1;
				printf("|                   |                |          |       |       |\n");
				printf("|---------------------------------------------------------------|\n");
				printf("\n  Nastepna strona ->");
				getchar();
				CzyscEkran();
				printf("|---------------------------------------------------------------|\n");
				printf("| Lista zlecen                                                  |\n");
				printf("|---------------------------------------------------------------|\n");
				printf("|   Nazwa klienta   |   Nazwa Firmy  | Operacja | Ilosc | Cena  |\n");
				printf("|                   |                |          |       |       |\n");
			}
			else ++wyswietlonych;
			printf("|%18s |%15s | ", zlecenie->nazwa, nazwaFirmy);
			if (zlecenie->operacja == Kupno) printf(" Kupno  ");
			else printf("Sprzedaz");
			printf(" |%6d | %5d |\n", zlecenie->ilosc, zlecenie->cena);
		}		
		zlecenie = zlecenie->nastepny;
	}
	printf("|                   |                |          |       |       |\n");
	printf("|---------------------------------------------------------------|\n");
	gets(str);
}

//Dodaje zlecenie do listy
void DodajZlecenieDoListy(struct ZlecenieStruct *zlecenie)
{
	zlecenie->nastepny = NULL;
	if (listaZlecen != NULL) ostatnieZlecenieNaLiscie->nastepny = zlecenie;
	else listaZlecen = zlecenie;
	ostatnieZlecenieNaLiscie = zlecenie;
}

void DodajFirmeDoListy(struct FirmaStruct *firma)
{
	int i;
	
	for (i = 0; i < IloscDniWHistorii; ++i)
		firma->historia[i] = 0;
	firma->nastepny = NULL;
	if (listaFirm != NULL) ostatniaFirmaNaLiscie->nastepny = firma;
	else listaFirm = firma;
	ostatniaFirmaNaLiscie = firma;
}

void MenuDodajZlecenie()
{
	struct ZlecenieStruct *zlecenie, *zlecenie2;
	int flaga;
	int i;
	char tmpStr[20];

	CzyscEkran();
	zlecenie = malloc(sizeof(struct ZlecenieStruct));
	printf("|----------------------------------------------|\n");
	printf("| Dodaj nowego klienta:                        |\n");
	printf("|----------------------------------------------|\n");
	printf("\n");
	flaga = 1;
	while (flaga)
	{
		printf("  Nazwa klienta: ");
		gets(zlecenie->nazwa);
		if (zlecenie->nazwa[0] == 0)
		{	
			printf("  Nazwa klienta nie moze byc pusta\n");
		}
		else
		{
			zlecenie2 = listaZlecen;
			flaga = 0;
			while (zlecenie2 != NULL)
			{
				if (strcmp(zlecenie2->nazwa, zlecenie->nazwa) == 0)
				{
					flaga = 1;
					break;
				}
				zlecenie2 = zlecenie2->nastepny;
			}
			if (flaga) printf("  Nazwa klienta musi byc unikalna\n");
		}
	}
	DodajZlecenieDoListy(zlecenie);
	printf("  klient zostal dodany");
	gets(str);
}

void MenuDodajFirme()
{
	struct FirmaStruct *firma, *firma2;
	int flaga;
	int i;
	char tmpStr[20];

	CzyscEkran();
	firma = malloc(sizeof(struct FirmaStruct));
	printf("|----------------------------------------------|\n");
	printf("| Dodaj nowa firme:                            |\n");
	printf("|----------------------------------------------|\n");
	printf("\n");
	flaga = 1;
	while (flaga)
	{
		printf("  Nazwa firmy: ");
		gets(firma->nazwa);
		if (firma->nazwa[0] == 0)
		{	
			printf("  Nazwa firmy nie moze byc pusta\n");
		}
		else
		{
			firma2 = listaFirm;
			flaga = 0;
			while (firma2 != NULL)
			{
				if (strcmp(firma2->nazwa, firma->nazwa) == 0)
				{
					flaga = 1;
					break;
				}
				firma2 = firma2->nastepny;
			}
			if (flaga) printf("  Nazwa firmy musi byc unikalna\n");
		}
	}
	DodajFirmeDoListy(firma);
	printf("  firma zostala dodana");
	gets(str);
}

void MenuUsunZlecenie()
{
	char nazwa[MaksDlugoscNazwyZlecenia];
	struct ZlecenieStruct *zlecenie, *poprzednie;
	int znaleziono = 0;
	
	CzyscEkran();
	printf("\n  Prosze podac nazwe klienta do usuniecia: ");
	scanf("%s", nazwa);
	
	zlecenie = listaZlecen;
	poprzednie = NULL;
	
	while (zlecenie != NULL)
	{
		if (strcmp(nazwa, zlecenie->nazwa) == 0)
		{
			if (poprzednie == NULL) listaZlecen = zlecenie->nastepny;
			else poprzednie->nastepny = zlecenie->nastepny;
			if (zlecenie->nastepny == NULL) ostatnieZlecenieNaLiscie = poprzednie;
			free(zlecenie);
			znaleziono = 1;
			break;
		}
		poprzednie = zlecenie;
		zlecenie = zlecenie->nastepny;
	}
	
	if (znaleziono == 0) printf("  Zlecenie nie zostalo znalezione");
	else printf("  Zlecenie zostalo usuniete");
	
	gets(str);
	gets(str);
}

void MenuUsunFirme()
{
	char nazwa[MaksDlugoscNazwyFirmy];
	struct ZlecenieStruct *zlecenie, *zleceniePoprzednie, *zlecenieTmp;
	struct FirmaStruct *firma, *firmaPoprzednia;
	int znaleziono = 0;
	
	CzyscEkran();
	printf("\n\n  Prosze podac nazwe firmy do usuniecia: ");
	scanf("%s", nazwa);
	
	firma = listaFirm;
	firmaPoprzednia = NULL;
	
	while (firma != NULL)
	{
		if (strcmp(nazwa, firma->nazwa) == 0)
		{
			//usuniecie firmy
			if (firmaPoprzednia == NULL) listaFirm = firma->nastepny;
			else firmaPoprzednia->nastepny = firma->nastepny;
			if (firma->nastepny == NULL) ostatniaFirmaNaLiscie = firmaPoprzednia;
			strcpy(nazwa, firma->nazwa);
			free(firma);
			znaleziono = 1;
			break;
		}
		firmaPoprzednia = firma;
		firma = firma->nastepny;
	}
	
	if (znaleziono == 0) printf("  Firma nie zostala znaleziona");
	else printf("  Firma zostala usunieta");
	
	gets(str);
	gets(str);
}

int Max(int a, int b)
{
	return (a > b) ? (a) : (b);
}

int Min(int a, int b)
{
	return (a < b) ? (a) : (b);
}

int Rand(int a, int b)
{
	return rand() % (b - a) + a;
}

void MenuSymulacja()
{
	struct FirmaStruct *firma;
	struct ZlecenieStruct *zlecenie;
	int i, cenaMax, cenaMin, maxD, maxG, flaga, ilosc, czySprzedano;
	int *tab1, *tab2, tabSize, roznica, pozostalo, kurs;

	
	firma = listaFirm;
	
	while (firma != NULL)
	{
		CzyscEkran();
		for (i = IloscDniWHistorii - 1; i > 0; --i) 
			firma->historia[i] = firma->historia[i-1];
		firma->historia[0] = 0;
		
		zlecenie = listaZlecen;
		while (zlecenie != NULL)
		{
			if ((i = Rand(0, 100)) < ZlecenieProcent)
			{
				zlecenie->aktywny = 1;
				zlecenie->operacja = (Rand(0, 100) < 50) ? (Kupno) : (Sprzedaz);
				zlecenie->cena = Rand(CenaMin, CenaMax);
				zlecenie->ilosc = Rand(IloscMin, IloscMax);
			}
			else 
			{
				zlecenie->aktywny = 0;
			}
			
			zlecenie = zlecenie->nastepny;
		}
		ListaZlecen(firma->nazwa);

		zlecenie = listaZlecen;
		cenaMax = 0;
		cenaMin = 20000000;
		while (zlecenie != NULL)
		{
			if (zlecenie->aktywny)
			{
				cenaMax = Max(cenaMax, zlecenie->cena);
				cenaMin = Min(cenaMin, zlecenie->cena);
			}
			zlecenie = zlecenie->nastepny;
		}

		tabSize = cenaMax - cenaMin + 1;
		tab1 = malloc(sizeof(int) * tabSize);
		tab2 = malloc(sizeof(int) * tabSize);
		memset(tab1, 0, sizeof(int) * tabSize);
		memset(tab2, 0, sizeof(int) * tabSize);

		zlecenie = listaZlecen;
		flaga = 0;
		while (zlecenie != NULL)
		{
			if (zlecenie->aktywny)
			{
				flaga = 1;
				if (zlecenie->operacja == Kupno)
					tab1[zlecenie->cena - cenaMin] = zlecenie->ilosc;
				else
					tab2[zlecenie->cena - cenaMin] = zlecenie->ilosc;
			}
			zlecenie = zlecenie->nastepny;
		}
		if (flaga == 0) 
		{
			printf(" Firma %s\n\n", firma->nazwa);
			printf("Nie ma zadnych zlecen");
		}
		else
		{
			for (i = tabSize - 1; i > 0; --i)
				tab1[i - 1] += tab1[i];
			for (i = 0; i < tabSize - 1; ++i)
				tab2[i + 1] += tab2[i];
			maxG = maxD = 0;
			flaga = 1;
			for (i = 0; i < tabSize; ++i)
			{
				//printf("%d %d\n", tab1[i], tab2[i]);
				if (Min(tab1[maxD],tab2[maxD]) < Min(tab1[i], tab2[i]))
				{
					flaga = 1;
					maxD = maxG = i;
				}
				else if (Min(tab1[maxD],tab2[maxD]) == Min(tab1[i], tab2[i]))
				{
					if (flaga) maxG = i;
				}
				else flaga = 0;
			}

			roznica = tab1[maxG] - tab2[maxD]; // dodatnie to przewaga kupna
			pozostalo = abs(roznica);
			maxD += cenaMin;
			maxG += cenaMin;
			kurs = (maxD + maxG) / 2;
			zlecenie = listaZlecen;
			//printf("%d %d %d\n", maxD, maxG, roznica);
			CzyscEkran();
			printf("  |------------------------------------------------|\n");
			printf("  |     Symulacja gieldy - Firma %-15s   |\n", firma->nazwa);
			printf("  |------------------------------------------------|\n");
			printf("  |   Nazwa klienta    | Dokonane transakcje       |\n");
			printf("  |------------------------------------------------|\n");
			printf("  |                                                |\n");
			czySprzedano = 0;
			while (zlecenie != NULL)
			{
				if (zlecenie->aktywny)
				{
					if (zlecenie->operacja == Kupno)
					{
						if (zlecenie->cena > maxG || (zlecenie->cena == maxG && roznica <= 0)) 
						{
							printf("  | %18s | Kupiono   %3d z %3d akcji |\n",
								zlecenie->nazwa, zlecenie->ilosc, zlecenie->ilosc);
							czySprzedano = 1;
						}
						else if (zlecenie->cena == maxG)
						{
							if (pozostalo >= zlecenie->ilosc)
							{
								pozostalo -= zlecenie->ilosc;
								ilosc = 0;
							}
							else 
							{
								ilosc = zlecenie->ilosc - pozostalo;
								pozostalo = 0;
							}
							if (ilosc != 0) 
							{
								printf("  | %18s | Kupiono   %3d z %3d akcji |\n",
									zlecenie->nazwa, ilosc, zlecenie->ilosc);
								czySprzedano = 1;
							}
						}
					}
					else
					{
						if (zlecenie->cena < maxD || (zlecenie->cena == maxD && roznica >= 0)) 
						{
							printf("  | %18s | Sprzedano %3d z %3d akcji |\n",
								zlecenie->nazwa, zlecenie->ilosc, zlecenie->ilosc);
							czySprzedano = 1;
						}
						else if (zlecenie->cena == maxD)
						{
							if (pozostalo >= zlecenie->ilosc)
							{
								pozostalo -= zlecenie->ilosc;
								ilosc = 0;
							}
							else 
							{
								ilosc = zlecenie->ilosc - pozostalo;
								pozostalo = 0;
							}
							if (ilosc != 0) 
							{
								printf("  | %18s | Sprzedano %3d z %3d akcji |\n",
									zlecenie->nazwa, ilosc, zlecenie->ilosc);
								czySprzedano = 1;
							}
						}
					}
				}
				zlecenie = zlecenie->nastepny;
			}
			if (!czySprzedano) kurs = 0;
			firma->historia[0] = kurs;
			printf("  |------------------------------------------------|\n");
			if (kurs != 0 && firma->historia[1] != 0)
			{
				if (kurs >= firma->historia[1])
					printf("\n  kurs akcji wyniosl: %d (+%d%%)", 
						kurs, 
						((kurs - firma->historia[1]) * 100 ) / firma->historia[1]);
				else printf("\n  kurs akcji wyniosl: %d (-%d%%)", 
						kurs, 
						((firma->historia[1] - kurs) * 100 ) / firma->historia[1]);
			}
			else printf("\n  kurs akcji wyniosl: %d", kurs);
		}
		free(tab1);
		free(tab2);
		gets(str);
		firma = firma->nastepny;
	}
}