#include "CONFIG.h"
#if  AIWB2

#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 "Pump_Dicts_Util.h"
#include "Regist.h"
#include "PumpBusiness.h"
#include "Initialize.h"
#include "Tuoreniot.h"


#include "aiwb2.h"


//WiFi连接参数 
char WIFI_ID[50]="tuoren";
char WIFI_PASSWORD[30]="123456789";

// 测试模式
uint8_t UDPCLIENT_TestModeFlag = 0;

// coap报文
static uint8_t coap_message[512]; 
static uint16_t coap_message_length = 0;

// 待发送数据的地址和长度
static uint8_t data[128];
static uint16_t data_length;

// 信号值
static struct Signal
{
	int RSRP;
	int RSRQ; 
	int RSSI; 
	int SINR;
} signal = {
	.RSRP = 99,
	.RSRQ = 99,
	.RSSI = 99,
	.SINR = 99,
};
// 查询信号质量
void UDPCLIENT_QuerySignal(int * RSRP, int * RSRQ, int * RSSI, int * SINR)
{
	*RSRP = signal.RSRP;
	*RSRQ = signal.RSRQ;
	*RSSI = signal.RSSI;
	*SINR = signal.SINR;
}

// 函数声明
static void UDPCLIENT_Process(void); // 流程
static void UDPCLIENT_SetStatus(enum UDPCLIENT_StatusEnum status); // 设置状态
static void UDPCLIENT_SetResult(enum UDPCLIENT_ResultEnum result); // 设置结果

static void goto_start(void); // 开始
static void goto_success(void); // 成功
static void goto_failure(char * _info); // 失败
static void goto_finish(void); // 结束




// 流程
enum Step{
	STEP_NONE, // 空闲状态，无操作
	STEP_START, // 开始
	STEP_EXIT_SLEEP, // 退出睡眠
	STEP_START_AT,//发送AT，检测模块是否唤醒
	STEP_SET_QISDE_0,//关闭发送回显
	STEP_SET_WORKMODE,//设置WIFI工作模式
	STEP_SET_RECEIVEMODE,//设置socket接收模式
	STEP_WIFI_RSSI, //设定查询wifi的信息输出
	STEP_SELECT_AP,//查询WIFI信号强度,设置WIFI
	STEP_WIFI, //模块连接wifi
	STEP_QUERY_SIGNAL,//查询WiFi信号强度
	STEP_OPEN,//打开客户端
	STEP_JUDGE_AUTH_OR_DATA,//判断认证还是发送
	STEP_JOIN_AUTH_MESSAGE,//拼接认证报文
	STEP_JOIN_DATA_MESSAGE,//拼接数据报文
	STEP_SEND,// 发送send
	STEP_WAIT, // 等待
	STEP_SUCCESS,//成功
	STEP_ENTER_SLEEP,// 进入睡眠
	STEP_FAILURE,// 失败
	STEP_FINISH,// 结束流程

};


// 步骤跳转时的监听
//static uint8_t STEP_JOIN_AUTH_MESSAGE_times = 0; // 认证的次数
//static uint8_t STEP_QUERY_CGREG_times = 0; // 查询网络状态的次数
//static void initialize()
//{
//	STEP_JOIN_AUTH_MESSAGE_times = 0;
//	STEP_QUERY_CGREG_times = 0;
//}	
static uint16_t goto_step_event(uint16_t ns)
{
	// 重置ec800m状态
	aiwb2.reset();
	
	// 流程控制
	uint16_t step = ns;
//	if(ns == STEP_JOIN_AUTH_MESSAGE && STEP_JOIN_AUTH_MESSAGE_times++ >= 1)
//	{
//		goto_failure("认证次数过多");
//		step = STEP_FAILURE;
//	}
//	else if(ns == STEP_QUERY_CGREG && STEP_QUERY_CGREG_times++ >= 20)
//	{
//		goto_failure("查询网络状态的次数过多，联网失败");
//		step = STEP_FAILURE;
//	}
	return step;
}

// 流程控制
static struct PCTRL_Struct pctrl = {
	.current_step = STEP_FINISH,
	.next_step = STEP_FINISH,
	.step_wait = STEP_WAIT,
	.goto_step_listener = goto_step_event,
};


