#include <stdio.h>
#include <tchar.h>
#include <windows.h>
#include <string.h>
#include <stdlib.h>
#include <vector>

//-----------------------------------------

typedef struct D_struktury				// definice strukrury zaznamu
{
	char	Jmeno[50];
	char	Prijmeni[50];
	char	Oznaceni[50];
	char	Poznamka[50];
	char	Datum [50];
	int		ID;
} D_struct;

//-----------------------------------------

class Seznam                               // trida seznam
{
private:
	std::vector<D_struct*>	S_polozek;	   // vektor pro praci se seznamem polozek
	std::vector<D_struct*> Search_pamet;   // pamet pro vypis posledniho hledani 
	bool	S_pristupny;			       // zjisti zda je seznam pristupny
public:
	D_struct	*Pamet;				       // pamet - pracuje s jednim zaznamem
	char	*Soubor_nazev;				   // nazev souboru se seznamem
	bool	S_otevren();				   // funkce pro otevreni souboru ze seznamu
	void	S_zavren();				       // funkce pro zavreni souboru ze seznamu 
	void	Pridat_polozku();			   // Pridat novou polozku z pameti
	void	Zmena_polozky();			   // Zmena polozky
	void	Smazat_polozku();			   // smaze polozku z pameti
	void	Ulozit_seznam();			   // zavreni a otevreni souboru
	bool	Novy_soubor();                 // Vytvori novy soubor
	bool	Soubor_existuje();			   // zjisti, zda existuje soubor se seznamem
	bool	Nahrat_seznam();		       // nahraje cely seznam do pameti 
	bool	Pamet_uloz_seznam();		   // ulozi cely seznam z pameti do souboru
	bool	Vycistit_soubor();		       // vycisti soubor seznamu
	int		Posledni_ID();		           // vraci posledni id ze seznamu
	bool	Vyhledat_retezec(char *_s);	   // vyhledava podle retezcu
	void	Dalsi_polozka();		       // posun o 1 zaznam vpred
	void	Predchozi_polozka();	       // posun o 1 zaznam vzad
	void	Zacatek_seznamu();			   // posun na zacatek seznamu
	void	Konec_seznamu();			   // posun na konec seznamu
	void	Aktualni_pamet();	           // aktualizuje pamet podle Pozice_vector
	int		Pocet_zaznamu();			   // vypise pocet prvku ze seznamu
    int     Pozice_vector;		           // eqvivalent iteratoru pro posun

	Seznam();				// konstruktor
	~Seznam();				// destruktor
};

//-----------------------------------------

FILE	*Hlavni_soubor;					// hlavni soubor pro praci se seznamem
FILE	*Docasny_soubor;				// docasny soubor pro upravy v seznamu
D_struct	*Docasny_seznam;
Seznam *Soubor_seznam;
//-----------------------------------------

Seznam::Seznam()
{
	S_pristupny = false;
	Pamet = new D_struct();
	Pozice_vector = -1;
}

//-----------------------------------------

Seznam::~Seznam()
{
}

//-----------------------------------------

void Pridat()
{
	system("cls");
	char tmp[50];
	int itmp = 0;
    printf("\n*************************\n");
	printf("   PRIDAT NOVY KONTAKT  \n");
	printf("*************************\n\n");

	printf("Jmeno:     ");
	scanf("%s", tmp);
	sprintf(Soubor_seznam->Pamet->Jmeno, "%s", tmp);

	printf("Prijmeni:  ");
	scanf("%s", tmp);
	sprintf(Soubor_seznam->Pamet->Prijmeni, "%s", tmp);

    printf("Datum:     ");
	scanf("%s", tmp);
	sprintf(Soubor_seznam->Pamet->Datum, "%s", tmp);
	
	printf("Oznaceni:  ");
	scanf("%s", tmp);
	sprintf(Soubor_seznam->Pamet->Oznaceni, "%s", tmp);

	printf("Poznamka:  ");
	scanf("%s", tmp);
	sprintf(Soubor_seznam->Pamet->Poznamka, "%s", tmp);

	Soubor_seznam->Pridat_polozku();
}

