#include "FAT16.h"



uint8 BUFFER[512];
uint16 BPB_BytesPerSec; 
uint8 BPB_SecPerClus;   
uint16 BPB_RsvdSecCnt;  
uint8 BPB_NumFATs;      
uint16 BPB_RootEntCnt;  
uint16 BPB_TotSec16;    
uint16 BPB_FATSz16;     
uint32 BPB_HiddSec;     

//********************************************************************************************
void ReadBlock(uint32 LBA)
//********************************************************************************************
{
	MMC_read_sector(LBA,BUFFER); 
	return;
}

//********************************************************************************************
void WriteBlock(uint32 LBA)
//********************************************************************************************
{
//	LBA = LBA+19;
	MMC_write_sector(LBA,BUFFER);
	return;
}

//********************************************************************************************
void CopyBytes(void* S, void* D, uint16 size)
//********************************************************************************************
{
	uint8 *s = S, *d = D;
	uint16 i;
	for(i = 0; i < size; i++)
		*d++ = *s++;
}

//********************************************************************************************
uint8 IsEqual(void* A, void* B, uint8 Size)
//********************************************************************************************
{
	uint8 i, *a = A, *b = B;
	for(i = 0; i < Size; i++)
		if(a[i] != b[i])
			return 0;
	return 1;
}

//********************************************************************************************
void EmptyBytes(void *D, uint16 size)
//********************************************************************************************
{
	uint16 i;
	uint8* data = (uint8*)D;
	for(i = 0; i < size; i++)
	{
		*data++ = 0;
	}
}

//********************************************************************************************
void ReadBPB(void)
//********************************************************************************************
{
	FAT_BPB* BPB = (FAT_BPB*)BUFFER;
	ReadBlock(0);

	
	BPB_BytesPerSec = BPB->BPB_BytesPerSec;
	BPB_SecPerClus = BPB->BPB_SecPerClus; 
	BPB_RsvdSecCnt = BPB->BPB_RsvdSecCnt;
	BPB_NumFATs = BPB->BPB_NumFATs;
	BPB_RootEntCnt = BPB->BPB_RootEntCnt;
	BPB_TotSec16 = BPB->BPB_TotSec16;
	BPB_FATSz16 = BPB->BPB_FATSz16;
	BPB_HiddSec = BPB->BPB_HiddSec;

}

//********************************************************************************************
uint32 DirStartSec(void)
//********************************************************************************************
{
	return BPB_RsvdSecCnt + BPB_NumFATs * BPB_FATSz16;
}

//********************************************************************************************
uint32 DataStartSec(void)
//********************************************************************************************
{
	return (uint32)(DirStartSec() + BPB_RootEntCnt * 32 / BPB_BytesPerSec);

}

//********************************************************************************************
uint16 GetDirSecCount(void)
//********************************************************************************************
{
	return BPB_RootEntCnt * 32 / 512;
}

//********************************************************************************************
uint32 ClusConvLBA(uint16 ClusID)
//********************************************************************************************
{
	return DataStartSec() + BPB_SecPerClus * (ClusID - 2);
	
}

//********************************************************************************************
uint16 ReadFAT(uint16 Index)
//********************************************************************************************
{
	uint16 *RAM = (uint16*)BUFFER;
	ReadBlock(BPB_RsvdSecCnt + Index / 256);
	return RAM[Index % 256];
}

//********************************************************************************************
void WriteFAT(uint16 Index, uint16 Value)
//********************************************************************************************
{
	uint16 *RAM = (uint16*)BUFFER;
	uint32 SecID;
	SecID = BPB_RsvdSecCnt + Index / 256;
	ReadBlock(SecID);
	RAM[Index % 256] = Value;
	WriteBlock(SecID);
}

//********************************************************************************************
uint16 GetEmptyDIR()
//********************************************************************************************
{
	uint16 DirSecCut, DirStart, i, m, ID = 0;
	DirSecCut = GetDirSecCount();
	DirStart = DirStartSec();
	for(i = 0; i < DirSecCut; i++)
	{
		ReadBlock(DirStart + i);  
		for(m = 0; m < 16; m++)   
		{
			if((BUFFER[m * 32] == 0) || (BUFFER[m * 32] == 0xe5))
				return ID;
			else
				ID++;
		}
	}
	return ID;
}