// 备注
static char info[40];
// 开始
static void goto_start(void)
{
//	initialize();
	PCTRL_GotoStep(&pctrl, STEP_START, "开始");
}
// 成功
static void goto_success(void)
{
	UDPCLIENT_SetResult(UDPCLIENT_Result_Success);
	PCTRL_GotoStep(&pctrl, STEP_SUCCESS, "成功");
}
// 失败
static void goto_failure(char * _info)
{
	UDPCLIENT_SetResult(UDPCLIENT_Result_Failure);
	memset(info, 0, sizeof(info));
	strcpy(info, _info);
	PCTRL_GotoStep(&pctrl, STEP_FAILURE, "失败");
	Log_Printf_Debug("info：%s！\r\n", info);
}
// 结束
static void goto_finish(void)
{
	UDPCLIENT_SetStatus(UDPCLIENT_Status_Done);
	PCTRL_GotoStep(&pctrl, STEP_FINISH, "结束");
}


// 状态
static enum UDPCLIENT_StatusEnum udpclient_status = UDPCLIENT_Status_None;
// 结果
static enum UDPCLIENT_ResultEnum udpclient_result = UDPCLIENT_Result_None;
// 设置状态
static void UDPCLIENT_SetStatus(enum UDPCLIENT_StatusEnum status)
{
	udpclient_status = status;
}
// 获取状态
enum UDPCLIENT_StatusEnum UDPCLIENT_GetStatus(void)
{
	return udpclient_status;
}
// 设置结果
static void UDPCLIENT_SetResult(enum UDPCLIENT_ResultEnum result)
{
	udpclient_result = result;
}
// 获取结果
enum UDPCLIENT_ResultEnum UDPCLIENT_GetResult(void)
{
	return udpclient_result;
}
// 重置
enum EXECUTE_ResultEnum UDPCLIENT_Reset(void)
{
	if(UDPCLIENT_GetStatus() == UDPCLIENT_Status_Being)
	{
		Log_Printf_Debug("发送流程重置错误！\r\n");
		return EXECUTE_Result_Failure;
	}
	UDPCLIENT_SetStatus(UDPCLIENT_Status_None);
	UDPCLIENT_SetResult(UDPCLIENT_Result_None);
	return EXECUTE_Result_Success;
}
// 开始
enum EXECUTE_ResultEnum UDPCLIENT_Start(void)
{
	UDPCLIENT_Reset();
	if(UDPCLIENT_GetStatus() != UDPCLIENT_Status_None)
	{
		Log_Printf_Debug("发送流程启动错误！\r\n");
		return EXECUTE_Result_Failure;
	}
	goto_start();
	UDPCLIENT_SetStatus(UDPCLIENT_Status_Being);
	return EXECUTE_Result_Success;
}
// 流程处理，放到大循环里
void UDPCLIENT_ProcessHandle(void)
{
	if(UDPCLIENT_GetStatus() == UDPCLIENT_Status_Being)
	{
		UDPCLIENT_Process();
	}
}


// 发送数据的逻辑


static int wifi_number = 0; //wifi信息编号变量
int wifi_rssi[10];			//各wifi信号值存储数组
static enum Result result = Result_None;
//UDPID=2 表示建立UDP连接
static uint8_t UDPID = 2;
//static uint16_t socket_err = 0;

//获取最佳wifi_rssi中最佳信号位置
int get_BestWifiSignal(int* rssi, int number)
{
	int signal=0;   //假设首个wifi信号最好
	int value=-99;	//初始化比较值
	for(int i=0; i<number; i++)
	{
		if((rssi[i] > value) && (rssi[i] != 0))
		{
			value = rssi[i];
			signal = i;
		}
	}
	return signal;
}


