#include <stdlib.h>
#include <iostream.h>
#include <fstream.h>

#include "sym.h"
#include "block.h"
#include "allocate.h"
#include "table.h"   


Table * s;
int  findTable(char * tableName)   //if not find return -1
{
	FIELD v,k;
	FIELDREC vl,kr;

	k.name = "Table_Name";
	v.name = "Valid";

	s->findField(k);
	s->findField(v);
	for(int i=0;i<(long)(s->getTotalRec());i++)
	{
		vl = s->getOneFieldRecord(v,i);
		if(atoi(vl.value))
		{
			kr=s->getOneFieldRecord(k,i);
			if(!strcmp(tableName,kr.value))
				return i;
		}
	}
	return -1;

}

void create_databse(char * fileName)
{
	
	f->open(fileName,ios::in|ios::out|ios::binary);
	if(f->fail())
		cout<<"File \""<<fileName<<"\" can not create.";
	else
	{	
			Block::writeEmpty(0,32);  //initial first 32 blocks						
			super=new Block();
			super->write(32,4,0);	//file length initial to 32 block(64k)
			super->write(1,4,4);    //system table located in block 1
			super->write(0x80,1,256);//write bit map  1000 0000 B
			super->save();
			unsigned  long t = allocateBlock();
			systemTableBlock=new Block(t);		//initial system table	
						
			s=new Table(systemTableBlock);
			FIELD v,tableName,node,owner;
			v.valid=1;
			v.length=1;
			v.type = BYTE;
			v.nl=0;
			v.key = 0;
			v.name = "Valid";
			tableName.valid=1;
			tableName.length = 128+1;
			tableName.type = CHAR;
			tableName.nl=0;
			tableName.key = 1;  //Primary key;
			tableName.name = "Table_Name";
			node.valid=1;
			node.length=4;
			node.type = LONG;
			node.nl=0;
			node.key = 0;
			node.name = "Index_Node";
			owner.valid=1;
			owner.length = 128+1;
			owner.type = CHAR;
			owner.nl=0;
			owner.key = 0;
			owner.name = "owner";

			s->addField(v);
			s->addField(tableName);
			s->addField(node);
			s->addField(owner);

			FIELDREC system[4];
			system[0].value="1";
			system[0].type = BYTE;
			system[1].value = "System";
			system[1].type = CHAR;
			system[2].value = "1";
			system[2].type = LONG;
			system[3].value = "FOXAGE";
			system[3].type = CHAR;

			s->addRecord(system);			
			cout<<"File create successfully."<<endl;
			s->listField();
	}
			
}


