#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <io.h>
#include <fcntl.h>
#include <time.h >
#include "linear_hash.h"

extern BUCKET_BUF 		bucket;
extern DATA_BUF		data;
extern NTH_BLOCK_BUF	nth_blk_relation;
extern HASH_INFO 		hash_info;

extern long			DATA_CUR;//記錄最后最后讀入的數據塊號
extern long			NTH_BLK_CUR;//記錄最后讀入的對應信息塊號
extern long			SEARCH_CUR;

extern BUCKET_BUF		buk_buf[BUCKET_BUFFER_SIZE];
extern BUCKET_BUF		buk_over_buf[BUCKET_BUFFER_SIZE];
extern DATA_BUF			dat_buf[DATA_BUFFER_SIZE];
extern NTH_BLOCK_BUF	nth_blk_buf[NTH_BLOCK_BUFFER_SIZE];
void insert_idx(char *filename)
{
	long fd = 0;
	long dlength = 0;
	long j = 0;
	long data_volume = 0;
	long i = 0;
	long p = 0;
	long flag = 0;
	
	fd = open("all200000.dat", O_RDWR);
	dlength = filelength(fd)/BLOCK_SIZE;
	close(fd);
	
	insert_to_data_file(filename);
	
	while(dlength != -1)
	{
		j = 0;
		data_volume = 0;
		for(i = 0; i < DATA_BUFFER_SIZE; i++)
		{
			dat_buf[i].from_blk_no = -1;
			for(p = 0; p < LONG_IN_BLOCK; p++)
			{
				dat_buf[i].key[p] = -1;
			}
		}
		while ( j < DATA_BUFFER_SIZE )//讀入需要加入的數據塊
		{
			if( dat_buf[j].from_blk_no == -1 )
			{
				flag = read_dat("all200000.dat", dlength); 
				if(flag != 0)
				{
				dat_buf[j] = data;
				data_volume += flag;
				dlength++;
				}
				else
				{
					dlength = -1;
					break;
				}
			}
			j++;
		}
		scan_data(data_volume);
	}
}

void insert_to_data_file(char *filename)
{
	long fd = 0;
	long dlength = 0;
	long ilength = 0;
	long flag = 0;
	long i = 0;
	long j = 0;
	FILE *fp = NULL;
	fd = open("all200000.dat", O_RDWR);
	dlength = filelength(fd)/BLOCK_SIZE;
	close(fd);
	fd = open(filename, O_RDWR);
	ilength = filelength(fd)/BLOCK_SIZE;
	close(fd);
	
	fp = fopen("all200000.dat", "rb+");
	for( i = 0; i < ilength; i++)
		get_blk(fp);
	fclose(fp);
	
	for(i = 0; i < ilength; i++)
	{
		for( j = 0; j < DATA_BUFFER_SIZE; j++)
			dat_buf[j].from_blk_no = -1;
		
		for( j = 0; j < DATA_BUFFER_SIZE; j++)
		{
			flag = read_dat(filename, i);
			if(flag != 0)
			{
				dat_buf[j] = data;
				i++;
			}
			else
				break;
		}
		for( j = 0; j < DATA_BUFFER_SIZE; j++)
		{
			if(dat_buf[j].from_blk_no != -1)
			{
				data = dat_buf[j];
				write_dat("all200000.dat", dlength);
				dlength++;
			}
		}
	}
}

void insert_single(long key)
{
	long key_blk_no = -1;
	long key_offset = -1;
	long found = 1;
	long flag = 0;
	long add_in = 0;
	long old_hash_info_hkey_i = 0;
	long old_hash_info_bucket_no = 0;
	long hkey = 0;
	long power = 0;
	long change_in = 0;
	long i = 0;
	long j = 0;
	FILE *fp = NULL;
	if(key == -1)
		return;

	while(found)
	{
		flag = read_dat("all200000.dat", j);
		if(flag != 0)
		{
			for( i = 0; i < LONG_IN_BLOCK; i++)
			{
				if(data.key[i] == -1 || data.key[i] == key)
				{
					data.key[i] = key;
					key_blk_no = j;
					key_offset = sizeof(long) * i;
					write_dat("all200000.dat", data.from_blk_no);
					found = 0;
					break;
				}
			}
			j++;
		}
		else
		{
			fp = fopen("all200000.dat", "rb+");
			get_blk(fp);
			fclose(fp);
			read_dat("all200000.dat", j + 1 );
			data.key[0] = key;
			write_dat("all200000.dat", data.from_blk_no);
			key_blk_no = j + 1;
			key_offset = 0;
			found = 0;
			break;
		}
	}
	
	power = pow(2, hash_info.hkey_i - 1);
	
	if(key != -1)
	{
		hkey = add_in_which(key, hash_info.hkey_i);
		if(hkey < hash_info.bucket_no)
			add_in = hkey;
		else
			add_in = hkey - power;
	}
	old_hash_info_hkey_i = hash_info.hkey_i;
	old_hash_info_bucket_no = hash_info.bucket_no;
	renew_hash_info(1);
	add_hash_table_bucket("hash_table.idx", old_hash_info_bucket_no);
	
	if(old_hash_info_hkey_i == hash_info.hkey_i && old_hash_info_bucket_no == hash_info.bucket_no)
	{
		insert_single_read_nth_blk(add_in, key, key_blk_no, key_offset, 1);
	}
	
	if(old_hash_info_hkey_i == hash_info.hkey_i && old_hash_info_bucket_no != hash_info.bucket_no)
	{
		change_in = old_hash_info_bucket_no - power;
		insert_single_read_nth_blk(change_in, key, key_blk_no, key_offset, 2); 
	}
	
	if(old_hash_info_hkey_i != hash_info.hkey_i && old_hash_info_bucket_no != hash_info.bucket_no)
	{
		change_in = old_hash_info_bucket_no - power * 2;
		insert_single_read_nth_blk(change_in, key, key_blk_no, key_offset, 2); 
	}
}