//-----------------------------------------

void Smazat()
{

	if(Soubor_seznam->Pocet_zaznamu() > 0) Soubor_seznam->Smazat_polozku();
	if(Soubor_seznam->Pocet_zaznamu() > 0)
	{
		Soubor_seznam->Zacatek_seznamu();
		Soubor_seznam->Aktualni_pamet();
	}
}

//-----------------------------------------


void Zmenit()
{
	char tmp[50];
	int itmp = 0;

    printf("\n*****************************************\n");
	printf("                Zmena zaznamu           \n");     
	printf("*****************************************\n\n");

	printf("Jmeno:     ");
	scanf("%s", tmp);
	sprintf(Soubor_seznam->Pamet->Jmeno, "%s", tmp);

	printf("Prijmeni:  ");
	scanf("%s", tmp);
	sprintf(Soubor_seznam->Pamet->Prijmeni, "%s", tmp);

    printf("Datum:     ");
	scanf("%s", tmp);
	sprintf(Soubor_seznam->Pamet->Datum, "%s", tmp);
	
	printf("Oznaceni:  ");
	scanf("%s", tmp);
	sprintf(Soubor_seznam->Pamet->Oznaceni, "%s", tmp);

	printf("Poznamka:  ");
	scanf("%s", tmp);
	sprintf(Soubor_seznam->Pamet->Poznamka, "%s (zmena)", tmp);

	Soubor_seznam->Zmena_polozky();
}

//-----------------------------------------

void Hledat()
{
     
	char sw[50], key;
	getchar() ;
    system("CLS");
	printf("\n\n Zadejte \"vyraz\" pro vyhledani konkretniho zaznamu: ");
	gets(sw);

	if(!Soubor_seznam->Vyhledat_retezec(sw)) 
   { printf("\n\n Hledany zaznam neexistuje!!!\n\n");
    system(" pause");
    return;}
    
	do
	{
        	
		system("CLS");
		printf("\n*****************************************\n");
		printf("             Hledana polozka            \n");
		printf("*****************************************\n\n");
		printf("Jmeno:    %s\n", Soubor_seznam->Pamet->Jmeno);
		printf("Prijmeni: %s\n", Soubor_seznam->Pamet->Prijmeni);
		printf("Oznaceni: %s\n", Soubor_seznam->Pamet->Oznaceni);
		printf("Datum:    %s\n", Soubor_seznam->Pamet->Datum);
		printf("Poznamka: %s\n", Soubor_seznam->Pamet->Poznamka);
		printf("ID: %d\n", Soubor_seznam->Pamet->ID);
		printf("\n");
		
		printf("-----------------------------------------\n");
		if(Soubor_seznam->Pozice_vector > 0) printf("<<-  p ... Predchozi   ");
		if(Soubor_seznam->Pozice_vector < (unsigned int)Soubor_seznam->Pocet_zaznamu() - 1) printf("d ... Dalsi  ->>    ");
		printf("\n-----------------------------------------");
		
		printf("\n\n");

		printf("1 ... Zpet do menu     \n\n");
		printf("-----------------------------------------\n");
		printf("Zvolte moznost: "); 
		

		char key= getchar() ;

		switch(key)
		{
			case	'p'	:	Soubor_seznam->Predchozi_polozka(); Soubor_seznam->Aktualni_pamet(); continue;
			case	'd'	:	Soubor_seznam->Dalsi_polozka(); Soubor_seznam->Aktualni_pamet(); continue;
			case	'1'	:	return;
		}
	
	}
	while(true);
}

