// XPE.cpp : Defines the entry point for the console application. 
// 

#include "stdafx.h" 
#include <string> 
#include <fstream> 
#include <iostream> 
#include <locale> 
#include <gtest/gtest.h>
#include <cstdlib>
//#include "tests.cpp"
using namespace std; 

struct Tree_Cell 
{ 
char name[20]; 
int value; 
Tree_Cell* next[50]; 
int iMax_Cell; 
}; 

struct Data_Out
{
	int daykey;
	string outstr[100];
	int strmax;
};
/////////////////////////////////////////////////// 
//////////////////////////////////HESH DATA 
/////////////////////////////////////////////////// 
class HeshData 
{ 
    private: 
		 int makehash(string name) 
		  {
			  int sum; 
			  sum=0; 
			  for(int i=0; i<name.length(); i++) 
			  { 
				  sum += name[i]; 
			  } 
			  sum = abs(sum)/10; 
			  sum = min(iHeshMaxSize-1,sum); 
			  return sum; 
		 }
    public: 
		HeshData() { iHeshMaxSize=100; sOrgHeshNames = new string[iHeshMaxSize]; for(int i=0; i<iHeshMaxSize; i++){heshnames[i] = "*";} maxOHNames=0; } 
		int SetHash(string name) 
		{ 
			int sum,wepassed; 
			sum = makehash(name); 
			wepassed = 0;
			while(heshnames[sum] != "*") 
			{ 
				sum++; wepassed++;
			    if (sum>iHeshMaxSize) {sum = 0;} 
				if (wepassed>iHeshMaxSize-1) {return -1;}
			}
			heshnames[sum] = name; 
			sOrgHeshNames[maxOHNames]=name; 
			maxOHNames++; 
			return sum; 
		} 
		int GetHash(string name) 
		{ 
			int sum, wepassed; 
			wepassed = 0;
			sum = makehash(name); 
			while(heshnames[sum]!=name) 
			{ 
				if (heshnames[sum]=="*"){return -1;} 
				sum++; wepassed++;
				if (sum>iHeshMaxSize) {sum = 0;}
				if (wepassed >iHeshMaxSize-1) {return -1;}
			} 
			return sum; 
		} 

string *sOrgHeshNames; 
int maxOHNames; 
int iHeshMaxSize;
private: 
string heshnames[100]; 

}; 

/////////////////////////////////////////////////// 
/////////////////////////////////////////////////// 
/////////////////////////////////////////////////// 
void MakeData(HeshData *Hesh,Tree_Cell** cNods, char *fname) 
{     
	/////Читаем строчку 
	char buffer [256]; 
	char name[20],cValue[100]; 
	string sLine; 
	fstream fin; 
	fin.open(fname,ios::in); 
	fin.getline(buffer,256); 
	sLine = buffer; 
	
	Tree_Cell* Last_Header; 
	Last_Header = new Tree_Cell; 
	Last_Header->iMax_Cell=0; 
	Tree_Cell* Last_Main_Header; 
	Last_Main_Header = new Tree_Cell; 
	Last_Main_Header = Last_Header; 
	
	while(sLine != "") 
	{ 
		int i2=0; 
		for(int i=0; i<sLine.length(); i++) 
		{ 
			if(sLine[i]!=':') 
			{ 
				name[i2]=sLine[i];                //Читаем имя до двоеточия 
				i2++; 
			}else{ 
				name[i2]='\0';                    //Считали имя 
				i2 = 0; 
				//MessageBox(hWnd,name,"MESSAGE",MB_OK); 
				strcpy(Last_Header->name,name); i+=1; //read ':' 
				int k=0; 
				while((sLine[i]!=':')&&(sLine[i]!=','))//Читаем значения до двоеточия 
				{ 
					cValue[k]=sLine[i]; 
					k++; i++; 
					if (i>sLine.length()) {break;} 
				} 
				cValue[k]='\0'; //Считали значение 
				//MessageBox(hWnd,cValue,"MESSAGE",MB_OK); 
				Last_Header->value = atoi(cValue); //Заполняем ячейку 
				///////////////////////////////////////////////////// 
				if(Last_Header != Last_Main_Header) //Добавляем ее к отцу 
				{ 
					Last_Main_Header->next[Last_Main_Header->iMax_Cell] = new Tree_Cell; 
					Last_Main_Header->next[Last_Main_Header->iMax_Cell] = Last_Header; 
					Last_Main_Header->iMax_Cell++; 
				} 
				Last_Header = new Tree_Cell; //Создаем новый лист для следуещго параметра, если его нет то зря тратим память*/ 
			}//else 
		}//for 
		string sNodName; 
		sNodName = Last_Main_Header->name; 
		cNods[Hesh->SetHash(sNodName)] = Last_Main_Header; //Загоняем в Массив строительных ячеек по имени. 
		Last_Main_Header = new Tree_Cell; //для следующей итерации, создаем новый нод; 
		Last_Main_Header->iMax_Cell = 0; 
		Last_Header = new Tree_Cell; 
		Last_Header = Last_Main_Header; 
		fin.getline(buffer,256); 
		sLine = buffer; 
		//MessageBox(hWnd,sNodName.c_str(),"MESSAGE",MB_OK); 
		//MessageBox(hWnd, buffer,"MESSAGE",MB_OK); 
	} 
//cout<<sNodName.c_str(); 
} 





