#include "common.h"
#include "drv_io.h"
#include "drv_can.h"
#include "app_rs485_1.h"
#include "app_rs485_2.h"
#include "app_can.h"
#include "app.h"
#include "app_end_ctr.h"
#include "measure_temprature.h"
#include "hardware_test.h"
#include "drv_io.h"
#include "measure_vol.h"
#include "shark_xl.h"
#include "shark_charge.h"

END_CTR_SELF_SEND_STATUS end_ctr_self_ss;
END_CTR_SELF_SEND_STATUS end_ctr_self_ss_new;
END_CTR_SELF_SEND_STATUS end_ctr_rsp;

uint8_t Get_QD_State(void)
{
	return end_ctr_self_ss_new.qd_sta;
}

uint8_t Is_Soak(void)
{
	return end_ctr_self_ss_new.soak_sta;
}

void Can_End_Ctr_Self_Send_Check(CAN_FRAME*can_ctr_frame)
{
	uint16_t len;
	uint8_t *buf = can_ctr_frame->data;

	if(memcmp(&end_ctr_self_ss,&end_ctr_self_ss_new,sizeof(END_CTR_SELF_SEND_STATUS)) != 0) {
		memcpy(&end_ctr_self_ss,&end_ctr_self_ss_new,sizeof(END_CTR_SELF_SEND_STATUS));
		shark_can_send_pending |= SHARK_SEND_PENDING_4280;
		shark_can_send_times = 0;
	}

	if ((shark_can_send_pending & SHARK_SEND_PENDING_4280) == 0) {
		return;
	}
	
	len = sizeof(end_ctr_self_ss);
	//
	can_ctr_frame->head.rsp = FRAME_PT_NEED_RSP;
	can_ctr_frame->head.dest = CTR_ID;
	can_ctr_frame->head.sour = SELF_ID;
	can_ctr_frame->head.index = 1;
	can_ctr_frame->head.total = (len - 1)/8 + 1;
	can_ctr_frame->head.pro   =FRAME_PRO_D;
	//
	can_ctr_frame->len = len;
	memcpy(buf,&end_ctr_self_ss,len);
	
	//
	if(!Send_Data_Can(can_ctr_frame,CTR_SELF))
	{
		//g_event |= END_CTR_RESEND_CMD_EVENT;
		//return;
	}
	
}

#ifdef CONFIG_CAN_IAP
void qws_iap_fmc_flag_clear(void)
{
	fmc_flag_clear(FMC_FLAG_BANK0_PGERR | FMC_FLAG_BANK0_WPERR | FMC_FLAG_BANK0_END);
}

void qws_iap_write_magic(uint32_t magic)
{
	uint32_t capacity = (REG32(0x1FFFF7E0) & 0xFFFF) << 10;
	uint32_t address = 0x08000000 + (capacity - 1024);
	uint32_t length, checksum, value;

	value = REG32(address + 8);
	if (magic == value) {
		return;
	}

	length = REG32(address);
	checksum = REG32(address + 4);

	fmc_unlock();

	if (value != 0xFFFFFFFF) {
		qws_iap_fmc_flag_clear();
		fmc_page_erase(address);

		qws_iap_fmc_flag_clear();
		fmc_word_program(address, length);

		qws_iap_fmc_flag_clear();
		fmc_word_program(address + 4, checksum);
	}

	if (magic != 0xFFFFFFFF) {
		qws_iap_fmc_flag_clear();
		fmc_word_program(address + 8, magic);
	}

	fmc_lock();
}

void qws_iap_reboot(void)
{
	qws_iap_write_magic(0xFFFFFFFF);
	__set_FAULTMASK(1);
	NVIC_SystemReset();
}

uint8_t qws_iap_read_string(uint8_t *buff)
{
	uint32_t address = ((uint32_t) buff[4]) << 16 | ((uint32_t) buff[3]) << 8 | buff[2];
	const char *text = (const char *) (0x08000000 + address);
	int length = strlen(text);

	if (length > 250) {
		length = 250;
	}

	buff[5] = buff[4];
	buff[4] = buff[3];
	buff[3] = buff[2];
	buff[2] = 0x00;

	memcpy(buff + 6, text, length);

	return length + 6;
}
#endif