//-----------------------------------------
void Vypis()
{
	char key;

	do
	{
			if(!Soubor_seznam->Pocet_zaznamu()) return;		
		system("CLS");
		printf("\n*****************************************\n");
        printf("        VYPIS => polozka %d / %d     \n", Soubor_seznam->Pozice_vector+1, Soubor_seznam->Pocet_zaznamu());
		printf("*****************************************\n\n");
		printf("Jmeno:    %s\n", Soubor_seznam->Pamet->Jmeno);
		printf("Prijmeni: %s\n", Soubor_seznam->Pamet->Prijmeni);
		printf("Oznaceni: %s\n", Soubor_seznam->Pamet->Oznaceni);
		printf("Datum:    %s\n", Soubor_seznam->Pamet->Datum);
		printf("Poznamka: %s\n", Soubor_seznam->Pamet->Poznamka);
		printf("ID: %d\n", Soubor_seznam->Pamet->ID);
		printf("\n");
		
		printf("-----------------------------------------\n");
		if(Soubor_seznam->Pozice_vector > 0) printf("<<-  p ... Predchozi   ");
		if(Soubor_seznam->Pozice_vector < (unsigned int)Soubor_seznam->Pocet_zaznamu() - 1) printf("d ... Dalsi  ->>    ");
		printf("\n-----------------------------------------");
		
		printf("\n\n");
		
		printf("1 ... Smazat zaznam    \n");
		printf("2 ... Pridat zaznam   \n");
		printf("3 ... Upravit zaznam   \n");
		printf("4 ... Zpet do menu     \n\n");
		printf("-----------------------------------------\n");
		printf("Zvolte moznost: ");
	
		char key= getchar() ;

		switch(key)
		{
			case	'p'	:	Soubor_seznam->Predchozi_polozka(); Soubor_seznam->Aktualni_pamet(); continue;
			case	'd'	:	Soubor_seznam->Dalsi_polozka(); Soubor_seznam->Aktualni_pamet(); continue;
			case	'1'	:	Smazat(); continue;
			case	'2'	:	Pridat(); continue;
			case	'3'	:	Zmenit(); continue;
			case	'4'	:	
                 Soubor_seznam->Pamet_uloz_seznam();
	             Soubor_seznam->S_zavren();return;
		}
	}
	while(true);
}
    
	
//-----------------------------------------

char HlavniMenu()
{
     printf("\n***********************\n");
     printf("     HLAVNI MENU       \n");
	 printf("***********************\n\n");
	 printf("1 ... Databaze\n\n");
	 printf("2 ... Novy zaznam \n\n");
	 printf("3 ... Hledat zaznam\n\n");
	 printf("4 ... Konec \n\n");
	 printf("-----------------------\n");
	 printf("Zvolte moznost: ");
	 int ch =getchar();

	switch(ch)
	{
		case	'1'	:	Vypis(); break;
		case	'2'	:	Pridat(); break; 
		case	'3'	:	Hledat(); Soubor_seznam->Nahrat_seznam(); break;
	}

	return (char)ch;

}

//-----------------------------------------

int _tmain(int argc, _TCHAR* argv[])
{
	Soubor_seznam = new Seznam();   // trida pro praci se seznamem
	Soubor_seznam->Soubor_nazev = "PRO_zapocet_E.txt";  // cesta k souboru se seznamem
		
	if(!Soubor_seznam->S_otevren()) // otevreni, nebo vytvoreni soubor
	{
		printf("[ CHYBA ]\n");
		return 0;
	}
	
	if(!Soubor_seznam->Nahrat_seznam())  // nacteni polozek ze seznamu
	{
		printf("[CHYBA]");
		return 0;
	}

	char key;

	do
	{
		key = HlavniMenu();
		system("cls");
	}
	while(key != '4');

	Soubor_seznam->Pamet_uloz_seznam();
	Soubor_seznam->S_zavren();

	return 0;
}

//-----------------------------------------

int Seznam::Pocet_zaznamu()
{
	return (int) S_polozek.size();
}

//-----------------------------------------

bool Seznam::Novy_soubor()
{
	Docasny_soubor = fopen(Soubor_nazev, "w");
	if(!Docasny_soubor) return false;
	fclose(Docasny_soubor);
	return true;
}

