#include "CONFIG.h"
#if  EC800M

#include "stm32f10x.h"
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>


#include "UDP_Client.h"
#include "Timer_Module.h"
#include "Log_Module.h"

#include "mbedtls_util.h"

#include "cJSON.h"
#include "ec800m.h"
#include "Pump_Dicts_Util.h"
#include "Regist.h"
#include "PumpBusiness.h"
#include "aliyuniot.h"
#include "Initialize.h"

// 流程
enum Step{
	STEP_NONE, // 空闲状态，无操作
	STEP_START, // 开始
	STEP_EXIT_SLEEP, // 退出睡眠
	STEP_ENTER_SLEEP, // 进入睡眠
	STEP_WAIT, // 等待
	
	STEP_STATE, // 查询状态
	STEP_OPEN, // 打开
	STEP_OPEN_WAIT_RESULT, // 等待打开结果
	STEP_JUDGE_AUTH_OR_DATA, // 判断认证还是发送
	STEP_JOIN_AUTH_MESSAGE, // 拼接认证报文
	STEP_JOIN_DATA_MESSAGE, // 拼接数据报文
	STEP_QUERY_SLEEP, // 查询休眠
	STEP_SET_SLEEP, // 开启休眠
	STEP_QUERY_QENG_SERVINGCELL, // 查询信号质量
	
	STEP_SET_QISDE_0, // 关闭发送回显
	STEP_SEND, // 发送
	STEP_RECV, // 等待发送结果
	
	STEP_SET_CFUN_0, // 设置最小功能模式
	STEP_WAIT_SET_CFUN_0, // 等待设置最小功能模式
	STEP_SET_CFUN_1, // 设置全功能模式
	STEP_WAIT_SET_CFUN_1, // 等待设置全功能模式结果
	
	STEP_SET_CGREG_2, // 设置ps域允许上报网络注册和位置信息
	STEP_QUERY_CGREG, // 查询网络注册状态
	
	STEP_CLOSE, // 关闭
	
	STEP_SUCCESS, // 成功
	STEP_FAILURE, // 失败
	STEP_FINISH, // 流程结束
	
	
	STEP_VERIFY_REGIST, // 验证注册
	STEP_VERIFY_INITIALIZE, // 验证初始化
};
// 当前
static enum Step step = STEP_NONE;
// 下一步
static enum Step next_step = STEP_NONE;

// 客户端5
struct UDP_Client_Struct client = {
	.status = Client_Status_None,
};


// socket ID
static uint8_t connectID = 5;



static uint8_t coap_message[512]; 
static uint16_t coap_message_length = 0;

// 泵参数
extern struct Pump_Params pump_params;
// 待发送数据的地址和长度
static uint8_t databuff[128];
static uint16_t data_length;

static uint8_t test_flag=0;


// 计时相关的变量
static struct TIMER_Struct timer;
uint32_t wait_time = 10;

// 信号值
static struct Signal
{
	int RSRP;
	int RSRQ; 
	int RSSI; 
	int SINR;
} signal = {
	.RSRP = 99,
	.RSRQ = 99,
	.RSSI = 99,
	.SINR = 99,
};

void Query_Signal(int * RSRP, int * RSRQ, int * RSSI, int * SINR)
{
	*RSRP = signal.RSRP;
	*RSRQ = signal.RSRQ;
	*RSSI = signal.RSSI;
	*SINR = signal.SINR;
}

// 初始化
void UDP_Client_Init(void)
{
	//aliyuniot_set_device_params(flashdata.productKey,flashdata.deviceName,flashdata.deviceSecret);

	aliyuniot_set_device_params(regist_get_aliyun_productKey(),regist_get_aliyun_deviceName(),regist_get_aliyun_deviceSecret());
}
// 声明函数。步骤跳转
void goto_step(enum Step ns);
// 发送流程
void UDP_Client_Handle(void);
// 发送数据
void UDP_Client_Send(uint8_t test_switch)
{
	test_flag=test_switch;
	if(step == STEP_NONE)
	{
		// 初始化
		UDP_Client_Init();
		// 正在发送
		client.status = Client_Status_Sending;
		// 流程开始
		goto_step(STEP_START);
	}
}
// 获取状态
enum Client_Status UDP_Client_Status(void)
{
	if(client.status == Client_Status_None)
	{
		return client.status;
	}
	else if(step == STEP_FINISH)
	{
		return client.status;
	}
	else
	{
		return Client_Status_Sending;
	}
}