int8_t Handle_Can_Ctr_CMD(CAN_FRAME*can_ctr_frame)
{
	uint16_t key;
	uint8_t *buf = can_ctr_frame->data;

	memcpy(&key,can_ctr_frame->data,sizeof(key));

	switch(key)
	{
		case KEY_END_CTR_COMMON:
			soak_dec_delay.enable = (buf[2]&0x01);
			break;
		case KEY_END_CTR_SWI_BAT:	
			break;
		case KEY_END_CTR_BAT_INT_EN:
			is_intelligent = buf[2];
			break;
		case KEY_END_CTR_BAT_INT_PRE:
#if 0
			if(buf[2] == 1)
				CB_OPERATE_PRECEDENCE_Config = PRE_SERIES;
			else if(buf[2] == 2)
				CB_OPERATE_PRECEDENCE_Config = PRE_PARRALLEL;
			else
				return 0;
#endif
			break;
		case KEY_END_CTR_SOFT_WARE:	
			break;
		case KEY_END_CTR_SN:	
			break;
		case KEY_END_CTR_WRITER_SN:	
			Writer_SN(&buf[2]);
			break;
		case KEY_END_CTR_BAT_UPDATE_REQ:		
			break;
		case KEY_END_CTR_BAT_UPDATE:
			break;
		case KEY_END_CTR_BAT_UPDATE_EXIT:
			break;
			
		case KEY_END_CTR_DAN_CI_LI_CHENG:
			memcpy(&sheng_yu_li_cheng.sy_dan_ci_li_cheng_temp,&buf[2],sizeof(sheng_yu_li_cheng.sy_dan_ci_li_cheng_temp));
			break;
		case KEY_END_CTR_ZHEN_JI_CE_SHI:
			break;
		case KEY_END_CTR_TEST_INFO:
			break;
		case KEY_END_CTR_QD:
			if(work_normal == 1)
			{
				switch(buf[2])
				{
					case 0:
						//QD_Enable(0);
						//ACC2_Enable(0);
						QD_Enable_From(0,2);
						shark_battery_series_locked = shark_false;
						break;
					case 1:
						//QD_Enable(1);
						QD_Enable_From(1,3);
						// if(ACC2_Is_On() == 0)
							ACC2_Enable(1);
						break;
					default:
						return 0;
				}
				delay_1ms(10);
			}
			break;
		case KEY_END_CTR_LOCK:
			switch(buf[2])
			{
				case 0:
					Lock_Enable(0);
					break;
				case 1:
					Lock_Enable(1);
					break;
				default:
					return 0;
			}
			
			break;
		case KEY_END_CTR_L_R_LIGHT:
			
			if(buf[2] == 0)
			{
				Left_Light_Enable(0);
				left_light_delay.set = 0;
				left_light_delay.count = 0;
			}
			if(buf[2] == 1)
			{
				Left_Light_Enable(1);
			}
			if(buf[2] == 2)
			{
				Left_Light_Enable(1);
				left_light_delay.set = 1;
				left_light_delay.count = 0;
			}

			if(buf[2] == 3)
			{
				Left_Light_Enable(0);
				left_light_delay.set = 1;
				left_light_delay.count = 600;
			}
			
			if(buf[3] == 0)
			{
				Right_Light_Enable(0);
				right_light_delay.set = 0;
				right_light_delay.count = 0;
			}
			if(buf[3] == 1)
			{
				Right_Light_Enable(1);
				
			}
			if(buf[3] == 2)
			{
				Right_Light_Enable(1);
				right_light_delay.set = 1;
				right_light_delay.count = 0;
			}

			if(buf[3] == 3)
			{
				Right_Light_Enable(0);
				right_light_delay.set = 1;
				right_light_delay.count = 600;
			}
			break;
		case KEY_END_CTR_CARPET_LIGHT:
			switch(buf[2])
			{
				case 0:
					Carpet_Light_Enable(0);
					break;
				case 1:
					Carpet_Light_Enable(1);
					break;
				default:
					return 0;
			}
			break;
		case KEY_END_CTR_TAIL_LIGHT:
			switch(buf[2])
			{
				case 0:				
					Tail_Light_Enable(0);	
					break;
				case 1:
					Tail_Light_Enable(1);
					break;
				default:
					return 0;
			}
			break;
		case KEY_END_CTR_ACC12:

			if(work_normal == 1)
			{
				switch(buf[2])
				{
					case 0:
						if(QD_Dect() == 0)
						{
							ACC2_Enable(0);
						}
						break;
					case 1:
						if(ACC2_Is_On() == 0)
							ACC2_Enable(1);		
						break;
					default:
						return 0;
				}
				delay_1ms(10);
			}
		
			break;
		case KEY_END_CTR_ACC12_TEST:
			if(work_normal == 1)
			{
				sub_bms_info_1.test_error = buf[2];
				sub_bms_info_2.test_error = buf[3];
			}
			break;
		case KEY_END_CTR_ACC12_TEST_1:
			switch(buf[2])
			{
				case 0:
					//if(QD_Dect() == 0)
					{
						ACC2_Enable(0);
					}
					break;
				case 1:
					// if(ACC2_Is_On() == 0)
						ACC2_Enable(1);		
					break;
				default:
					return 0;
			}
			delay_1ms(10);
			break;
		case KEY_END_CTR_HEART_TICK:
			break;
		case KEY_END_CTR_SELF_UP:
			shark_can_send_pending &= ~SHARK_SEND_PENDING_4280;
			return 0;
#ifdef CONFIG_CAN_IAP
		case 0x42F0:
			qws_iap_reboot();
			return 0;

		case 0x42F5:
		case 0x42F6:
		case 0x42F8:
		case 0x42F9:
			break;
#endif
		default:
			return 0;

	}
	
	return 1;
	
}

