#include "app.h"

const configa_t configa = {
	.light1 = 70,
	.light0 = 5,
	.time = 3, 
	.uidx = 10,
	.didx = 12,  
	.ctemp = 50,  
	.weight = 3500,
	.color1 = {255, 255, 255, 255, 255},
	.color0 = {255, 255, 255, 255, 255},
};

const configb_t configb = {
	.a = 50, 
	.b = 100,
};


const configc_t configc = {
	.a = 30,
	.b = 720,
	.c = 24,
	.d = 0,
	.e = 1,
	.f = 100,
	.g = 0x1D,
	.h = 10,
};


const configd_t configd = {
	.a = 20000,
	.b = 3,
	.c = 16, 
	.d = 8,
	.e = 10,
	.f = 25,
	.g1 = 12,
	.g2 = 0,
};


const confige_t confige = {
	.a = 200,
	.b = 100,
	.c = 3, 
	.d = 1,      
	.e = 60,  
	.f = 60,
};

const roles_t init_aa = {
	ROLE_A,
};


const status_t init_bb = {
	STAT_1,
};

param_t   param;
setting_t settinga = {0};
setting_t settingb = {0};
setting_t settingc = {0};
cfga_t cfga = {0};
cfgb_t cfgb = {0};
cfgc_t cfgc = {0}; 

uint16_t save_mask = 0; 
uint16_t save_count = 0;
uint16_t wmap_wait = 0;


void store_init(void)
{
	api_flash_read(ID_MAP2, (uint8_t *)&param, sizeof(param));
	api_flash_read(ID_MAP3, (uint8_t *)&settinga.list, sizeof(settinga.list));
	api_flash_read(ID_MAP4, (uint8_t *)&settingb.list, sizeof(settingb.list));
	api_flash_read(ID_MAP5, (uint8_t *)&settingc.list, sizeof(settingc.list));
	
	if(param.aa != LAMPTYPE)
	{
		api_flash_erase(ID_MAP2);
		store_clear_map(ID_MAP3);
		store_clear_map(ID_MAP4);
		store_clear_map(ID_MAP5);
		
		f_memset((uint8_t *)&param, 0xFF, sizeof(param));
		param.aa = LAMPTYPE;
		param.bb = init_bb; 
		param.cc = init_aa; 
		param.ca = configa; 
		param.cb = configb;
		param.cd = configc;
		param.ce = configd;
		param.cf = confige;
		api_flash_write(ID_MAP2, (uint8_t *)&param, sizeof(param));
	}
	
	for(uint8_t i = 0; i < NUM_DEVICES; i++)
	{
		if(settinga.list[i].aa > 0 && settinga.list[i].aa < param.ce.a)
		{
			settinga.number++;
		}
		if(settingb.list[i].aa > 0 && settingb.list[i].aa < param.ce.a)
		{
			settingb.number++;
		}
		if(!f_chrcmp(settingc.list[i].addr, 0xFF, 4) && !f_chrcmp(settingc.list[i].addr, 0x00, 4))
		{
			settingc.number++;
		}
	}
	f_memset((uint8_t *)&cfga.list, 0xFF, sizeof(cfga.list));
	f_memset((uint8_t *)&cfgb.list, 0xFF, sizeof(cfgb.list));
	f_memset((uint8_t *)&cfgc.list, 0xFF, sizeof(cfgc.list));
}


void store_process_100ms(void)
{
	if(save_mask & (1<<ID_MAP2))
	{
		save_mask &= ~(1<<ID_MAP2);
		api_flash_write(ID_MAP2, (uint8_t *)&param, sizeof(param));
	}

	if(wmap_wait > 0 && --wmap_wait == 0)
	{
		api_flash_write(ID_MAP5, (uint8_t *)&settingc.list, sizeof(settingc.list));
	}

	if(++save_count >= 6000) 
	{
		save_count = 0;
		if(save_mask & (1<<ID_MAP3))
		{
			save_mask &= ~(1<<ID_MAP3);
			api_flash_write(ID_MAP3, (uint8_t *)&settinga.list, sizeof(settinga.list));
		}
		if(save_mask & (1<<ID_MAP4))
		{
			save_mask &= ~(1<<ID_MAP4);
			api_flash_write(ID_MAP4, (uint8_t *)&settingb.list, sizeof(settingb.list));
		}
	}
}