// 获取备注
char * UDP_Client_Get_Info(void)
{
	return client.info;
}
// 清除
void UDP_Client_Clear(void)
{
	// 流程置空
	goto_step(STEP_NONE);
	// 空闲
	client.status = Client_Status_None;
}

// 直接跳转到下一步
static void goto_step(enum Step ns)
{
	// 重置ec800m状态
	ec800m.reset();
	step = ns; 
}

// 先等待再跳转到下一步
static void goto_step_wait(enum Step ns, uint32_t t)
{
	goto_step(STEP_WAIT); // 等待
	wait_time = t;
	next_step = ns; // 等待之后跳转
}

// 只等待，等待之后返回原来的步骤
static void goto_wait(uint32_t t)
{
	goto_step_wait(step, t);
}

// 失败
static void goto_failure(char * info)
{
	Log_Printf_Debug("STEP: 数据发送失败,%s\r\n", info);
	client.status = Client_Status_Failure;
	strcpy(client.info, info);
	goto_step(STEP_FAILURE);
}

// 成功
static void goto_success(char * info)
{
	Log_Printf_Debug("STEP: 数据发送成功,%s\r\n", info);
	client.status = Client_Status_Success;
	strcpy(client.info, info);
	goto_step(STEP_SUCCESS);
}

// 等待
static void wait(void)
{
	if(time_get_delay(&timer) > wait_time)
	{
		goto_step(next_step); // 进入下一步
		time_clear(&timer);
	}
}