void create_table(char * input,int & readPointer,char * word)
{
	SYMBOL w;
	char tableName[128];
	FIELDNODE * head,* p,* temp;
	int count=0,i;

	w=getSym(input,readPointer,word);
	if(w!=IDENT)
	{
		cout<<"Eligle table name!"<<endl;
		return;
	}
	strcpy(tableName,word);	
	w=getSym(input,readPointer,word);
	if(w!=LPAREN)
	{
		cout<<"\'(\' expected!"<<endl;
		return;
	}
	
	head = new FIELDNODE;
	head->f.valid =1;
	head->f.name = "Valid";
	head->f.key =0;
	head->f.length =1;
	head->f.nl = 0;
	head->f.type = BYTE;
	head->next =NULL;
	p=head;
	do{
		w=getSym(input,readPointer,word);
		if(w==IDENT){
			count++;
			temp = new FIELDNODE;
			temp->f.name = new char[247];
			strcpy(temp->f.name,word);
			w=getSym(input,readPointer,word);
			temp->f.type=w;
			temp->f.nl = 1;
			temp->f.key = 0;
			temp->f.valid =1;
			switch(w)
			{
			case BYTE:
				temp->f.length = 1;
				w=getSym(input,readPointer,word);
				break;
			case INT:
				temp->f.length = 2;
				w=getSym(input,readPointer,word);
				break;
			case LONG:
				temp->f.length = 4;
				w=getSym(input,readPointer,word);
				break;
			case CHAR:
				w=getSym(input,readPointer,word);
				if(w==LPAREN)
				{
					w=getSym(input,readPointer,word);
					if(w==NUM)
					{
						temp->f.length =atoi(word)+1;
						w=getSym(input,readPointer,word);
						if(w!=RPAREN)
						{
							cout<<"\')\' expected."<<endl;
							return;
						}
						w=getSym(input,readPointer,word);
					}
					else
					{
						cout<<"Number needed to define a CHAR."<<endl;
						return;
					}
					
				}
				else
				{
					cout<<"Field "<<temp->f.name<<" muust specify a length!"<<endl;
					return;
				}
				break;
			default:	
					cout<<"Unknow data type."<<endl;
					return;
			}
			if(w==NOT)
			{
				w=getSym(input,readPointer,word);
				if(w!=NL)
				{
					cout<<"Unknow command."<<endl;
					return;
				}
				temp->f.nl=0;
				w=getSym(input,readPointer,word);
				
			}

			p->next=temp;
			p=p->next;

		}
		else
		{
			if(w==PRIMARY)
			{
				w=getSym(input,readPointer,word);
				if(w!=KEY)
				{
					cout<<"Unkown word!"<<endl;
					return;
				}
				w=getSym(input,readPointer,word);
				FIELDNODE * a;
				a=head->next;
				for(i=0;i<count;i++)
				{
					if(!strcmp(a->f.name,word))
					{
						a->f.key=1;
						break;
					}
					a=a->next;
				}
			}
			w=getSym(input,readPointer,word);
		}
		
	}while(w==COMMA);
	if(w!=RPAREN)
	{
		cout<<"\')\' expected."<<endl;
		return;
	}

	if(findTable(tableName)!=-1)
	{
		cout<<"Table "<<tableName<<" already exist."<<endl;
		return;
	}
	FIELDNODE * a;
	unsigned long newTableIndex=allocateBlock();
	char indexValue[20];
	Block b(newTableIndex);
	Table newTable(&b);
	

	//add record in system table
	FIELDREC system[4];
	system[0].value="1";
	system[0].type = BYTE;
	system[1].value = tableName;
	system[1].type = CHAR;
	itoa((int)newTableIndex,indexValue,10);
	system[2].value = indexValue;
	system[2].type = LONG;
	system[3].value = "FOXAGE";
	system[3].type = CHAR;
	if(s->addRecord(system))
	{
		cout<<"Table already exist."<<endl;
		return;
	}
	
	//analysis ok,begin to write table
	a=head;
	for(i=0;i<=count;i++)
	{
		newTable.addField(a->f);
		a=a->next;
	}

			
	cout<<"Table create successfully."<<endl;
	
}

void alter_table(char * input,int & readPointer,char * word)
{
	SYMBOL w;
	char tableName[128];
	int i;
	FIELD f,indexNode;
	FIELDREC fr;
	Block indexBlock;
	
	
	w=getSym(input,readPointer,word);
	if(w!=TABLE)
	{
		cout<<"Unknow command."<<endl;
		return;
	}
	w=getSym(input,readPointer,word);
	if(w!=IDENT)
	{
		cout<<"Tell me which table!";
		return;
	}
	strcpy(tableName, word);
	w=getSym(input,readPointer,word);
	i=findTable(tableName);
	if(i==-1)
	{
		cout<<"Talbe do not exist."<<endl;
		return;
	}

	indexNode.name="Index_Node";
	s->findField(indexNode);
	fr=s->getOneFieldRecord(indexNode,i);
	indexBlock.load(atoi(fr.value));
	Table thisTable(&indexBlock);
	

	switch(w)
	{
	case ADD:
		w=getSym(input,readPointer,word);
		if(w==IDENT){		
			f.name = new char[247];
			strcpy(f.name,word);
			w=getSym(input,readPointer,word);
			f.type=w;
			f.nl = 1;
			f.key = 0;
			f.valid =1;
			switch(w)
			{
			case BYTE:
				f.length = 1;
				w=getSym(input,readPointer,word);
				break;
			case INT:
				f.length = 2;
				w=getSym(input,readPointer,word);
				break;
			case LONG:
				f.length = 4;
				w=getSym(input,readPointer,word);
				break;
			case CHAR:
				w=getSym(input,readPointer,word);
				if(w==LPAREN)
				{
					w=getSym(input,readPointer,word);
					if(w==NUM)
					{
						f.length =atoi(word)+1;
						w=getSym(input,readPointer,word);
						if(w!=RPAREN)
						{
							cout<<"\')\' expected."<<endl;
							return;
						}
						w=getSym(input,readPointer,word);
					}
					else
					{
						cout<<"Number needed to define a CHAR."<<endl;
						return;
					}					
				}
				else
				{
					cout<<"Field "<<f.name<<" must specify a length!"<<endl;
					return;
				}
				break;
			default:	
					cout<<"Unknow data type."<<endl;
					return;
			}
			thisTable.addField(f);
			cout<<"Filed "<<f.name<<" add successfully."<<endl;
			return;

		}
		else
		{
			if(w==PRIMARY)
			{
				w=getSym(input,readPointer,word);
				if(w!=KEY)
				{
					cout<<"Unkown word!"<<endl;
					return;
				}
				w=getSym(input,readPointer,word);
				if(w==IDENT)
				{
					if(!thisTable.changeKey(word))
					{
						cout<<"No such filed.";
						return;
					}
					cout<<"Primary key changed."<<endl;
				}				
			}
		}
		break;
	case DROP:
		w=getSym(input,readPointer,word);
		if(w!=IDENT)
		{
			cout<<"Can field name like this?"<<endl;
			return;
		}
		FIELD f;
		f.name = new char[247];
		strcpy(f.name,word);
		
		if(thisTable.deleteField(f))
		{
			cout<<"Field "<<f.name<<" delete successfully."<<endl;			
		}
		else
		{
			cout<<"No such field in table "<<tableName<<"."<<endl;
			return;
		}
	}		
}

