#include "stdafx.h"
#include <stdlib.h>
#include <iostream>
#include <fstream>
#include "stdio.h"
#include <vector>
#include <string>

struct File
{
	std::string name;
	std::string extension;
	int bytes;
	int pos;
	File *next;
	friend void operator -(File & lfl);
	friend void operator +(File &, File const& );
	File()
	{
		std::string name = "";
	    std::string extension = "";
	    int bytes = 0;
	    int pos=this-next;
	    File *next=NULL;
	}
	~File()
	{next=NULL;}
	File(File const& fl)
	{
		this->name=fl.name;
		this->extension=fl.extension;
		this->bytes=fl.bytes;
		this->pos=fl.pos;
		this->next=fl.next;
	}
	File operator =(File const& frm)
	{
		this->name = frm.name;
		this->extension = frm.extension;
		this->bytes = frm.bytes;
		this->pos = frm.pos;
		this->next = frm.next;
		return *this;
	}
	void AddElement(int n,File & rfl)

		//File *previous = this;
		//while (previous->pos != ((File*)previous->pos)->pos)
		//	previous = (File*)((File*)previous->pos)->pos;
		//previous = (File*)((File*)previous->pos)->pos;
		//													//уходим в начало

		//if (previous->next != NULL)								//если текущий элемент не последний
		//if (previous->next->next != NULL)						//и следующий за ним не последний
		//{
		//	File *to_del = previous->next;
		//	previous->next = previous->next->next;
		//	to_del->~File();
		//}
{
//File temp;
//bool flag = false;
//temp = this->next == NULL ? temp = *this: *(this->next);	//сохраняем адрес следующего элемента (в случае, если вставляем в середину)
//flag = this->pos != (int)NULL ? true : false;

	File *previous = this;
		//while (previous->pos != (int)NULL)
	while(previous->pos!=((File*)previous->pos)->pos)
			previous = (File*)(previous->pos);

		for(int i = 0; i < n; i++)
		{
			previous = previous->next;
			if(previous == NULL)
				return;
		}
		previous = (File*)(previous->pos);
		File *temp = previous->next;
		/*if(previous->next != NULL)
			temp = previous->next;
		else return;*/

		previous->next = new File;
		previous->next->name = rfl.name;
		previous->next->extension = rfl.extension;
		previous->next->bytes = rfl.bytes;
		previous->next->next = temp;


}
};
File FileAdd()
{
	File temp;
	bool right = false;
	std::cout<<"Enter file name"<<std::endl;
	std::cin >> temp.name;
	std::cout<<"Enter file extension"<<std::endl;
	std::cin >> temp.extension ;
	while (!right){
		std::cout<<"Enter file byte"<<std::endl;
		try{
			std::string str;
			std::cin >> str;
			temp.bytes = std::stoi(str);
			break;
		}
		catch (...)
		{
			continue;
		}
	}
	return temp;

}
void operator -(File & lfl)
{
		File *previous = &lfl;
		while (previous->next->next != NULL)
			previous = previous->next;
		delete previous->next;
		previous->next = NULL;
}
void operator +(File &lfl, File const& rfl)
{
	File temp;
	bool flag = false;
//	temp = lfl.next == NULL ? temp = lfl : *lfl.next;	//сохраняем адрес следующего элемента (в случае, если вставляем в середину)
	File *templfl = &lfl;
	flag = templfl != NULL ? true : false;
	if (flag){
		//lfl.next = new File;								//выделяем новую память
		//lfl.next->name = rfl.name;						//пишем туда название
		//lfl.next->extension = rfl.extension;					//
		//lfl.next->bytes = rfl.bytes;		//
		//lfl.next->next = NULL;						//			 адрес следующего элемента (в случае, если вставляем в середину)
		//lfl.pos = rfl.pos;
										//выделяем новую память
		templfl->name = rfl.name;						//пишем туда название
		templfl->extension = rfl.extension;					//
		templfl->bytes = rfl.bytes;		//
		templfl->next = new File;						//			 адрес следующего элемента (в случае, если вставляем в середину)
		templfl->pos = rfl.pos;
	}
	else
	{
		templfl = new File;
		templfl->name = rfl.name;						//пишем туда название
		templfl->extension = rfl.extension;					//
		templfl->bytes = rfl.bytes;		//
		templfl->next = NULL;						//			 адрес следующего элемента (в случае, если вставляем в середину)
		templfl->pos = rfl.pos;
		//File* temp_ptr;
		//temp_ptr = lfl.next;
		//lfl.next = new File;
		//lfl = *lfl.next;

		//lfl.name = rfl.name;						//пишем туда название
		//lfl.extension = rfl.extension;					//			 адрес
		//lfl.bytes = rfl.bytes;		//			 количество сотрудников
		//lfl.next = temp_ptr;						//			 адрес следующего элемента (в случае, если вставляем в середину)
		//lfl.pos = rfl.pos;

		//
		//						//выделяем новую память
		//lfl.name = rfl.name;						//пишем туда название
		//lfl.extension = rfl.extension;					//			 адрес
		//lfl.bytes = rfl.bytes;		//			 количество сотрудников
		//lfl.next = new File;						//			 адрес следующего элемента (в случае, если вставляем в середину)
		//lfl.pos = rfl.pos;
		/**/
		/*File* l_ptr = &lfl;
		while(l_ptr->next !=NULL)
			l_ptr=l_ptr->next;
		l_ptr->next=new File;
		l_ptr=l_ptr->next;
		l_ptr->name=rfl.name;
		l_ptr->extension=rfl.extension;
		l_ptr->bytes=rfl.bytes;
		l_ptr->next=NULL;
		l_ptr->pos=rfl.pos;*/

	}
}
class ReadingBase
{
public: int length;
/*protected:*/	char* content;
	std::fstream basefile;
public:
	friend File* Parse(ReadingBase &);
	ReadingBase()
	{
		try
		{
			basefile.open("basefile.txt", std::ios::out | std::ios::in);
		}
		catch(...)
		{
			std::cout<<"Ошибка открытия файла"<<std::endl;
		}
		basefile.seekg(0, basefile.end);
        length = basefile.tellg();
        basefile.seekg(0, basefile.beg);

        content = new char[++length];
        basefile.getline(content, length - 1);
        content[length - 1] = '\0';
    }