static void UDPCLIENT_Process(void)
{
		// 流程
	switch(pctrl.current_step)
	{
		case STEP_NONE: // 空闲
		break;
		case STEP_START: // 开始
			PCTRL_GotoStep(&pctrl, STEP_EXIT_SLEEP, "退出休眠");
			break;
		case STEP_EXIT_SLEEP: // 退出休眠
			result = aiwb2.exit_sleep_io_test();
			aiwb2.exit_sleep_io();
			PCTRL_GotoStepWait(&pctrl, STEP_START_AT,350, "设定模块查询信息的输出");
			break;
		case STEP_START_AT:	//开始AT,检测模块是否唤醒
			result = aiwb2.test_at();
			if(result == Result_Success)
			{
				PCTRL_GotoStep(&pctrl,STEP_SET_QISDE_0,"关闭发送回显");
			}
			else if(result == Result_Failed)
			{
				goto_failure("发送AT失败,模块未唤醒");
			}
			break;		
		case STEP_SET_QISDE_0: // 关闭发送回显
			result = aiwb2.set_qisde(0);
			if(result == Result_Success)
			{
				PCTRL_GotoStep(&pctrl, STEP_SET_WORKMODE, "设置WIFI工作模式");
			}
			else if(result == Result_Failed)
			{
				goto_failure("关闭发送回显失败");
			}
			break;	
		case STEP_SET_WORKMODE://设置WIFI工作模式
			result = aiwb2.set_workmode(1,1);
			if(result == Result_Success)
			{
				PCTRL_GotoStepWait(&pctrl,STEP_SET_RECEIVEMODE,3,"设置socket接收模式");
			}	
			else if(result == Result_Failed)
			{
				goto_failure("设置WIFI工作模式失败");
			}
			break;
		case STEP_SET_RECEIVEMODE://设置socket接收模式
			result = aiwb2.set_receivingmode(1);
			if(result == Result_Success)
			{
				PCTRL_GotoStepWait(&pctrl,STEP_WIFI_RSSI,3,"设定模块查询信息的输出");
			}
			else if(result == Result_Failed)
			{
					goto_failure("设置socket接收模式失败");
			}
			break;			
		case STEP_WIFI_RSSI: //设定模块查询信息的输出
			 result = aiwb2.set_dataout();
			if(result == Result_Success)
			{
			 PCTRL_GotoStepWait(&pctrl, STEP_SELECT_AP, 3, "查询WIFI信号强度,设定连接wifi");
			}
			else if(result == Result_Failed)
			{
				goto_failure("设定模块查询信息的输出失败");
			}
		break;	
		case STEP_SELECT_AP://查询WIFI信号强度,设置WIFI
		if(wifi_number < regist_response.wifiNumber)
		{
			result = aiwb2.query_id_signal(regist_response.wifi[wifi_number].wifiName, &wifi_rssi[wifi_number]);
			if(result == Result_Success || result == Result_Failed)
			{
				Log_Printf_Debug("wifi%d的信号值RSSI=%d\r\n",wifi_number,wifi_rssi[wifi_number]);
				Log_Printf_Debug("wifi_number=%d\r\n",wifi_number);
				wifi_number++;
				if(wifi_number == regist_response.wifiNumber)
				{
					PCTRL_GotoStep(&pctrl, STEP_SELECT_AP, "wifi查询完成");
				}else 
				{
					PCTRL_GotoStep(&pctrl, STEP_SELECT_AP, "继续wifi的RSSI,选择wifi");
				}
			}
		}
		else
		{
			//获取信号最佳的wifi在数组中的位置
			int i=get_BestWifiSignal(wifi_rssi, wifi_number);
			//拷贝wifi信息
			strcpy(WIFI_ID,regist_response.wifi[i].wifiName);
			strcpy(WIFI_PASSWORD,regist_response.wifi[i].wifiPassword);
			Log_Printf_Debug("选择信号最好的第%d组wifi\r\n",i);
			Log_Printf_Debug("WIFI_ID=%s\r\n",WIFI_ID);
			Log_Printf_Debug("WIFI_PASSWORD=%s\r\n",WIFI_PASSWORD);
			PCTRL_GotoStep(&pctrl, STEP_WIFI, "模块连接wifi");
		}
		break;
		case STEP_WIFI: //模块连接wifi
			result = aiwb2.set_connect_WIFI(WIFI_ID, WIFI_PASSWORD);
			if(result == Result_Success)
			{
			 PCTRL_GotoStepWait(&pctrl, STEP_QUERY_SIGNAL, 3, "查询已连接的wifi信号强度");
			}
			else if(result == Result_Failed)
			{
				goto_failure("模块连接wifi失败");
			}
		break;
		case STEP_QUERY_SIGNAL://查询已连接的WiFi信号强度
    		result = aiwb2.query_signal(&signal.RSSI);
    		if(result == Result_Success)
    		{
    			PCTRL_GotoStep(&pctrl, STEP_OPEN, "打开客户端");
    		}
    		else if(result == Result_Failed)
    		{
    			goto_failure("查询WiFi信号强度失败");
    		}
    		break;  
		case  STEP_OPEN:// 打开客户端
			result = aiwb2.open_socket(UDPID,regist_response.address,regist_response.port);
			if(result == Result_Success)
			{
				 PCTRL_GotoStep(&pctrl, STEP_JUDGE_AUTH_OR_DATA, "判断认证还是发送");
			}
			else if(result == Result_Failed)
			{
				goto_failure("客户端打开失败");
			}
		break;
		case STEP_JUDGE_AUTH_OR_DATA: // 判断认证还是发送
				if(TUORENIOT_IsAuthentication() == 1) // 已认证
			{
				PCTRL_GotoStep(&pctrl, STEP_JOIN_DATA_MESSAGE, "拼接数据报文");
			}
			else
			{
				PCTRL_GotoStep(&pctrl, STEP_JOIN_AUTH_MESSAGE, "拼接认证报文");
			}
			break;	
		case STEP_JOIN_AUTH_MESSAGE: // 拼接认证报文
			memset(coap_message, 0, sizeof(coap_message));
			TUORENIOT_PackAuthMessage(coap_message, &coap_message_length);
//		    Log_Printf_Debug("数据报文%d\r\n", coap_message_length);
//		    Log_SendHex(coap_message, coap_message_length);
//     		Log_Printf_Debug("\r\n");
			PCTRL_GotoStep(&pctrl, STEP_SEND, "发送认证报文");
			break;
		case STEP_JOIN_DATA_MESSAGE: // 拼接数据报文
			
			//
			strcpy(regist_response.deviceSecret,"7bd7eaa33860ce9a2bd1b33633127f04");
		
			PUMPBUSINESS_ParamsRefresh();// 编码
			memset(data, 0, sizeof(data));
			PUMPDICTS_ProtocolEncode(&pump_params, data, &data_length);
			memset(coap_message, 0, sizeof(coap_message));
			TUORENIOT_PackDataMessage(data, data_length, coap_message, &coap_message_length);
//			Log_Printf_Debug("数据报文%d\r\n", coap_message_length);
//			Log_SendHex(coap_message, coap_message_length);
//			Log_Printf_Debug("\r\n");
			PCTRL_GotoStep(&pctrl, STEP_SEND, "发送数据报文");
			break;
		case STEP_SEND: // 发送send
			result = aiwb2.send(conID, coap_message, coap_message_length,&coap_message_length);
			if(result == Result_Success)
			{
			uint8_t res	= TUORENIOT_AnalysisMessage(coap_message, coap_message_length);
			 if(res == 0) 		// 发送失败
			{
			 PCTRL_GotoStep(&pctrl, STEP_JUDGE_AUTH_OR_DATA, "重新认证"); // 重新认证
			}
			 else if(res == 1) 	// 认证成功
			{
			 PCTRL_GotoStep(&pctrl, STEP_JOIN_DATA_MESSAGE, "拼接数据报文");
			}
			else if(res == 2) 	// 发送成功
			{
			 goto_success();
			 }
			}
			else if(result == Result_Failed)
			{
			 goto_failure("等待结果失败");
		    }
			break;	
		case STEP_WAIT: // 等待
			PCTRL_Wait(&pctrl);
			break;			
		case STEP_SUCCESS: // 成功
			PCTRL_GotoStep(&pctrl, STEP_ENTER_SLEEP, "进入睡眠");
			break;
		case STEP_FAILURE: // 失败
			PCTRL_GotoStep(&pctrl, STEP_ENTER_SLEEP, "进入睡眠");
			break;
		case STEP_ENTER_SLEEP: // 进入睡眠
			aiwb2.enter_sleep_io();
			goto_finish();
			break;
		case STEP_FINISH: // 结束流程
			Log_Printf_Debug("流程结束");
			break;
		default:
			goto_failure("步骤不存在");
			break;
		
	}
}	

#endif