void insert_single_read_nth_blk(long fhkey, long key, long blk_no, long offset, long any)
{
	long j = 0;
	long i = 0;
	long flag = 0;
	NTH_BLK_CUR = 0;
	while( j < NTH_BLOCK_BUFFER_SIZE )//讀入對應關系文件塊
	{
		if (nth_blk_buf[j].from_blk_no == -1)
		{
			flag = read_nth_blk("nth_block.dat", NTH_BLK_CUR);
			if(flag == 1)
			{
				nth_blk_buf[j] = nth_blk_relation;
				for( i = 0; i < NTH_BLOCK_IN_BLOCK; i++)
				{
					if(nth_blk_buf[j].nth_blk[i].nth_bucket == fhkey)
					{
						insert_single_scan_in_buf_nth_blk(fhkey, key, blk_no, offset, any);
						goto ZZ;
					}
				}
				NTH_BLK_CUR++;
			}
			else
			{
				break;
			}
		}
		j++;
	}
	ZZ: ;
}

void insert_single_scan_in_buf_nth_blk(long fhkey, long key, long blk_no, long offset, long any)
{
	long i = 0;
	long j = 0;
	long m = 0;
	long n = 0;
	while( m < NTH_BLOCK_BUFFER_SIZE)
	{
		if(nth_blk_buf[m].from_blk_no != -1)
		{
			while( n < NTH_BLOCK_IN_BLOCK)
			{
				if( nth_blk_buf[m].nth_blk[n].nth_bucket == fhkey)
				{
					read_idx("hash_table.idx", nth_blk_buf[m].nth_blk[n].nth_bucket, nth_blk_buf[m].nth_blk[n].blk_no);
					while(j < BUCKET_BUFFER_SIZE)
					{	
						i = 0;
						while(bucket.buk.blk_no != -1)//判斷當前桶的溢出桶個數
						{
							read_idx("hash_table.idx", nth_blk_buf[m].nth_blk[n].nth_bucket, bucket.buk.blk_no);
							i++;
						}
						
						if( (BUCKET_BUFFER_SIZE - j) >= (i + 1))//將桶和溢出桶讀入
						{
							read_idx("hash_table.idx", nth_blk_buf[m].nth_blk[n].nth_bucket, nth_blk_buf[m].nth_blk[n].blk_no);
							buk_buf[j] = bucket;
							j++;
							while(bucket.buk.blk_no != -1)
							{
								read_idx("hash_table.idx", nth_blk_buf[m].nth_blk[n].nth_bucket, bucket.buk.blk_no);
								buk_buf[j] = bucket;
								j++;
							}
							if ( j == BUCKET_BUFFER_SIZE )
							{
								if(any == 1)
								insert_single_data_operate_1(fhkey, key, blk_no, offset);
								if(any == 2)
								insert_single_data_operate_2(fhkey, key, blk_no, offset);
								j = 0;
								break;
							}
							else
								break;
						}
						else
						{
							if(any == 1)
							insert_single_data_operate_1(fhkey, key, blk_no, offset);
							if(any == 2)
							insert_single_data_operate_2(fhkey, key, blk_no, offset);
							j = 0;
							break;
						}
					}
				}
				n++;
			}
		}
		m++;
	}
	if(any == 1)
	insert_single_data_operate_1(fhkey, key, blk_no, offset);
	if(any == 2)
	insert_single_data_operate_2(fhkey, key, blk_no, offset);
	
	for( j = 0; j < NTH_BLOCK_BUFFER_SIZE; j++ )
	{
		nth_blk_buf[j].from_blk_no = -1;
	}
}
void insert_single_data_operate_1(long fhkey, long key, long blk_no, long offset)
{
	long 	m = 0;
	long 	n = 0;
	long 	found = 0;
	long 	fd = 0;
	long 	length = 0;
	long 	i = 0;
	FILE 	*fp =NULL;
	while( m < BUCKET_BUFFER_SIZE )
	{
		if(fhkey == buk_buf[m].nth_bucket)
		{
			found = 0;
			while(fhkey == buk_buf[m].nth_bucket && found == 0)
			{
				n = 0;
				while( n < HASH_SPACE && found == 0)
				{
					if(buk_buf[m].buk.hk_addr[n].hkey == -1)
					{
						buk_buf[m].buk.hk_addr[n].hkey = key;
						buk_buf[m].buk.hk_addr[n].to_rcd.blk_no = blk_no;
						buk_buf[m].buk.hk_addr[n].to_rcd.offset = offset;
						buk_buf[m].buk.rcd_no++;
						bucket = buk_buf[m];
						printf("INSERT OK!\n");
						write_idx("hash_table.idx", bucket.from_blk_no);
						found = 1;
						goto TT;
					}
					n++;
				}
				m++;
			}
			m--;
			if(found == 0)
			{
				fp = fopen("hash_table.idx", "rb+");
				get_blk(fp);
				fclose(fp);
				fd = open("hash_table.idx", O_RDWR);
				length = filelength(fd)/BLOCK_SIZE;
				close(fd);
				buk_buf[m].buk.blk_no = length - 1;
				buk_buf[m].change_flag = 1;
				read_idx("hash_table.idx", buk_buf[m].nth_bucket, length - 1);
				bucket.buk.blk_no = -1;
				bucket.buk.rcd_no = 1;
				bucket.buk.hk_addr[0].hkey = key;
				bucket.buk.hk_addr[0].to_rcd.blk_no = blk_no;
				bucket.buk.hk_addr[0].to_rcd.offset = offset;
				printf("INSERT OK!\n");
				write_idx("hash_table.idx", length - 1);
				bucket = buk_buf[m];
				write_idx("hash_table.idx", bucket.from_blk_no);
			}
		}
		m++;
	}
	TT: ;
	for(i = 0; i < BUCKET_BUFFER_SIZE; i++)
	{
		buk_buf[i].from_blk_no = -1;
		buk_buf[i].change_flag = 0;
	}	
}

