#include "memory.h"
#include "string.h"
#include "HeadDetector.h"
#include "Viola2.h"
#include "stdlib.h"
#include "stdio.h"
#include "CCZip.h"

#define SCALAR_DISC_PO2 8
#define SCALAR_DISC (1<<SCALAR_DISC_PO2)
#define VECTOR_DIM_SQR 4
#define VECTOR_DIM (VECTOR_DIM_SQR * VECTOR_DIM_SQR)
#define VECTOR_COMB (((VECTOR_DIM - 1 ) * VECTOR_DIM) / 2)

typedef struct FEAT_Vector_
{
	u8 Scalar[VECTOR_DIM];
} FEAT_Vector;


typedef struct Feature_Comb2_Map_
{
	u32 Bits[8][SCALAR_DISC];
} Feature_Comb2_Map;


typedef struct Feature_TYPE_
{
	Feature_Comb2_Map Maps[VECTOR_COMB];
	s32 XYDOptimized[VECTOR_DIM];
} Feature_TYPE;


void*	FEAT_NewBase()
{
	Feature_TYPE *FeatMap;
	FeatMap = (Feature_TYPE *)malloc(sizeof(Feature_TYPE));
	memset(FeatMap , 0 , sizeof(FeatMap));
	return (void*)FeatMap;
}

void*	FEAT_LoadSaveBase(u32 B_Eye_Mouse_Nose,void *FeatMap)
{
	char FeatName[1024] = "";
	char Mode[3];
	if (FeatMap != NULL) 
		sprintf(Mode , "wb");
	else
		sprintf(Mode , "rb");

	switch (B_Eye_Mouse_Nose)
	{
	case 0:strcpy(FeatName,".\\IDs\\Eyes.Feat");			break;
	case 1:strcpy(FeatName,".\\IDs\\MouseCorner.Feat");		break;
	case 2:strcpy(FeatName,".\\IDs\\Nose.Feat");			break;
	case 3:strcpy(FeatName,".\\IDs\\Mouse_UP.Feat");		break;
	case 4:strcpy(FeatName,".\\IDs\\Mouse_DOWN.Feat");		break;
	}

	if (*FeatName)
	{
		CCZip ZIP;
		ZIP.ZIPSetMode(2);
		if (!ZIP.ZIPOpen(FeatName, Mode))
			return NULL;
		if (FeatMap != NULL) 
		{
			ZIP.ZIPWrite(FeatMap,1,sizeof(Feature_TYPE));
		} else
		{
			FeatMap = (Feature_TYPE *)malloc(sizeof(Feature_TYPE));
			memset(FeatMap , 0 , sizeof(FeatMap));
			ZIP.ZIPRead(FeatMap,1,sizeof(Feature_TYPE));
		}
		ZIP.ZIPClose();
		return (void*)FeatMap;
	} else
		return NULL;
}

u32 FEAT_TestMap(Feature_TYPE *FeatMap,FEAT_Vector *pV)
{
	u32 REs;
	REs = 1;
	Feature_Comb2_Map *Map;
	Map = FeatMap->Maps;
#define ErrorEMBase 5
	u32 EM = ErrorEMBase;
	for (int i = 0 ; i < VECTOR_DIM - 1 ; i++)
		for (int j = i + 1 ; j < VECTOR_DIM ; j++)
		{
			u32 REsLucky;
			REsLucky = REs;
			REs &= (Map->Bits[pV->Scalar[j]>>5][pV->Scalar[i]] >> (pV->Scalar[j]&31));
			
			if (!REs) 
			{
				if (EM)
				{
					REs = REsLucky;
					EM--;
				} else
					return 0;
			}

			Map++;
		}
	EM = 1 + EM - ErrorEMBase;
	return EM;
}

void FEAT_SetVector(Feature_TYPE *FeatMap,FEAT_Vector *pV)
{
	Feature_Comb2_Map *Map;
	Map = FeatMap->Maps;
	for (int i = 0 ; i < VECTOR_DIM - 1 ; i++)
		for (int j = i + 1 ; j < VECTOR_DIM ; j++)
		{
			Map->Bits[pV->Scalar[j]>>5][pV->Scalar[i]] |= 1 << (pV->Scalar[j]&31);
			Map++;
		}
}

s32 XYD[VECTOR_DIM_SQR] = {-6,-2,2,6};

void FEAT_GetImageVector(s32 *Pixel_A,s32 Pitch,FEAT_Vector *pV,s32 *pXYDOptimized)
{
	for (u32 Counter = 0 ; Counter < VECTOR_DIM ; Counter++)
	{
		pV->Scalar[Counter] = *(Pixel_A + *(pXYDOptimized++)) & (SCALAR_DISC - 1);
	}
}
void FEAT_OptimizeForImage(void *pFT,MAP *Pixels)
{
	u32 ACC = 0;
	for (int i = 0;i<VECTOR_DIM_SQR;i++)
		for (int j = 0;j<VECTOR_DIM_SQR;j++)
		{
			((Feature_TYPE *)pFT)->XYDOptimized[ACC++] = XYD[i] + XYD[j] * Pixels->PITCH;
		}
}

u32		FEAT_IsIn		(void* LB,s32 *Pixel_A,s32 *Pixel_B , s32 Pitch)
{
	FEAT_Vector V;
	FEAT_GetImageVector(Pixel_A,Pitch,&V,((Feature_TYPE *)LB)->XYDOptimized);
	return FEAT_TestMap((Feature_TYPE *)LB,&V);
}
u32	FEAT_AddBase(void* LB,s32 *Pixel_A,s32 *Pixel_B , s32 Pitch , u32 learnMode , u32 SecondPass)
{
	FEAT_Vector V;
	if (learnMode == 1)
	{
		FEAT_GetImageVector(Pixel_A,Pitch,&V,((Feature_TYPE *)LB)->XYDOptimized);
		FEAT_SetVector((Feature_TYPE *)LB,&V);
	}
	return 0;
}


void	FEAT_FinishLearn(void* LB)
{
};