void store_write_param(uint8_t type, uint8_t *data)
{
	switch(type)
	{
	case PARAM1:
		save_mask |= (1<<ID_MAP2);
		break;
	case PARAM2:
		if(param.bb != data[0])
		{
			param.bb = data[0];
			save_mask |= (1<<ID_MAP2);
		}
		break;
	case PARAM3:
		if(param.cc != data[0])
		{
			param.cc = data[0];
			save_mask |= (1<<ID_MAP2);
		}
		break;
	case PARAM4:
		if(param.dd != data[0])
		{
			param.dd = data[0];
			save_mask |= (1<<ID_MAP2);
		}
		break;
	case PARAM5:
		if(!f_memcmp(param.ee, data, 4))
		{
			f_memcpy(param.ee, data, 4);
			save_mask |= (1<<ID_MAP2);
		}
		break;
	case PARAM6: 
		if(!f_memcmp(param.ff, data, 4))
		{
			f_memcpy(param.ff, data, 4);
			save_mask |= (1<<ID_MAP2);
		}
		break;
	case PARAM7: 
		if(!f_memcmp(param.gg, data, 12))
		{
			f_memcpy(param.gg, data, 12);
			api_flash_write(ID_MAP2, (uint8_t *)&param, sizeof(param));
		}
		break;
	case PARAM8: 
		if(!f_memcmp(param.ca.data, data, sizeof(param.ca)))
		{
			f_memcpy(param.ca.data, data, sizeof(param.ca));
			save_mask |= (1<<ID_MAP2);
		}
		break;
	case PARAM9:
		if(!f_memcmp(param.cb.data, data, 4))
		{
			f_memcpy(param.cb.data, data, 4);
			save_mask |= (1<<ID_MAP2);
		}
		break;
	case PARAM10:
		if(!f_memcmp(param.cd.data, data, 12))
		{
			f_memcpy(param.cd.data, data, 12);
			api_flash_write(ID_MAP2, (uint8_t *)&param, sizeof(param));
		}
		break;
	case PARAM11:
		if(!f_memcmp(param.ce.data, data, 8))
		{
			f_memcpy(param.ce.data, data, 8);
			save_mask |= (1<<ID_MAP2);
		}
		break;
	case PARAM12:
		if(!f_memcmp(param.cf.data, data, 6))
		{
			f_memcpy(param.cf.data, data, 6);
			save_mask |= (1<<ID_MAP2);
		}
		break;
	case PARAM13:
		if(data[0] < 8 && !f_memcmp(param.cg[data[0]], data+1, 4))
		{
			f_memcpy(param.cg[data[0]], data+1, 4);
			save_mask |= (1<<ID_MAP2);
		}
		else if(data[0] >= 8)
		{
			f_memset((uint8_t *)&param.cg, 0xFF, sizeof(param.cg));
			save_mask |= (1<<ID_MAP2);
		}
		break;
	}
}

//Çå³ý±í
void store_clear_map(uint8_t mapid)
{
	switch(mapid)
	{
	case ID_MAP3:
		settinga.number = 0;
		if(!f_chrcmp((uint8_t *)&settinga.list, 0xFF, sizeof(settinga.list)))
		{
			api_flash_erase(ID_MAP3);
			f_memset((uint8_t *)&settinga.list, 0xFF, sizeof(settinga.list));
		}
		break;
	case ID_MAP4:
		settingb.number = 0;
		if(!f_chrcmp((uint8_t *)&settingb.list, 0xFF, sizeof(settingb.list)))
		{
			api_flash_erase(ID_MAP4);
			f_memset((uint8_t *)&settingb.list, 0xFF, sizeof(settingb.list));
		}
		break;
	case ID_MAP5:
		settingc.number = 0;
		if(!f_chrcmp((uint8_t *)&settingc.list, 0xFF, sizeof(settingc.list)))
		{
			api_flash_erase(ID_MAP5);
			f_memset((uint8_t *)&settingc.list, 0xFF, sizeof(settingc.list));
		}
		break;
	case ID_MAP7:
		cfgb.number = 0;
		f_memset((uint8_t *)&cfgb.list, 0xFF, sizeof(cfgb.list));
		break;
	case ID_MAP6:
		cfga.number = 0;
		f_memset((uint8_t *)&cfga.list, 0xFF, sizeof(cfga.list));
		break;
	}
}

//дÈë±í
void store_write_map(uint8_t mapid, uint8_t *data)
{
	save_mask |= (1<<mapid);
	switch(mapid)
	{
	case ID_MAP5:
		if(data[0] < NUM_DEVICES) {
			settingc.number = data[0]+1;
			f_memcpy((uint8_t *)&settingc.list[data[0]], data+1, 6);
			wmap_wait = 30;
		} else {
			store_clear_map(ID_MAP5);
		}
		break;
	}
}

void store_read_map(uint8_t mapid, uint8_t *data)
{
	switch(mapid)
	{
	case ID_MAP3:
		if(data[0] < NUM_DEVICES) {
			f_memcpy(data+1, (uint8_t *)&settinga.list[data[0]], 8);
		}
		break;
	case ID_MAP4:
		if(data[0] < NUM_DEVICES) {
			f_memcpy(data+1, (uint8_t *)&settingb.list[data[0]], 8);
		}
		break;
	case ID_MAP5:
		if(data[0] < NUM_DEVICES) {
			f_memcpy(data+1, (uint8_t *)&settingc.list[data[0]], 6);
		}
		break;
	case ID_MAP6:
		if(data[0] < NUM_DEVICES) {
			f_memcpy(data+1, cfga.list[data[0]].addr, 4);
			data[5] = cfga.list[data[0]].a;
			data[6] = cfga.list[data[0]].b;
			data[7] = cfga.list[data[0]].c;
			data[8] = cfga.list[data[0]].d & 0xFF;
			data[9] = cfga.list[data[0]].d >> 8;
			data[10] = cfga.list[data[0]].e & 0xFF;
			data[11] = cfga.list[data[0]].e >> 8;
		}
		break;
	case ID_MAP7:
		if(data[0] < NUM_cfgb) {
			f_memcpy(data+1, (uint8_t *)&cfgb.list[data[0]], 8);
		}
		break;
	case ID_MAP8:
		if(data[0] < NUM_cfgc) {
			f_memcpy(data+1, (uint8_t *)&cfgc.list[data[0]], 5);
		}
		break;
	}
}

void store_setfl(uint8_t number)
{
	store_clear_map(ID_MAP4); 
	param.cb.a = 65535;
	param.cb.b = 65535;
	f_memset((uint8_t *)&param.cg, 0xFF, sizeof(param.cg));
	for(uint8_t i = 0; i < number && number <= 8; i++)
	{
		f_memcpy(param.cg[i], settinga.list[i].addr, 4);
	}
	api_flash_write(ID_MAP2, (uint8_t *)&param, sizeof(param));
}