void run_read(char * string, unsigned int current_cluster, int offset, int length){

	unsigned int FirstSectorofCluster = getFirstSectorofCluster(current_cluster);
	unsigned int fatEntry = getFatEntry(current_cluster);
	unsigned int new_file_cluster;


	fseek(fp, FirstSectorofCluster+offset, SEEK_SET);

	if(length + offset > boot_region.bytes_per_sector){
		fread(strlen(string)+string,(boot_region.bytes_per_sector-offset), 1, fp);
		printf("%.*s", length, string + offset);
		length = length - (boot_region.bytes_per_sector-offset);
	}
	else{
		fread(string, length , 1, fp);
		printf("%.*s\n", length, string + offset);
		return;
	}

	if(fatEntry != 0x0FFFFFF8 || fatEntry != 0x0FFFFFFF || fatEntry != 0x00000000){
		 run_read(string, fatEntry,0,length);
	}

}

void read(unsigned int current_cluster, char * fileName, int offset, int length)  // wil
{
  int i = 0;
	int flag = 0;
	bool found = false;
	char * formatString;
	struct FAT32Dir directory = getDirectory(current_cluster, fileName);
	unsigned int fatEntry = getFatEntry(current_cluster);
	unsigned int FirstSectorofCluster = getFirstSectorofCluster(current_cluster);


	if(offset > directory.FileSize)
	{
			printf("Error! OFFSET is larger than file size\n");
			return;

		}



  if(!strcmp(getFileName((char *)directory.Name), fileName))   // check if file exist
  {
		if(directory.Attr != 0x10){


		if(length >  directory.FileSize || offset+length > directory.FileSize){
			length = directory.FileSize - offset;
			formatString = (char *)calloc(length+1, sizeof(char));
		}

			//else
			{

				for(i = 0; i < 500; i++){

					 if(openFiles[i].name != NULL && !strcmp(openFiles[i].name, getFileName(directory.Name))){

						 if(openFiles[i].mode == FILE_READ || openFiles[i].mode == FILE_READWRITE){

								 fatEntry = openFiles[i].first_cluster_num;
								 flag = offset/boot_region.bytes_per_sector;

								 while(flag != 0){
									 if(fatEntry == 0x00000000 || fatEntry == 0xFFFFFFF8){
										 return;
									 }

									 fatEntry = getFatEntry(fatEntry);
									 flag--;
							 	}
							 run_read(formatString, fatEntry, (offset%boot_region.bytes_per_sector), length);
							 found = true;
							 break;
							 /*
							 	long int hex = FirstSectorofCluster + (openFiles[i].first_cluster_num - 2) * (boot_region.bytes_per_sector * boot_region.sectors_per_cluster);
							 	unsigned char buffer[5000000];

							 	fseek(fp, hex, SEEK_SET);
							 	fread(buffer,sizeof(buffer), 1, fp);
							 	printf("%.*s\n", len, buffer + offs);
								*/
						 }
					 }
				 }

				 if(found == false)
					 printf("File [%s] is not in reading mode\n", fileName);
				 }
			 }
		else
			printf("Error! [%s] is a directory.\n", fileName);
  }

  else
  	printf("Error! [%s] does not exist.\n", fileName);
}



void run_write(unsigned int current_cluster, int offset, int len, char * string){

	unsigned int FirstSectorofCluster = getFirstSectorofCluster(current_cluster);
	unsigned int fatEntry = getFatEntry(current_cluster);
	unsigned int new_file_cluster;
	int string_offset;


	fseek(fp, FirstSectorofCluster+offset, SEEK_SET);

	if(len + offset > boot_region.bytes_per_sector){
		fwrite(string,boot_region.bytes_per_sector-offset, 1, fp);
		string_offset = (boot_region.bytes_per_sector-offset);
		len = len - (boot_region.bytes_per_sector-offset);
	}
	else{
		fwrite(string, len , 1, fp);
		return;
	}


	if(fatEntry != 0x0FFFFFF8 || fatEntry != 0x0FFFFFFF || fatEntry != 0x00000000){
		 run_write(fatEntry, 0, len, string + string_offset);
	}

	if(fatEntry == 0x0FFFFFF8 || fatEntry == 0x0FFFFFFF ){
		new_file_cluster = findEmptyCluster();
		linkNewCluster(current_cluster, new_file_cluster);
		run_write(new_file_cluster, 0, len, string+string_offset);
	}
}

void updateDirectory(struct FAT32Dir directory, unsigned int current_cluster){

	int i = 0;
	int next_free_cluster;
	struct FAT32Dir temp;
	unsigned int fatEntry = getFatEntry(current_cluster);
	unsigned int FirstSectorofCluster = getFirstSectorofCluster(current_cluster);

	fseek(fp, FirstSectorofCluster, SEEK_SET);

	while(i * sizeof(struct FAT32Dir) < boot_region.bytes_per_sector){

			fread(&temp, sizeof(struct FAT32Dir), 1, fp);

			if(!strcmp(getFileName(temp.Name), getFileName(directory.Name) )){
					fseek(fp, i*sizeof(struct FAT32Dir)+ FirstSectorofCluster, SEEK_SET);
					fwrite(&directory, sizeof(struct FAT32Dir), 1, fp);
			}

			i++;
	}

	if(fatEntry != 0x0FFFFFF8 &&fatEntry != 0x0FFFFFFF)
			updateDirectory(directory, fatEntry);

}

void write(unsigned int current_cluster, char * fileName, int offs, int len, char * string) // wil
{
	//char * dup;
	int i = 0;
	int flag = 0;
	unsigned int fatEntry;
	char * formatString;
	struct FAT32Dir directory = getDirectory(current_cluster, fileName);

	if(strlen(string) <= len){
		formatString = (char *)calloc(len, sizeof(char));
		strcpy(formatString, string);
	}

	if(!strcmp(getFileName((char *)directory.Name), fileName))
  {
		if(directory.Attr != 0x10)
		{

	    if(offs > directory.FileSize)
	    	printf("Error! OFFSET is larger than file size\n");

	     else
	     {

				 bool found = false;

				 for(i = 0; i < 500; i++)
				 {
					 if(openFiles[i].name != NULL && !strcmp(openFiles[i].name, getFileName(directory.Name)))
					 {
						 if(openFiles[i].mode == FILE_WRITE || openFiles[i].mode == FILE_READWRITE)
						 {
							 fatEntry = openFiles[i].first_cluster_num;
							 flag = offs/boot_region.bytes_per_sector;

							 while(flag != 0){
								 if(fatEntry == 0x00000000 || fatEntry == 0xFFFFFFF8){
									 return;
								 }

								 fatEntry = getFatEntry(fatEntry);
								 flag --;
							 }
							 	run_write(fatEntry, (offs%boot_region.bytes_per_sector), len, formatString);

								if(offs + len > directory.FileSize)
								{
									directory.FileSize = directory.FileSize + (strlen(string) - directory.FileSize) + offs;
									directory.Attr = 0x20;
									updateDirectory(directory, current_cluster);

							 	}

						 found = true;
						 break;
					 }
				 }

				 if(found == false)
				 	printf("File [%s] is not in writing mode\n", fileName);
			}
		}
	}

		else
			printf("Error! [%s] is a directory.\n", fileName);
  }

  else
  	printf("Error! [%s] does not exist.\n", fileName);
}