//********************************************************************************************
uint8 GetFileID(uint8* Name, DIR* ID)
//********************************************************************************************
{
	uint16 DirSecCut, DirStart, i, m;
	DirSecCut = GetDirSecCount();         
	DirStart = DirStartSec();             
	for(i = 0; i < DirSecCut; i++)
	{
		ReadBlock(DirStart + i);
		for(m = 0; m <16; m++)
		{
			if(IsEqual(Name, &((DIR*)&BUFFER[m * 32])->FileName, 11)) 
			{
				*ID = *((DIR*)&BUFFER[m * 32]);
				return 1; 
			}
		}
	}
	return 0; 
}

//********************************************************************************************
uint16 GetNextFAT(void)
//********************************************************************************************
{
	uint16 FAT_Count, i;
	FAT_Count = BPB_FATSz16 * 256; 
	for(i = 0; i < FAT_Count; i++)
	{
		if(ReadFAT(i) == 0)
			return i;
	}
	return 0;
}

//********************************************************************************************
void ReadDIR(uint16 Index, DIR* Value)
//********************************************************************************************
{
	uint32 DirStart = DirStartSec();
	ReadBlock(DirStart + Index / 16);
	CopyBytes(&BUFFER[(Index % 16) * 32], Value, 32);
}

//********************************************************************************************
void WriteDIR(uint16 Index, DIR* Value)
//********************************************************************************************
{
	uint32 LBA = DirStartSec() + Index / 16;
	ReadBlock(LBA);
	CopyBytes(Value, &BUFFER[(Index % 16) * 32], 32);
	WriteBlock(LBA);
}
//********************************************************************************************
void CreateFile(uint8* FileName, uint32 Size)
//********************************************************************************************
{
	uint16 ClusID, ClusNum, ClusNext, i;
	DIR FileDir;
	ClusNum = Size / (BPB_SecPerClus * 512) + 1;  
	EmptyBytes(&FileDir, sizeof(DIR));            
	CopyBytes(FileName, &FileDir.FileName, 11);   
	FileDir.FilePosit.Size = Size;                
	FileDir.FilePosit.Start = GetNextFAT();       
	ClusID = FileDir.FilePosit.Start;             
	for(i = 0; i < ClusNum - 1; i++)
	{
		WriteFAT(ClusID, 0xffff);
		ClusNext = GetNextFAT();
		WriteFAT(ClusID, ClusNext);
		ClusID = ClusNext;
	}
	WriteFAT(ClusID, 0xffff);
	WriteDIR(GetEmptyDIR(), &FileDir);
}

//********************************************************************************************
void CopyFAT(void)
//********************************************************************************************
{
	uint16 FATSz16, RsvdSecCnt, i;
	FATSz16 = BPB_FATSz16;
	RsvdSecCnt = BPB_RsvdSecCnt;
	for(i = 0; i < FATSz16; i++)
	{
		ReadBlock(RsvdSecCnt + i);
		WriteBlock(RsvdSecCnt + FATSz16 + i);
	}
}

//********************************************************************************************
uint8 OperateFile(uint8 Write ,uint8* Name, uint32 Start, uint32 Length, void* Data)
//********************************************************************************************
{
	uint8 *data = Data;
	uint16 BytePerClus, SecPerClus, ClusNum, ClusID, m;
	uint32 LBA, i;
	DIR FileDir;                         
	SecPerClus = BPB_SecPerClus;         
	BytePerClus = BPB_SecPerClus * 512;  
	if(GetFileID(Name, &FileDir)!=1)
	return FIND_FILENAME;           

	ClusNum = Start / BytePerClus;
	ClusID = FileDir.FilePosit.Start;
	for(i = 0; i < ClusNum; i++)
	ClusID = ReadFAT(ClusID);


	i = (Start % BytePerClus) / 512;


	m = (Start % BytePerClus) % 512;

	LBA = ClusConvLBA(ClusID) + m;

	if(Write)
		ReadBlock(LBA);
	else
		ReadBlock(LBA++);

	goto Start;

	while(1)
	{
		ClusID = ReadFAT(ClusID); 
		LBA = ClusConvLBA(ClusID);
		for(i = 0; i < SecPerClus; i++)
		{
			if(Write)
				ReadBlock(LBA);
			else
				ReadBlock(LBA++);

			for(m = 0; m < 512; m++)
			{
Start:
				if(Write)
					BUFFER[m] = *data++;
				else
					*data++ = BUFFER[m];

				
				if(--Length == 0)
				{
					if(Write)
						WriteBlock(LBA); 
					return;
				}
			}
			if(Write)
				WriteBlock(LBA++); 
		}
	}
}