//-----------------------------------------

bool Seznam::Soubor_existuje()
{
	Docasny_soubor = fopen(Soubor_nazev, "r");  // zjisteni existence souboru 
	if(Docasny_soubor)
	{
		fclose(Docasny_soubor);
		return true;
	}
	else
	{
		return false;
	}
}

//-----------------------------------------

bool Seznam::S_otevren()
{
	S_pristupny = false;  // kontrola zda soubor existuje. 
                          // jinak vytvori novy soubor
	
    if(!Soubor_existuje()) Novy_soubor();
	Hlavni_soubor = fopen(Soubor_nazev, "r+");
	if(!Hlavni_soubor) return false;

	S_pristupny = true;
	return true;
}

//-----------------------------------------

void Seznam::S_zavren()
{
	if(S_pristupny)
	{
		fclose(Hlavni_soubor);
		S_pristupny = false;
	}
}

//-----------------------------------------

void Seznam::Ulozit_seznam()
{
	S_zavren();
	S_otevren();
}

//-----------------------------------------

bool Seznam::Nahrat_seznam()
{
	size_t result;

	if(!S_pristupny) if(!S_otevren()) return false;
	S_polozek.clear();

	rewind(Hlavni_soubor);

	while(!feof(Hlavni_soubor))
	{
		Docasny_seznam = new D_struct();  	// nacteni souboru do pameti
		result = fread(Docasny_seznam, sizeof(D_struct), 1, Hlavni_soubor);
		if(result) S_polozek.push_back(Docasny_seznam);
	}	

	if(S_polozek.size())
	{
		Pozice_vector = 0;
		Aktualni_pamet();
	}

	return true;

}

//-----------------------------------------

bool Seznam::Vycistit_soubor()
{
	if(S_pristupny) S_zavren();
	Hlavni_soubor = fopen(Soubor_nazev, "w");
	if(!Hlavni_soubor) return false;
	fclose(Hlavni_soubor);
	S_otevren();
	return true;
}

//-----------------------------------------

void Seznam::Pridat_polozku()
{
	// ulozi seznam v pameti do vektoru
	Docasny_seznam = new D_struct();
	sprintf(Docasny_seznam->Jmeno, "%s", Pamet->Jmeno);
	sprintf(Docasny_seznam->Prijmeni, "%s", Pamet->Prijmeni);
	sprintf(Docasny_seznam->Oznaceni, "%s", Pamet->Oznaceni);
	sprintf(Docasny_seznam->Poznamka, "%s", Pamet->Poznamka);
	sprintf(Docasny_seznam->Datum, "%s", Pamet->Datum);
	Docasny_seznam->ID = Posledni_ID() + 1;	//generovani ID
	S_polozek.push_back(Docasny_seznam);
	Pamet_uloz_seznam();
	Zacatek_seznamu();
	Aktualni_pamet();
}

//-----------------------------------------
bool Seznam::Pamet_uloz_seznam()
{
	if(!S_pristupny) if(!S_otevren()) return false;

	Vycistit_soubor();

	for(unsigned int i=0; i<S_polozek.size(); i++)
	{
		fwrite(S_polozek[i], sizeof(D_struct), 1, Hlavni_soubor);
	}

	Ulozit_seznam();
	return true;

}

//-----------------------------------------

void Seznam::Zmena_polozky()
{
		std::vector<D_struct*>::iterator it = S_polozek.begin();

	for(unsigned int i=0; i<S_polozek.size(); i++, it++)
	{
		if(S_polozek[i]->ID == Pamet->ID) 
		{
			S_polozek.erase(it);
			break;
		}
	}
	Docasny_seznam = new D_struct();
	sprintf(Docasny_seznam->Jmeno, "%s", Pamet->Jmeno);
	sprintf(Docasny_seznam->Prijmeni, "%s", Pamet->Prijmeni);
	sprintf(Docasny_seznam->Oznaceni, "%s", Pamet->Oznaceni);
	sprintf(Docasny_seznam->Poznamka, "%s", Pamet->Poznamka);
	sprintf(Docasny_seznam->Datum, "%s", Pamet->Datum);
	Docasny_seznam->ID= Pamet->ID  ;	
	S_polozek.push_back(Docasny_seznam);
	Pamet_uloz_seznam();
	Konec_seznamu();
	Aktualni_pamet();
}