		~ReadingBase()
    {
        try
        {
            delete[] content;
        }
        catch (int){}
    }
};
class sorting: public ReadingBase
{
protected:
	std::vector<char> file1;
    std::vector<char> file2;
    std::vector<char> file3;
public:
#pragma region
#pragma endregion
	/*std::string names[4];
	std::string extensions[4];
	int numberbytes[4];*/

public:
/*sorting()
{
	int tp=0;
#pragma region sorting by files
    for(int i=0;i<length;i++)
	{
		if(content[i]!=';')
		{file1.push_back(content[i]);}
		else
		{tp=i+1;break;}
	}
	 for(int i=tp;i<length;i++)
	{
		if(content[i]!=';')
		{file2.push_back(content[i]);}
		else
		{tp=i+1;break;}
	}
	  for(int i=tp;i<length;i++)
	{
		if(content[i]!=';')
		{file3.push_back(content[i]);}
		else
		{tp=i+1;break;}
	}
#pragma endregion
/*#pragma region sorting by characteristics
#pragma region file1
	  std::string name1="";
	  std::string extension1="";
	  std::string numberbytes_1="";
	  for (int i=0;i<file1.size();i++)
	  {
		  if(file1[i]!=',')
		  {name1+=file1[i];}
		  else{tp=i+1;break;}
	  }
	  for (int i=tp;i<file1.size();i++)
	  {
		  if(file1[i]!=',')
		  {extension1+=file1[i];}
		  else{tp=i+1;break;}
	  }
	  for (int i=tp;i<file1.size();i++)
	  {
		  if(file1[i]!=',')
		  {numberbytes_1=file1[i];}
		  else{tp=i+1;break;}
	  }
	  int numberbytes1=atoi(numberbytes_1.c_str());
#pragma endregion
#pragma region file2
	  std::string name2="";
	  std::string extension2="";
	  std::string numberbytes_2="";
	  for (int i=0;i<file2.size();i++)
	  {
		  if(file2[i]!=',')
		  {name2+=file2[i];}
		  else{tp=i+1;break;}
	  }
	  for (int i=tp;i<file2.size();i++)
	  {
		  if(file2[i]!=',')
		  {extension2+=file2[i];}
		  else{tp=i+1;break;}
	  }
	  for (int i=tp;i<file2.size();i++)
	  {
		  if(file2[i]!=',')
		  {numberbytes_2=file2[i];}
		  else{tp=i+1;break;}
	  }
	  int numberbytes2=atoi(numberbytes_2.c_str());
#pragma endregion
#pragma region file3
	  std::string name3="";
	  std::string extension3="";
	  std::string numberbytes_3="";
	  for (int i=0;i<file3.size();i++)
	  {
		  if(file3[i]!=',')
		  {name3+=file3[i];}
		  else{tp=i+1;break;}
	  }
	  for (int i=tp;i<file3.size();i++)
	  {
		  if(file3[i]!=',')
		  {extension3+=file3[i];}
		  else{tp=i+1;break;}
	  }
	  for (int i=tp;i<file3.size();i++)
	  {
		  if(file3[i]!=',')
		  {numberbytes_3=file3[i];}
		  else{tp=i+1;break;}
	  }
	  int numberbytes3=atoi(numberbytes_3.c_str());
#pragma endregion
#pragma endregion
	  names[0]=name1;names[1]=name2;names[2]=name3;
	  extensions[0]=extension1;extensions[1]=extension2;extensions[2]=extension3;
	  numberbytes[0]=numberbytes1;numberbytes[1]=numberbytes2;numberbytes[2]=numberbytes3;
}
*/

static File* Parse(ReadingBase &rw)
{
	//name
	//extension
	//employee
	File temp_file;
	File *prev, *Files;
	char  t_strToParse[3][20];

	for (int i = 0, row = 0, column = 0;;)
	{
		Files = i == 0 ? prev = new File : Files;	//если первый проход, то получаем адрес выделенной памяти под первый элемент
																	//иначе оставляем все как есть
		temp_file.pos = (int)prev;
		prev = i != 0 ? prev->next : prev;

		while (row < 3)
		{
			while (rw.content[i] != ';' && rw.content[i] != '\t' && rw.content[i] != '\0')
			try
			{
				t_strToParse[row][column++] = rw.content[i++];
			}
			catch (...)
			{
				printf("Кол-во символов между ; ; превысило 20 знаков");	return NULL;
			}
			t_strToParse[row][column] = '\0';	//eof char
			column = 0;							// start of string
			i++;								//skip ;
			row++;
		}
		if (i > rw.length)
		{
			((File*)temp_file.pos)->next = NULL;
			break;
		}
		row = 0;
#pragma region Инициализируем структуру
		temp_file.name = t_strToParse[0];
		temp_file.extension = t_strToParse[1];
		temp_file.bytes = std::stoi(t_strToParse[2]);


		*prev + temp_file;
#pragma endregion
	}
	return Files;
};
public: void show(File* list,int size)
{
	if(size==2)
	{
	std::cout<<"name: "<<list->name<<std::endl;
	std::cout<<"extension:"<<list->extension<<std::endl;
	std::cout<<"bytes: "<<list->bytes<<std::endl;
	std::cout<<"================================"<<std::endl;
	std::cout<<"name: "<<list->next->name<<std::endl;
	std::cout<<"extension:"<<list->next->extension<<std::endl;
	std::cout<<"bytes: "<<list->next->bytes<<std::endl;
	std::cout<<"================================"<<std::endl;
	}
#pragma region
	if(size==3)
	{
	std::cout<<"name: "<<list->name<<std::endl;
	std::cout<<"extension:"<<list->extension<<std::endl;
	std::cout<<"bytes: "<<list->bytes<<std::endl;
	std::cout<<"================================"<<std::endl;
	std::cout<<"name: "<<list->next->name<<std::endl;
	std::cout<<"extension:"<<list->next->extension<<std::endl;
	std::cout<<"bytes: "<<list->next->bytes<<std::endl;
	std::cout<<"================================"<<std::endl;
	std::cout<<"name: "<<list->next->next->name<<std::endl;
	std::cout<<"extension:"<<list->next->next->extension<<std::endl;
	std::cout<<"bytes: "<<list->next->next->bytes<<std::endl;
	std::cout<<"================================"<<std::endl;
	}
	if (size==4)
	{

	}
#pragma endregion
}
		public: void output (File* list)
	   {
		   File* work_ptr=list;
		   //while(work_ptr!=NULL)
		   std::cout<<"=============New Base============"<<std::endl;
			   std::cout<<"name: "<<list->name<<std::endl;
	           std::cout<<"extension:"<<list->extension<<std::endl;
	std::cout<<"bytes: "<<list->bytes<<std::endl;
	std::cout<<"================================"<<std::endl;
	std::cout<<"name: "<<list->next->name<<std::endl;
	std::cout<<"extension:"<<list->next->extension<<std::endl;
	std::cout<<"bytes: "<<list->next->bytes<<std::endl;
	std::cout<<"================================"<<std::endl;
	std::cout<<"name: "<<list->next->next->name<<std::endl;
	std::cout<<"extension:"<<list->next->next->extension<<std::endl;
	std::cout<<"bytes: "<<list->next->next->bytes<<std::endl;
	std::cout<<"================================"<<std::endl;
	std::cout<<"name: "<<list->next->next->next->name<<std::endl;
	std::cout<<"extension:"<<list->next->next->next->extension<<std::endl;
	std::cout<<"bytes: "<<list->next->next->next->bytes<<std::endl;
			  work_ptr = work_ptr->next;

	   }
};

void main()
{
	ReadingBase pepe;
	File *list = sorting().Parse(pepe);
	int y;
	#pragma region
	//File temp=FileAdd();
	//list->AddElement(2,temp);
	//sorting().show(list,4);
	//File()- list;
	int n =2;
#pragma endregion
	std::cout<<" "<<std::endl;
	std::cout<<"MENU"<<std::endl;
	std::cout<<"1-show base, 2- delete last element, 3-add new, 0 - exit"<<std::endl;
	std::cin>>y;
	while(y!=0)
	{if(y==1){sorting().show(list,3);}
	if(y==2){list-list;
	sorting().show(list,n);}
	if(y==3){File temp=FileAdd();
	int z;
	std::cout<<"press number of position"<<std::endl;
	std::cin>>z;
	z=z-1;
	list->AddElement(z,temp);
	sorting().output(list);}
	std::cout<<"1-show base, 2- delete last element, 3-add new, 0 - exit"<<std::endl;
	std::cin>>y;
	}
	system("PAUSE");
}