void drop_table(char * input,int & readPointer,char * word)
{
	SYMBOL w;
	int toDrop;
	FIELD v;
	v.name="Valid";

	w=getSym(input,readPointer,word);
	if(w!=IDENT)
	{
		cout<<"Tell me which table!"<<endl;
		return;
	}
	toDrop=findTable(word);
	if(toDrop==-1)
	{
		cout<<"Table "<<word<<" do not exist.";
		return;
	}
	s->deleteRecord(toDrop);
	cout<<"Table "<<word<<" droped successfully."<<endl;
}



void describe_table(char * tableName){
	int i=findTable(tableName);
	if(i==-1)
		cout<<tableName<<" do not existt.";
	else
	{
		FIELD k;
		FIELDREC rk;
		Block b;
		
		k.name = "Index_Node";
		s->findField(k);
		rk=s->getOneFieldRecord(k,i);
		b.load((unsigned long)atoi(rk.value));
		Table t(&b);
		t.listField();
	}
}

void insert_into(char * input,int & readPointer,char * word)
{
	SYMBOL w;
	int toInsert,i;
	FIELDREC fr,* newValues;
	FIELD node;	
	node.name = "Index_Node";

	w=getSym(input,readPointer,word);
	if(w!=INTO)
	{
		cout<<"\'INTO\' expected after INSERT."<<endl;
		return;
	}
	w=getSym(input,readPointer,word);
	if(w!=IDENT)
	{
		cout<<"Tell me which table!"<<endl;
		return;
	}

	toInsert=findTable(word);
	if(toInsert==-1)
	{
		cout<<"Table "<<word<<" do not exist.";
		return;
	}
	s->findField(node);
	fr=s->getOneFieldRecord(node,toInsert);
	Block indexNode;
	indexNode.load(atoi(fr.value));
	Table thisTable(&indexNode);

	w=getSym(input,readPointer,word);
	if(w!=VALUES)
	{
		cout<<"\'VALUES\' expected."<<endl;
		return;
	}
	w=getSym(input,readPointer,word);
	if(w!=LPAREN)
	{
		cout<<"\'(\' expected after word VALUES."<<endl;
		return;
	}
	
	newValues = new FIELDREC[thisTable.getRealField()];
	newValues[0].value="1";
	newValues[0].type = BYTE;
	for(i=1;i<thisTable.getRealField();i++)
	{
		w=getSym(input,readPointer,word);
		switch(w)
		{
		case RPAREN:
			if(i<thisTable.getRealField()-1)
			{
				cout<<"Not enough data."<<endl;
				return;
			}
		case COMMA:
			newValues[i].value=0;
			newValues[i].type = NL;
			break;
		case TEXT:
			newValues[i].type = CHAR;
			newValues[i].value = new char[1024];
			strcpy(newValues[i].value,word);
			w=getSym(input,readPointer,word);
			break;
		case NUM:
		case FLOAT:
			newValues[i].type = NUM;
			newValues[i].value = new char[40];
			strcpy(newValues[i].value,word);
			w=getSym(input,readPointer,word);
			break;
		default:
			cout<<"Not a supported data type."<<endl;
			return;

		}
		if(i==thisTable.getRealField()-1&&w!=RPAREN)
		{
			cout<<"Too many data or \')\' missing."<<endl;
			return;
		}
		if(i<thisTable.getRealField()-1&&w!=COMMA)
		{
			cout<<"Datas must be seperated by \',\'"<<endl;
			return;