//-----------------------------------------
void Seznam::Smazat_polozku()
{
	std::vector<D_struct*>::iterator it = S_polozek.begin();

	for(unsigned int i=0; i<S_polozek.size(); i++, it++)
	{
		if(S_polozek[i]->ID == Pamet->ID) 
		{
			S_polozek.erase(it);
			break;
		}
	}
}

//-----------------------------------------

bool Seznam::Vyhledat_retezec(char *_s)
{

	Search_pamet.clear(); // vycisti pamet
	
	for(unsigned int i=0; i<S_polozek.size(); i++)
	{
		if(strstr(S_polozek[i]->Jmeno, _s))
		{
			Search_pamet.push_back(S_polozek[i]);
			continue;
		}

		if(strstr(S_polozek[i]->Prijmeni, _s))
		{
			Search_pamet.push_back(S_polozek[i]);
			continue;
		}
		if(strstr(S_polozek[i]->Datum, _s))
		{
			Search_pamet.push_back(S_polozek[i]);
			continue;
		}
		
		if(strstr(S_polozek[i]->Oznaceni, _s))
		{
			Search_pamet.push_back(S_polozek[i]);
			continue;
		}
			if(strstr(S_polozek[i]->Poznamka, _s))
		{
			Search_pamet.push_back(S_polozek[i]);
			continue;
		}

		}

	if(Search_pamet.size() > 0) 
	{
		S_polozek = Search_pamet;
		Pozice_vector = 0;
		Aktualni_pamet();
		return true;
	}

	return false;
}

//-----------------------------------------

void Seznam::Aktualni_pamet()
{
	sprintf(Pamet->Jmeno, "%s", S_polozek[Pozice_vector]->Jmeno);
	sprintf(Pamet->Prijmeni, "%s", S_polozek[Pozice_vector]->Prijmeni);
	sprintf(Pamet->Oznaceni, "%s", S_polozek[Pozice_vector]->Oznaceni);
	sprintf(Pamet->Datum, "%s", S_polozek[Pozice_vector]->Datum);
	sprintf(Pamet->Poznamka, "%s", S_polozek[Pozice_vector]->Poznamka);
	Pamet->ID = S_polozek[Pozice_vector]->ID;
}

//-----------------------------------------

void Seznam::Zacatek_seznamu()
{
	if(S_polozek.empty()) return;

	Pozice_vector = 0;
	Aktualni_pamet();
}

//-----------------------------------------

void Seznam::Konec_seznamu()
{
	if(S_polozek.empty()) return;

	Pozice_vector = S_polozek.size() - 1;
}

//-----------------------------------------

void Seznam::Predchozi_polozka()
{

	if(S_polozek.empty()) return;

	if(Pozice_vector > 0)
	{
		Pozice_vector--;
		Aktualni_pamet();
	}
}

//-----------------------------------------

void Seznam::Dalsi_polozka()
{
	
	if(S_polozek.empty()) return;
	
	if(Pozice_vector < S_polozek.size() - 1)
	{
		Pozice_vector++;
		Aktualni_pamet();
	}
}

//-----------------------------------------

int Seznam::Posledni_ID()
{
	// zjisti nejvyssi ID v seznamu
	int LastID = 0;

	for(unsigned int i=0; i<S_polozek.size(); i++)
	{
		if(LastID < S_polozek[i]->ID) LastID = S_polozek[i]->ID;
	}

	return LastID;
}

//-----------------------------------------