#include "scene.h"

#include "LZO\miniLZO.h"


int LZWMakeCompression(u8 *source, int lenght, u8 *dest);
int LZWMakeDecompression(u8 *source, int lenghtRes, u8 *dest);
#define ZIPBUFSIZE (8192)
u8 ZIPBUF[ZIPBUFSIZE + 256];
u8 LZOWRK[LZO1X_1_MEM_COMPRESS];
static u32 LZO_IsInit = 0;
u32 ZIPBufP = 0;
u32 ZIPBufS = 0;
u32 ZIPBufMETHOD = 0;


int COMPRESS(u8 *source, int lenght, u8 *dest)
{
	if (!LZO_IsInit) lzo_init();
	LZO_IsInit = 0;

	switch (ZIPBufMETHOD)
	{
		case 0:// No compression
			memcpy(dest,source,lenght);
			return lenght;
		case 1:// Yousri compression
			return LZWMakeCompression(source, lenght, dest);
		case 2:
			lzo_uint Dst;
			lzo1x_1_compress( source, lenght , dest , &Dst , LZOWRK );
			return Dst;
	}
	return 0;
}
int UNCOMPRESS(u8 *source, int lenght, u8 *dest)
{
	if (!LZO_IsInit) lzo_init();
	LZO_IsInit = 0;

	switch (ZIPBufMETHOD)
	{
		case 0:// No decompression
			memcpy(dest,source,lenght);
			return lenght;
		case 1:// Yousri decompression
			return LZWMakeDecompression(source, lenght, dest);
		case 2:
			lzo_uint Dst;
			lzo1x_decompress( source , lenght , dest , &Dst , NULL);//*/
			return Dst;
			//lzo_uint

	}
	return 0;
}


//#define COMP_TEST
u32 ZIPMODEW = 0;
u32 ZIPFlush(FILE *DST)
{

	if (!LZO_IsInit) lzo_init();
	LZO_IsInit = 0;

	u8 CompB[ZIPBUFSIZE+256];
	u32 Size;
	Size = COMPRESS((u8*)ZIPBUF, ZIPBufP, CompB);
#ifdef COMP_TEST
	u8 DECOMPTEST[ZIPBUFSIZE+256];
	u8 DECOMPTESTS[ZIPBUFSIZE+256];
	u32 TESTSIZE;
	memset(DECOMPTEST,0,sizeof(DECOMPTEST));
	memset(DECOMPTESTS,0,sizeof(DECOMPTESTS));
	memcpy(DECOMPTESTS,CompB,Size);
	UNCOMPRESS((u8*)DECOMPTESTS, Size, DECOMPTEST);
	TESTSIZE = memcmp(ZIPBUF,DECOMPTEST,ZIPBufP);
	if (TESTSIZE != 0)
		*(u32 *)0 = *(u32 *)4;// ABSOLUTE CRASH 
#endif
	fwrite(&Size,1,4,DST);
	fwrite(CompB,1,Size,DST);
	return 0;
}

u32 ZIPWrite(const void *bufVOID,u32 sizeT,u32 sizeW,FILE *DST)
{
	if (!LZO_IsInit) lzo_init();
	LZO_IsInit = 0;
    

	u8 *bufu8;
	bufu8 = (u8 *)bufVOID;
	if (ZIPMODEW == 0) ZIPMODEW = 1;
	if (ZIPMODEW == 2) return 0;
	ZIPMODEW = 1;
	u32 size = sizeT * sizeW;

	while (ZIPBufP+size > ZIPBUFSIZE)
	{
		u32 LocalSize;
		LocalSize = ZIPBUFSIZE - ZIPBufP;
		memcpy(ZIPBUF+ZIPBufP,bufu8,LocalSize);
		bufu8 += LocalSize;
		size -= LocalSize;
		ZIPBufP += LocalSize;
		ZIPFlush(DST);
		ZIPBufP = 0;
	}
	
	memcpy(ZIPBUF+ZIPBufP,bufu8,size);
	ZIPBufP += size;
	return 1;
}


u32 ZIPRead(void *bufVOID,u32 sizeT,u32 sizeW,FILE *DST)
{

	if (!LZO_IsInit) lzo_init();
	LZO_IsInit = 0;
	memset(bufVOID,0,sizeT * sizeW);

	u8 *bufu8 = (u8 *)bufVOID;
	if (ZIPMODEW == 0) {ZIPBufS = 0;ZIPMODEW = 2;ZIPBufP = 0;};
	if (ZIPMODEW == 1) return 0;

	u32 size = sizeT * sizeW;
	u32 FlushS;
	u32 SizeBase = size;
	while (size)
	{
		FlushS = ZIPBufS;
		if (FlushS > size) FlushS = size;
		memcpy(bufu8,ZIPBUF + ZIPBufP,FlushS);
		size -= FlushS;
		ZIPBufP += FlushS;
		ZIPBufS -= FlushS;
		bufu8+=FlushS;
		if (size)
		{
			/* recompute ZIPBUF */
			u32 CompSize,DECompSize;
			u8 CompB[ZIPBUFSIZE+256];
			ZIPBufP = 0;
			DECompSize = 0;
			if (fread(&CompSize,1,4,DST) == 4)
			{
				if (fread(CompB,1,CompSize,DST) == CompSize)
				{
					DECompSize = UNCOMPRESS((u8*)CompB, CompSize, (u8*)ZIPBUF);
				} else
					DECompSize = 0;
			} 
			ZIPBufS = DECompSize;
			if (!DECompSize) 
			{
				return 0;
			}
		}
	}
	return SizeBase - size;
}
u32 ZIPClose(FILE *DST)
{
	if (ZIPMODEW == 1)
	{
		// flush  
		ZIPFlush(DST);
	}
	ZIPMODEW = ZIPBufP = 0;
	return 0;
}


// 0 = No compression
// 1 = yousri
// 2 = LZO
void ZIPSetMode(u32 Mode)
{
	ZIPBufMETHOD = Mode;
}