#include "alarm.h"
#include "prj_com.h"
#include "rtc_run.h"
#include "eeprom.h"
#include "bill.h"

uint32_t alarm_bits;
static uint8_t alarm_flag = 0;
static uint8_t alarm_array[ERR_END * 2]; // 当前的实时报警状�?发生后�?, 写入报�?�后清�??
static uint32_t alarm_args[ERR_END * 2]; // 报�?�时产生的参�?
static uint8_t alarm_write_ptr = 0;
ALARM_INFO_DEF alarm_info;

// 123
// 123456789
// ��������
// 666
/// ������

///////sfsdfgsdfsdfgsdfgsdfsdfgsdfg

void alarm_init(void)
{
	alarm_bits = 0;
	alarm_flag = 0;
	memset(alarm_array, 0, sizeof(alarm_array));
	memset(alarm_args, 0, sizeof(alarm_args));

	get_alarm_info(&alarm_info);
}
void get_alarm_info(ALARM_INFO_DEF *info)
{
	uint32_t addr = ALARM_INFO_ADDR;
	uint8_t need_reset = 0;

	// 1. ���Զ�ȡ������鷵��ֵ������ read_eeprom_para ���� 0 ��ʾ�ɹ���
	if (read_eeprom_para(addr, (uint8_t *)info, sizeof(ALARM_INFO_DEF)) != 0)
	{
		need_reset = 1; // ��ȡʧ�ܣ�ǿ������
	}
	else
	{
		// 2. �����Ϸ���У��
		// ע�⣺num ���Ե��� MAX_ALARM_NUM (��)�������� > ������ >=
		if (info->start >= MAX_ALARM_NUM ||
			info->end >= MAX_ALARM_NUM ||
			info->num > MAX_ALARM_NUM ||
			info->flag != 0xaa)
		{
			need_reset = 1;
		}
		else
		{
			// 3. ����Ҫ��һ����У��
			// ���� start �� end ���¼��������ϵ� num
			uint8_t calculated_num;
			if (info->end >= info->start)
			{
				calculated_num = info->end - info->start;
			}
			else
			{
				calculated_num = MAX_ALARM_NUM - info->start + info->end;
			}

			// ����洢�� num �������� num ��һ�£�˵��������
			// ע�⣺������һ���������������������num Ӧ�õ��� MAX_ALARM_NUM
			// ���ڻ��ζ����У���ƾ start/end �޷����֡��ա��͡���������������� num��
			// ��Ȼ���Ǵ��� num������ num Ϊ׼����Ҫȷ�� num ������ MAX
			// ���ϸ��У���ǣ���� num < MAX���� calculated_num ������� num
			if (info->num < MAX_ALARM_NUM && calculated_num != info->num)
			{
				need_reset = 1;
			}
			// ��� num == MAX_ALARM_NUM�����������������ģ���������У��
		}
	}

	if (need_reset)
	{
		info->start = 0;
		info->end = 0;
		info->flag = 0xaa;
		info->num = 0;
		write_eeprom_para(addr, (uint8_t *)info, sizeof(ALARM_INFO_DEF));
	}
}
uint8_t get_alarm_num(void)
{
	return alarm_info.num;
}
void all_alarm_status(uint32_t **bits)
{
	*bits = &alarm_bits;
}

uint8_t alarm_status(uint8_t err_no)
{
	return BIT_VAL(alarm_bits, err_no);
}

void write_alarm(uint8_t err_no, uint8_t type, uint32_t arg)
{
	alarm_t alarm;
	rtc_run_t *rr;

	// 1. ��ȡ��ǰʱ��
	get_rtc_run(&rr);

	// 2. ����������¼
	alarm.flag = 1;
	alarm.err_no = err_no;
	alarm.type = type;
	alarm.arg[0] = (uint8_t)arg;
	alarm.arg[1] = (uint8_t)(arg >> 8);
	alarm.arg[2] = (uint8_t)(arg >> 16);
	alarm.arg[3] = (uint8_t)(arg >> 24);
	alarm.time[0] = 0x14;
	alarm.time[1] = rr->year;
	alarm.time[2] = rr->month;
	alarm.time[3] = rr->day;
	alarm.time[4] = rr->hour;
	alarm.time[5] = rr->minute;
	alarm.time[6] = rr->second;

	// 3. � EEPROM
	uint32_t addr = ALARM_START_ADDR + alarm_info.end * ALARM_DATA_SIZE;
	write_eeprom(addr, (uint8_t *)&alarm, sizeof(alarm_t));

	// 4. ����ָ��
	uint8_t next_end = alarm_info.end + 1;
	if (next_end >= MAX_ALARM_NUM)
	{
		next_end = 0;
	}

	// �ж��Ƿ񸲸ǣ�����������
	// �����һ��д��λ��׷���� start��˵������������
	if (next_end == alarm_info.start)
	{
		// �ƶ� start ָ�룬������ɵ�һ������
		alarm_info.start++;
		if (alarm_info.start >= MAX_ALARM_NUM)
		{
			alarm_info.start = 0;
		}
		// �ؼ��㣺��״̬�£������㶨Ϊ���ֵ
		alarm_info.num = MAX_ALARM_NUM;
	}
	else
	{
		// ��������������� 1
		alarm_info.num++;
	}

	alarm_info.end = next_end;

	// 5. ����Ԫ����
	write_eeprom_para(ALARM_INFO_ADDR, (uint8_t *)&alarm_info, sizeof(ALARM_INFO_DEF));
}

uint8_t read_alarm(uint8_t num, alarm_t *alarm)
{
	memset((uint8_t *)alarm, 0, sizeof(alarm_t));
	uint8_t ser = get_alarm_num(); // ��ȡ��ǰ��Ч����

	// ������������������Χ������ʧ��
	if (num >= ser)
		return 0;

	// ���������������� end-1 ��ʼ��ǰ�� num ��
	// ���� MAX_ALARM_NUM ��ȡģ��Ϊ�˴�����������
	ser = (alarm_info.end - 1 - num + MAX_ALARM_NUM) % MAX_ALARM_NUM;

	uint32_t addr = ALARM_START_ADDR + ALARM_DATA_SIZE * ser;
	uint8_t ret = read_eeprom(addr, (uint8_t *)alarm, sizeof(alarm_t));
	return (ret == 0);
}

void set_alarm_info(uint8_t err_no, uint8_t type, uint32_t arg)
{
	uint8_t idx;

	idx = ALARM_INDEX(err_no, type);
	alarm_array[idx] = 1;
	alarm_args[idx] = arg;
	alarm_flag = 1;
}

// type 1-alarm 0-alarm recovery
void Alarm(uint8_t err_no, uint8_t type, uint32_t arg)
{
	if (type)
	{
		if (!BIT_VAL(alarm_bits, err_no))
		{
			SET_BIT_WARN(alarm_bits, err_no);
			set_alarm_info(err_no, type, arg);
		}
	}
	else
	{
		if (BIT_VAL(alarm_bits, err_no))
		{
			RESET_BIT_WARN(alarm_bits, err_no);
			set_alarm_info(err_no, type, arg);
		}
	}
}

void AlarmHandle(void)
{
	uint16_t i;
	uint8_t err_no;
	uint8_t type;

  if(StartUp < 10)return;//wxl2026-5-18
	if (alarm_flag == 0)
	{
		return;
	}

	for (i = 0; i < ERR_END * 2; i++)
	{
		if (alarm_array[i] == 1)
		{
			err_no = i >> 1;
			type = i % 2;
			write_alarm(err_no, type, alarm_args[i]);
			alarm_array[i] = 0;
		}
	}

	alarm_flag = 0;
}