void Make_Output(HeshData *Hesh, int i, Data_Out *Data,Tree_Cell** cNods)
{
    //FUNCTION  (int i)
	int iHesh;	
	if (i>=Hesh->maxOHNames){return;}
	
	iHesh = Hesh->GetHash(Hesh->sOrgHeshNames[i]);
	//cout<<i<<" " <<cNods[iHesh]->name<<endl;

	Data[i].strmax = 0;
	Data[i].outstr[Data[i].strmax] = cNods[iHesh]->name;
	Data[i].outstr[Data[i].strmax] += " ";
	Data[i].daykey = cNods[iHesh]->value;
    //Data[i].outstr[Data[i].strmax] += " дней.";
    Data[i].strmax +=1;
	for(int j=0; j<cNods[iHesh]->iMax_Cell; j++)
	 {
		  int iHesh2;
		  string sName;
		  sName = cNods[iHesh]->next[j]->name;

		  iHesh2 = Hesh->GetHash(sName);
		       //быдлкод
		  if (Data[i].strmax<0){Data[i].strmax = 1;}
		  
		       
		  		 
		  Data[i].outstr[Data[i].strmax] =  sName;
               char buffer[20];
			   itoa(cNods[iHesh]->next[j]->value,buffer,10); 
		  Data[i].outstr[Data[i].strmax] += " ";
		  Data[i].outstr[Data[i].strmax] += buffer;
		  Data[i].outstr[Data[i].strmax] += " шт. ";
				  
		 //cout<<Data[i].outstr[Data[i].strmax]<<endl;
		  Data[i].strmax +=1;
		  
		  if (iHesh2 != -1)
		   {i+=1; Make_Output(Hesh,i,Data,cNods);}
	 }
}

//////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////TESTS
////////////////////////////////////////////////////////////////////////////////////
TEST(HeshTest, HasIndexes) {
	cout<<"running hesh test"<<endl;
	HeshData Hesh;
	string name;
	int inxes[100];

	name = "ara";
	char buff[100];
	for(int i=0; i<99; i+=1)   //Test orginized hesh names
	{
	 itoa(i,buff,10);	 
	 name = "ara";
	 name +=buff;
	 inxes[i] = Hesh.SetHash(name);	
	 EXPECT_EQ(name,Hesh.sOrgHeshNames[i]);
	}

	for(int i=98; i>=0; i-=1)   //Test hesh names indexes
	{
	 itoa(i,buff,10);	 
	 name = "ara";
	 name +=buff;	 
	 EXPECT_EQ(inxes[i],Hesh.GetHash(name));
	}
}

TEST(InputTest) {
 cout<<"running input test"<<endl;
 HeshData Hesh; 
 Tree_Cell* cNods[100]; 
 char fname[256]; 
 strcpy(fname,"Testinput.txt");

 fstream fin; 
 fin.open(fname,ios::out);

 string out;
 out = "Дом:1:Дерево:20:Кухня:1:";
 out += '\n';
 out += "Кухня:3:Дерево:4:Деревокав:5:";
 fin.write(out.c_str(),out.length());
 fin.close();

 MakeData(&Hesh,cNods,fname);
 EXPECT_EQ(cNods[Hesh.GetHash("Кухня")]->next[0]->value,4);
 EXPECT_EQ(cNods[Hesh.GetHash("Кухня")]->next[1]->value,5);
 EXPECT_EQ(cNods[Hesh.GetHash("Дом")]->next[0]->value,20);
 EXPECT_EQ(cNods[Hesh.GetHash("Дом")]->next[1]->value,1);

 EXPECT_STREQ(cNods[Hesh.GetHash("Кухня")]->next[0]->name,"Дерево");
 EXPECT_STREQ(cNods[Hesh.GetHash("Кухня")]->next[1]->name,"Деревокав");

 EXPECT_STREQ(cNods[Hesh.GetHash("Дом")]->next[0]->name,"Дерево");
 EXPECT_STREQ(cNods[Hesh.GetHash("Дом")]->next[1]->name,"Кухня");

 EXPECT_STREQ(cNods[Hesh.GetHash("Дом")]->name,"Дом");
 EXPECT_STREQ(cNods[Hesh.GetHash("Кухня")]->name,"Кухня");
}