void insert_single_data_operate_2(long fhkey, long key, long blk_no, long offset)
{
	long m = 0;
	long n = 0;
	long p = 0;
	long found = 0;
	long i = 0;
	long fd = 0;
	long length = 0;
	FILE *fp = NULL;
	
	fp = fopen("hash_table.idx", "rb+");
	get_blk(fp);
	fclose(fp);
	fd = open("hash_table.idx", O_RDWR);
	length = filelength(fd)/BLOCK_SIZE;
	close(fd);
	read_idx("hash_table.idx", hash_info.bucket_no - 1, length - 1);
	bucket.buk.blk_no = -1;
	bucket.buk.rcd_no = 1;
	bucket.buk.hk_addr[0].hkey = key;
	bucket.buk.hk_addr[0].to_rcd.blk_no = blk_no;
	bucket.buk.hk_addr[0].to_rcd.offset = offset;
	bucket.change_flag = 1;
	
	while( m < BUCKET_BUFFER_SIZE )
	{
		if(fhkey == buk_buf[m].nth_bucket)
		{
			while(fhkey == buk_buf[m].nth_bucket)
			{
				n = 0;
				while( n < HASH_SPACE )
				{
					if(add_in_which(buk_buf[m].buk.hk_addr[n].hkey, hash_info.hkey_i) == hash_info.bucket_no - 1)
					{
						found = 0;
						p = 0;
						while( p < HASH_SPACE )
						{
							if(bucket.buk.hk_addr[p].hkey == -1)
							{
								bucket.buk.hk_addr[p] = buk_buf[m].buk.hk_addr[n];
								buk_buf[m].buk.hk_addr[n].hkey = -1;
								buk_buf[m].buk.hk_addr[n].to_rcd.blk_no = -1;
								buk_buf[m].buk.hk_addr[n].to_rcd.offset = -1;
								bucket.buk.rcd_no++;
								found = 1;
								break;
							}
							p++;
						}
						if(found == 0)
						{
							bucket.buk.blk_no = length;
							write_idx("hash_table.idx", bucket.from_blk_no);
							fp = fopen("hash_table.idx", "rb+");
							get_blk(fp);
							fclose(fp);
							read_idx("hash_table.idx", hash_info.bucket_no - 1, length);
							bucket.buk.blk_no = -1;
							bucket.buk.rcd_no = 1;
							bucket.buk.hk_addr[0] = buk_buf[m].buk.hk_addr[n];
						}
						buk_buf[m].buk.rcd_no--;
						buk_buf[m].change_flag = 1;
					}
					n++;
				}
				m++;
			}
			m--;
		}
		m++;
	}
	
	for( i = 0; i < BUCKET_BUFFER_SIZE; i++)
		if(buk_buf[i].change_flag == 1)
			write_idx("hash_table.idx", buk_buf[i].from_blk_no);
	
	for(i = 0; i < BUCKET_BUFFER_SIZE; i++)
	{
		buk_buf[i].from_blk_no = -1;
		buk_buf[i].change_flag = 0;
	}		
}