// 发送数据的逻辑
static enum Result result = Result_None;
static uint8_t cgreg_n; 
static uint8_t cgreg_stat; 
static uint16_t cgreg_lac; 
static uint32_t cgreg_ci;
static uint8_t query_cgreg_times = 0; // 查询网络状态的次数
static uint8_t auth_times = 0; // 认证次数
static uint16_t socket_err = 0;
static uint8_t auth_or_data = 0;
static enum Initialize_Result InitializeResult;
static enum Regist_Result regist_result;
void UDP_Client_Handle(void)
{
	// 如果模块正在初始化，直接返回发送失败
	InitializeResult = get_initialize_status();
	if(InitializeResult==Initialize_Result_Busy)
	{
		goto_failure("模块正在初始化");
		goto_step(STEP_FINISH);
	}
	// 流程
	switch(step)
	{
		case STEP_NONE: // 空闲
			break;
		case STEP_START: // 开始
			query_cgreg_times = 0; // 查询网络状态的次数
			auth_times = 0; // 认证次数
			goto_step(STEP_EXIT_SLEEP);
			break;
		case STEP_EXIT_SLEEP: // 退出休眠
			ec800m.exit_sleep();
			goto_step_wait(STEP_SET_CFUN_1, 3);
			break;
		case STEP_SET_CFUN_1: // 设置全功能模式
			result = ec800m.set_cfun(1);
			if(result == Result_Success)
			{
				goto_step(STEP_SET_CGREG_2);
			}
			else if(result == Result_Failed)
			{
				goto_failure("设置全功能模式失败");
			}
			break;
		case STEP_SET_CGREG_2: // 设置ps域
			result = ec800m.set_cgreg(2);
			if(result == Result_Success)
			{
				goto_step(STEP_QUERY_CGREG);
			}
			else if(result == Result_Failed)
			{
				goto_failure("设置ps域失败");
			}
			break;
		case STEP_QUERY_CGREG: // 查询ps域
			result = ec800m.query_cgreg(&cgreg_n, &cgreg_stat, &cgreg_lac, &cgreg_ci);
			if(result == Result_Success)
			{
				if(cgreg_stat == 1)
				{
					// 下一步
					if(test_flag == 0)
					{
						goto_step(STEP_CLOSE);
					}
					else
					{
						goto_step(STEP_QUERY_QENG_SERVINGCELL);
					}
				}
				else if(query_cgreg_times > 20) // 最多查询20次
				{
					goto_failure("查询ps域次数过多");
				}
				else
				{
					goto_wait(400);
					query_cgreg_times++;
				}
			}
			else if(result == Result_Failed)
			{
				goto_failure("查询ps域失败");
			}
			break;
		case STEP_QUERY_QENG_SERVINGCELL: // 查询信号质量
			result = ec800m.qeng_servingcell(&signal.RSRP, &signal.RSRQ, &signal.RSSI, &signal.SINR);
			if(result == Result_Success)
			{
				goto_step(STEP_CLOSE);
			}
			else if(result == Result_Failed)
			{
				goto_failure("查询信号质量失败");
			}
			break;
		case STEP_CLOSE: // 关闭连接
			result = ec800m.close_socket(connectID);
			if(result == Result_Success)
			{
				goto_step(STEP_OPEN);
			}
			else if(result == Result_Failed)
			{
				goto_failure("关闭连接失败");
			}
			break;
		case STEP_OPEN: // 打开客户端
			result = ec800m.open_socket(connectID, "UDP",aliyuniot_get_host(), aliyuniot_get_port(), 1, &socket_err);
			if(result == Result_Success)
			{
				if(socket_err == 0)
				{
					goto_step(STEP_JUDGE_AUTH_OR_DATA);
				}
				else
				{
					goto_failure("客户端打开错误");
				}
			}
			else if(result == Result_Failed)
			{
				goto_failure("打开客户端失败");
			}
			break;
		case STEP_JUDGE_AUTH_OR_DATA: // 判断认证还是发送
			auth_or_data = aliyuniot_is_authentication();
			if(auth_or_data == 1) // 已认证
			{
				goto_step(STEP_JOIN_DATA_MESSAGE);
			}
			else
			{
				goto_step(STEP_JOIN_AUTH_MESSAGE);
			}
			break;
		case STEP_JOIN_AUTH_MESSAGE: // 拼接认证报文
			if(auth_times > 0) // 最多重新认证一次
			{
				goto_failure("认证次数过多");
			}
			else 
			{
				memset(coap_message, 0, sizeof(coap_message));
				aliyuniot_get_auth_message(coap_message, &coap_message_length);
				goto_step(STEP_SET_QISDE_0);
				auth_times++;
			}
			break;
		case STEP_JOIN_DATA_MESSAGE: // 拼接数据报文
			pump_params.lac = cgreg_lac;
			pump_params.ci = cgreg_ci;
			Pump_Params_Refresh();
					// 编码
			memset(databuff, 0, sizeof(databuff));
			business_protocol_encode(pump_params, databuff, &data_length);
			memset(coap_message, 0, sizeof(coap_message));
			aliyuniot_get_data_message(databuff, data_length, coap_message, &coap_message_length);
		
			goto_step(STEP_SET_QISDE_0);
			break;
		case STEP_SET_QISDE_0: // 关闭发送回显
			result = ec800m.set_qisde(0);
			if(result == Result_Success)
			{
				goto_step(STEP_SEND);
			}
			else if(result == Result_Failed)
			{
				goto_failure("关闭发送回显失败");
			}
			break;
		case STEP_SEND: // 发送send
			result = ec800m.send(connectID, coap_message, coap_message_length);
			if(result == Result_Success)
			{
				goto_step(STEP_RECV);
			}
			else if(result == Result_Failed)
			{
				goto_failure("发送send失败");
			}
			break;
		case STEP_RECV: // 等待结果
			result = ec800m.recv_with_time(connectID, coap_message, &coap_message_length, 10000);
			if(result == Result_Success)
			{
				uint8_t res = aliyuniot_recv_data_handle(coap_message, coap_message_length);
				if(res == 0) // 发送失败
				{
					goto_step(STEP_JUDGE_AUTH_OR_DATA); // 重新认证
				}
				else if(res == 1) // 认证成功
				{
					goto_step(STEP_JOIN_DATA_MESSAGE);
				}
				else if(res == 2) // 发送成功
				{
					goto_success("发送成功");
				}
			}
			else if(result == Result_Failed)
			{
				goto_failure("等待结果失败");
			}
			break;
		case STEP_WAIT: // 等待
			wait();
			break;
		case STEP_SUCCESS: // 成功
			goto_step(STEP_SET_SLEEP);
			break;
		case STEP_FAILURE: // 失败
			goto_step(STEP_SET_SLEEP);
			break;
		case STEP_SET_SLEEP: // 设置休眠模式
			result = ec800m.set_sleep(1);
			if(result != Result_None)
			{
				goto_step(STEP_SET_CFUN_0);
			}
			break;
		case STEP_SET_CFUN_0: // 设置最小功能模式
			result = ec800m.set_cfun(0);
			if(result != Result_None)
			{
				goto_step(STEP_ENTER_SLEEP);
			}
			break;
		case STEP_ENTER_SLEEP: // 进入睡眠
			ec800m.enter_sleep();
			goto_step(STEP_FINISH);
			break;
		case STEP_FINISH: // 结束流程
			break;
		default:
			break;
	}
	
}

#endif