TEST(OutputTest) {
 cout<<"running output test"<<endl;
 HeshData Hesh; 
 Tree_Cell* cNods[100]; 
 char fname[256]; 
 strcpy(fname,"Testinput.txt");

 fstream fin; 
 fin.open(fname,ios::out);

 string out;
 out = "Дом:1:Дерево:20:Кухня:1:";
 out += '\n';
 out += "Кухня:3:Дерево:4:Деревокав:5:";
 fin.write(out.c_str(),out.length());
 fin.close();

 MakeData(&Hesh,cNods,fname);
 Data_Out *Data;
 Data = new Data_Out[100];
 Make_Output(&Hesh,0,Data,cNods);
 EXPECT_STREQ(Data[0].outstr[0].c_str(),"Дом ");
 EXPECT_STREQ(Data[0].outstr[1].c_str(),"Дерево 20 шт. ");
 EXPECT_STREQ(Data[0].outstr[2].c_str(),"Кухня 1 шт. ");
 EXPECT_EQ(Data[0].daykey,1);

 EXPECT_STREQ(Data[1].outstr[0].c_str(),"Кухня ");
 EXPECT_STREQ(Data[1].outstr[1].c_str(),"Дерево 4 шт. ");
 EXPECT_STREQ(Data[1].outstr[2].c_str(),"Деревокав 5 шт. ");
 EXPECT_EQ(Data[1].daykey,3);

 cout<<Data[0].daykey<<endl;

}

int _tmain(int argc, _TCHAR* argv[])
{
std::cout << "Running main() from GTF\n";
testing::InitGoogleTest(&argc, argv);

setlocale(LC_ALL,".1251"); 

HeshData Hesh; 
Tree_Cell* cNods[100]; 
char fname[256]; 
strcpy(fname,"input.txt"); 

MakeData(&Hesh,cNods,fname);


cout<<"Данные имплантированы"<<endl;
//cout<<cNods[Hesh.GetHash("Кухня")]->next[0]->name<<endl;
/////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
Data_Out *Data;
Data = new Data_Out[100];

Make_Output(&Hesh,0,Data,cNods);
cout<<"Данные обработаны"<<endl;


/////////////////////////////БЫДЛО КОД
////
int Data_size;
Data_size = 0;
for(int i=0; i<100; i+=1)
{
	//cout<<Data[i].strmax<<endl;
	if (Data[i].strmax < 0)break;
	Data_size++;
}

int tmp,maxval;
string tmpS[100];
maxval = 0;
for(int i=0; i<Data_size; i++)
{
	
	
	for(int j=0; j<Data_size-i-1; j++)
	{
		if (Data[i].daykey < Data[i+1].daykey)
		{
			
			if (Data[i+1].daykey>maxval){maxval = Data[i+1].daykey; }
     		tmp = Data[i+1].daykey;
			Data[i+1].daykey = Data[i].daykey;
			Data[i].daykey = tmp;

			tmp = Data[i+1].strmax;
			for(int k=0; k<Data[i+1].strmax; k++)
			{
				tmpS[k] = Data[i+1].outstr[k];
			}
			for(int k=0; k<Data[i].strmax; k++)
			{
				Data[i+1].outstr[k] = Data[i].outstr[k];
				Data[i+1].strmax = Data[i].strmax;
			}			

			for(int k=0; k<tmp; k++)
			{
				Data[i].outstr[k] = tmpS[k];
				Data[i].strmax = k;
			}	

		}
	}
}

////////////////////////////////////
 cout<<endl<<"Порядок"<<endl;
 for(int i=0; i<Data_size; i++)
 {
	 cout<<"День "<<-Data[i].daykey+maxval+1<<endl;
	 for(int j=0; j<=Data[i].strmax; j++)
	 {
		 cout<<Data[i].outstr[j].c_str();
	 }
	 cout<<endl;
 }
 //Data[i].outstr[2]

//cout<<Data[0].strmax;
/*for(int i=0; i<= Data[2].strmax; i++)
{
	 cout<<Data[i].outstr[i].c_str()<<endl;
}*/


	



//name = Hesh.sOrgHeshNames[Hesh.heshnames];
//inx = Hesh.GetHash(name);
//cNods[1]->next[cNods[1]->iMax_Cell]->name;


/*string sNodName = "Хрень"; 
cout<<Hesh.sOrgHeshNames[1]<<endl; 
cout<<cNods[Hesh.GetHash(sNodName)]->next[1]->name; 
*/


int result=RUN_ALL_TESTS();
getchar();
return 1;//result; 
}