extern shark_u8 shark_charge_irq_times;

int8_t Rsp_Can_Ctr_CMD(CAN_FRAME*can_ctr_frame)
{
	uint16_t key,len;
	uint8_t *buf = can_ctr_frame->data;

	if (can_ctr_frame->head.rsp != FRAME_PT_NEED_RSP) {
		return 1;
	}

	memcpy(&key,can_ctr_frame->data,sizeof(key));

	switch(key)
	{
		case KEY_END_CTR_COMMON:
			end_ctr_rsp.key = KEY_END_CTR_COMMON;
			end_ctr_rsp.op_result = 0;
			len = sizeof(end_ctr_rsp);
			memcpy(buf,&end_ctr_rsp,len);
			
			buf[len++] = QD_switch_from;
			buf[len++] = power_switch_from;
			buf[len++] = shark_seconds;
			buf[len++] = shark_seconds >> 8;
			
			break;
		case KEY_END_CTR_SWI_BAT:
			len = 2;
			
			if(is_intelligent)
			{
				buf[len++] = 0;
				buf[len++] = CB_BAT_NO;
			}
			else
			{
				if(buf[len] > CB_BAT_NO && buf[len] < CB_MAX)
				{
					if(cb_operate_state != buf[len])
					{
						Battery_Change_Mode(buf[len]);	
					}
					buf[len++] = 0;
				}
				else
				{
					buf[len++] = 1;
				}
				
				buf[len++] = cb_operate_state;	
			}
			
			break;
		case KEY_END_CTR_BAT_INT_EN:
			len = 2;
			buf[len++] = 0;
			break;	
		case KEY_END_CTR_BAT_INT_PRE:
			len = 2;
			buf[len++] = 0;
			break;
		case KEY_END_CTR_SOFT_WARE:
			len = 2;
			buf[len++] = 0;
			memcpy(&buf[len],soft_version,PS100_SOFTWARE_SIZE);
			len += PS100_SOFTWARE_SIZE;
			break;
		case KEY_END_CTR_SN:
			len = 2;
			buf[len++] = 0;
			memcpy(&buf[len],sn,sizeof(sn));
			len += sizeof(sn);
			break;
		case KEY_END_CTR_WRITER_SN:
			len = 2;
			buf[len++] = 0;
			break;
		case KEY_END_CTR_BAT_UPDATE_REQ:
			len = 2;
			buf[len++] = 1;
			break;
		case KEY_END_CTR_BAT_UPDATE:
			len = 2;
			buf[len++] = 1;
			break;
		case KEY_END_CTR_BAT_UPDATE_EXIT:
			len = 2;
			buf[len++] = 0;
			break;
		case KEY_END_CTR_DAN_CI_LI_CHENG:
			len = 2;
			buf[len++] = sheng_yu_li_cheng.sy_yu_ji_ke_xing_shi_li_cheng;
			break;
		case KEY_END_CTR_ZHEN_JI_CE_SHI:
			Writer_HT_Flash(1);
			len = 2;
			buf[len++] = 0;
			break;
		case KEY_END_CTR_TEST_INFO:
			len = 2;
			switch(buf[len++])
			{
				case 1:
					memcpy(&buf[len],&test_info.ti_bms_1,sizeof(test_info.ti_bms_1));
					len += sizeof(test_info.ti_bms_1);
					memcpy(&buf[len],&test_info.ti_bms_2,sizeof(test_info.ti_bms_2));
					len += sizeof(test_info.ti_bms_2);
					break;
				case 2:
					Ca_Chu_Test_Info();
					buf[len++] = 0;
					break;
				case 3:
					shark_printf_enabled = buf[len];
					println("seconds: %d, charge: %d", shark_get_seconds(), shark_charge_get_time());
					buf[len++] = 0;
					break;
				case 4:
					memcpy(buf + len, &shark_xl_speed, sizeof(shark_xl_speed));
					len += sizeof(shark_xl_speed);
					memcpy(buf + len, &shark_xl_speed_max, sizeof(shark_xl_speed_max));
					len += sizeof(shark_xl_speed_max);
					shark_xl_speed_max = 0;
					break;
				case 5:
					memcpy(buf + len, &sub_bms_info_1.packet_common.work_status, sizeof(sub_bms_info_1.packet_common.work_status));
					len += sizeof(sub_bms_info_1.packet_common.work_status);
					memcpy(buf + len, &sub_bms_info_2.packet_common.work_status, sizeof(sub_bms_info_2.packet_common.work_status));
					len += sizeof(sub_bms_info_2.packet_common.work_status);
					buf[len++] = sub_bms_info_1.packet_common.bms_status;
					buf[len++] = sub_bms_info_2.packet_common.bms_status;
					println("soc: %d %d, vol: %d %d, curr: %d %d",
						shark_battery_get_capacity1(), shark_battery_get_capacity2(),
						shark_battery_get_voltage1(), shark_battery_get_voltage2(),
						shark_battery_get_current1(), shark_battery_get_current2());
					break;
				case 6:
					buf[len++] = cb_operate_state;
					buf[len++] = sub_bms_info_1.connected << 4 | sub_bms_info_2.connected;
					buf[len++] = sub_bms_info_1.exit_code << 4 | sub_bms_info_2.exit_code;
					memcpy(buf + len, &sub_bms_info_1.work_error, sizeof(sub_bms_info_1.work_error));
					len += sizeof(sub_bms_info_1.work_error);
					memcpy(buf + len, &sub_bms_info_2.work_error, sizeof(sub_bms_info_2.work_error));
					len += sizeof(sub_bms_info_2.work_error);
					sub_bms_info_1.exit_code = sub_bms_info_2.exit_code = SHARK_BATT_EXIT_SUCCESS;
					break;
				case 7:
					buf[len++] = end_ctr_self_ss_new.acc12_sta << 4 | ACC2_Dect();
					buf[len++] = end_ctr_self_ss_new.qd_sta << 4 | QD_Dect();
					buf[len++] = shark_charger_state << 4 | shark_charger_enabled;
					buf[len++] = sub_bms_info_1.packet_common.charge_flag << 4 | sub_bms_info_2.packet_common.charge_flag;
					break;
				case 9:
					memcpy(buf + len, &shark_mseconds, sizeof(shark_mseconds));
					len += sizeof(shark_mseconds);
					break;
				default:
					buf[len++] = 0;
					break;
					
			}
			
			break;
		case KEY_END_CTR_QD:
			len = 2;
			buf[len++] = 0;
			if(work_normal == 1)
			{
				buf[len++] = QD_Dect();
				qd_dec_delay.count = QD_DEC_TIMEOUT;
			}
			else
				buf[len++] = 0;
			
			break;	
		case KEY_END_CTR_LOCK:
			len = 2;
			buf[len++] = 0;
			buf[len++] = Lock_Dect();
			break;
		case KEY_END_CTR_L_R_LIGHT:
			len = 2;
			buf[len++] = 0;
			break;
		case KEY_END_CTR_CARPET_LIGHT:
			len = 2;
			buf[len++] = 0;
			break;
		case KEY_END_CTR_TAIL_LIGHT:
			len = 2;
			buf[len++] = 0;
			break;
		case KEY_END_CTR_ACC12:
			len = 2;
			buf[len++] = 0;
			if(work_normal == 1)
			{
				buf[len++] = end_ctr_self_ss_new.acc12_sta;
			}
			else
				buf[len++] = 0;
			break;	
			
		case KEY_END_CTR_ACC12_TEST:
			len = 2;
			buf[len++] = 0;
			break;	
		case KEY_END_CTR_ACC12_TEST_1:
			len = 2;
			buf[len++] = 0;
			if(work_normal == 1)
			{
				buf[len++] = ACC2_Dect();
			}
			else
				buf[len++] = 0;
			break;
		case KEY_END_CTR_HEART_TICK:	
			len = 2;
			buf[len++] = 0;
			break;
		case KEY_END_CTR_SELF_UP:
			return 0;
#ifdef CONFIG_CAN_IAP
		case 0x42F5:
			if (can_ctr_frame->len > 2 && can_ctr_frame->len < 8) {
				memmove(buf + 3, buf + 2, can_ctr_frame->len - 2);
				len = can_ctr_frame->len + 1;
				buf[2] = 0;
				break;
			}
		case 0x42F9:
			qws_iap_write_magic(0x11223344);
		case 0x42F6:
			len = 3;
			buf[2] = 0;
			break;

		case 0x42F8:
			len = qws_iap_read_string(buf);
			break;
#endif
		default:
			return 0;
	}
	//
	can_ctr_frame->head.rsp = FRAME_PT_RSP;
	can_ctr_frame->head.dest = can_ctr_frame->head.sour;
	can_ctr_frame->head.sour = SELF_ID;
	can_ctr_frame->head.index = 1;
	can_ctr_frame->head.total = (len - 1)/8 + 1;
	can_ctr_frame->head.pro   =FRAME_PRO_D;
	//
	can_ctr_frame->len = len;

	//
	if(!Send_Data_Can(can_ctr_frame,CTR_RSP))
	{
		g_event |= END_CTR_RESEND_CMD_EVENT;
		return 0;
	}
	
	return 1;

}

void Check_End_Ctr_Status(void)
{
	
	if(side_stay_dec_delay.set&&side_stay_dec_delay.count >= SIDE_STAY_DEC_TIMEOUT)
	{
		memset(&side_stay_dec_delay,0x00,sizeof(side_stay_dec_delay));
		end_ctr_self_ss_new.side_sta = !Side_Stay_Dect();
	}

	if(soak_dec_delay.set&&soak_dec_delay.count >= SOAK_DEC_TIMEOUT)
	{
		soak_dec_delay.set = 0;
		soak_dec_delay.count = 0;
		end_ctr_self_ss_new.soak_sta = Soak_Dect();
	}

	if(sti_dec_delay.set&&sti_dec_delay.count >= STI_DEC_TIMEOUT)
	{
		memset(&sti_dec_delay,0x00,sizeof(sti_dec_delay));
		end_ctr_self_ss_new.sit_sta = !Sitting_Dect();
	}

	if(repair_dec_delay.set&&repair_dec_delay.count >= REPAIR_DEC_TIMEOUT)
	{
		memset(&repair_dec_delay,0x00,sizeof(repair_dec_delay));
		//end_ctr_self_ss_new.side_sta = !Repair_Key_Dect();
	}

	if(qd_dec_delay.set&&qd_dec_delay.count >= QD_DEC_TIMEOUT/*&&serise_low_qd_status == 0*/)
	{
		memset(&qd_dec_delay,0x00,sizeof(qd_dec_delay));
		end_ctr_self_ss_new.qd_sta = QD_Dect();
	}

	//
	end_ctr_self_ss_new.charger_in = shark_charger_is_normal();
	end_ctr_self_ss_new.bat1_charge = shark_battery_charge_in1();
	end_ctr_self_ss_new.bat2_charge = shark_battery_charge_in2();

	end_ctr_self_ss_new.moto_temp = ctr_temperature[1];

	end_ctr_self_ss_new.ps100_temp = ctr_temperature[0];
	end_ctr_self_ss_new.bms_1_status = shark_battery_get_rs485_state(&sub_bms_info_1);
	end_ctr_self_ss_new.bms_2_status = shark_battery_get_rs485_state(&sub_bms_info_2);
	end_ctr_self_ss_new.using_bms_mode = cb_operate_state;

	end_ctr_self_ss_new.nhb = (uint16_t)(sheng_yu_li_cheng.sy_ss_parm.neng_hao_bi);


	//
	end_ctr_rsp = end_ctr_self_ss_new;
	
	end_ctr_rsp.lock_sta = Lock_Dect();
	end_ctr_rsp.carpet_sta = Carpet_Dect();
	end_ctr_rsp.tail_sta = Tail_Dect();

	
}

void End_Ctr_Initial(void)
{
	 E_CTR_Initial();
}