#include "string.h"
#include <stdlib.h>
#include "protocol.h"
#include "malloc.h"
#include "gateway_message.h"

GATEWAY_PARAMS gateway_config_params = {0};

GATEWAY_PARAMS *get_gateway_config_params()
{
    return &gateway_config_params;
}

void parseStringField(const char *data, const char *field, char *value);
int parseIntField(const char *data, const char *field);
void addNode(char *nodestring);
void addDevice(char *string, NODE_PARAMS *node);
int extract_substring(const char *input_string, const char *start_token, const char *end_token, char *result);
void addSensorListParams(char *paramString, DEVICE_PARAMS *device);

/**
 * @brief  解析输入字符串网关结构体信息，将数据保存
 * @param  char *nodestring 输入字符串的数据
 * @retval 无
 */
void addGatewayParams(char *gatewayString)
{
		
    parseStringField(gatewayString, "\"commandTopic\":\"", (char *)&gateway_config_params.commandTopic);
    parseStringField(gatewayString, "\"messageTopic\":\"", (char *)&gateway_config_params.messageTopic);
    parseStringField(gatewayString, "\"deviceId\":\"", (char *)&gateway_config_params.deviceId);
    parseStringField(gatewayString, "\"host\":\"", (char *)&gateway_config_params.host);
    gateway_config_params.port = parseIntField(gatewayString, "\"port\":");
	  gateway_config_params.node_params=NULL;
    gateway_config_params.pollTime = parseIntField(gatewayString, "\"pollTime\":");
    uint8_t nodeIndex = 1;
    char nodeStart[6];
		char nodeEnd[6];
		char *nodeString=mymalloc(SRAMEX,5*1024);
    while (1)
    {
			sprintf(nodeStart,"node_%d",nodeIndex);
			sprintf(nodeEnd,"node_%d",nodeIndex+1);
			if(extract_substring(gatewayString,nodeStart,nodeEnd,nodeString))
			{
				addNode(nodeString);
				nodeIndex++;
			}
			else
			{
				break;
			}
    }
		myfree(SRAMEX,nodeString);
		GATEWAY_PARAMS *get=get_gateway_config_params();
		GATEWAY_PARAMS *set=get_gateway_config_params();
		
}

/**
 * @brief  解析输入的字符串节点信息,并将此节点信息挂载在网关结构体的节点下面
 * @param  char *nodestring
 * @retval 无
		注：node内包含的设备名称device_1在别的节点下也可能包含，所以在解析节点时要先将数据截取出来让匹配不会越界到别的节点
 */

void addNode(char *nodestring)
{
    // 新增一个节点的设备并解析最外层的节点属性
    char *deviceString = (char *)nodestring; // 用于移位解析device设备信息
		NODE_PARAMS *newNode=mymalloc(SRAMIN,sizeof(NODE_PARAMS));
    newNode->device_params = NULL; // 先将其设备挂载为NULL
    newNode->nextNode = NULL;      // 下一个设备的挂载为NULL
    parseStringField(nodestring, "\"nodeId\":\"", (char *)&newNode->node_address);
    newNode->RFFrequency = parseIntField(nodestring, "\"RFFrequency\":");
    newNode->SignalBw = parseIntField(nodestring, "\"SignalBw\":");
    newNode->SpreadingFactor = parseIntField(nodestring, "\"SpreadingFactor\":");
    newNode->ErrorCoding = parseIntField(nodestring, "\"ErrorCoding\":");

    uint8_t deviceIndex = 1;
		char *device=mymalloc(SRAMIN,20);
    while (1)
    {
        sprintf(device, "\"device_%d\":", deviceIndex);
        // 判断内部是否包含node_num有就不断的++,
        char *deviceString = strstr(nodestring, device);
        if (deviceString)
        {
            addDevice(deviceString, newNode); // 往此节点下挂载设备信息
            deviceIndex++;
        }
        else
        {
            break;
        }
        /* code */
    }
    myfree(SRAMIN,device);

    // 添加节点到网关链表中
    if (gateway_config_params.node_params == NULL)
    {
        gateway_config_params.node_params = newNode;
    }
    else
    {
        NODE_PARAMS *current = gateway_config_params.node_params;
        while (current->nextNode != NULL)
        {
            current = current->nextNode;
        }
        current->nextNode = newNode;
    }
}
/**
 * @brief  解析输入字段的字符串，解析出属于该节点下的设备信息
 * @param  uint8_t *string输入的字符串数据,NODE_PARAMS *node节点信息
 * @retval 无
 */
void addDevice(char *deviceString, NODE_PARAMS *node)
{
		char *paramString=(char *)deviceString;                                          //属性指针
    // 创建新设备页
    DEVICE_PARAMS *newDevicePage = (DEVICE_PARAMS *)malloc(sizeof(DEVICE_PARAMS));
    newDevicePage->nextDevice = NULL;
    parseStringField(deviceString, "\"deviceId\":\"", (char *)&newDevicePage->deviceID);
    newDevicePage->protocol = parseIntField(deviceString, "\"protocol\":");
		newDevicePage->params = malloc(sizeof(PARAMS_PROTOCOL_COMMAND));
		
  	paramString=strstr(paramString,"\"sensorList\":[");                             //找到该节点的轮询上发属性
	  while(1)                                                                           //此处数据是以数组形式存储所以解析方法和上面不一样
		{
			addSensorListParams(paramString,newDevicePage);                                //解析一个属性并挂载该属性于该属性下
			paramString=strstr(paramString,"}");                                           //移动到下一条属性
			paramString++;
			if(paramString[0]==']')
			{
				paramString=(char *)deviceString;                                              //复原指针位置
				break;                                                                         //找到了结束符，跳出循环
			}
		}                                 
		//解析下发的mqtt存储信息下发控制指令
		if(newDevicePage->protocol==MODBUS)
		{
			paramString=strstr(paramString,"\"commandList\":[");
			while(1)
			{
				
			}
		}
    // 添加设备页到链表末尾
    if (node->device_params == NULL)
    {
        node->device_params = newDevicePage;
    }
    else
    {
        DEVICE_PARAMS *current = node->device_params;
        while (current->nextDevice != NULL)
        {
            current = current->nextDevice;
        }
        current->nextDevice = newDevicePage;
    }
}
/**
 * @brief  解析输入字符串的paramString数据,将数据保存到至该设备结构体下，此处解析sensorList
 * @param  uint8_t *paramString输入的字符串数据,DEVICE_PARAMS *device节点信息
 * @retval 无
 */
void addSensorListParams(char *paramString, DEVICE_PARAMS *device)
{
    

    switch (device->protocol)
    {
    case DLT645_97:
    case DLT645_07:
        NODE_READ_DLT645_COMMAND *read_dlt645_command = malloc(sizeof(NODE_READ_DLT645_COMMAND));
        read_dlt645_command->Identification = parseIntField(paramString, "\"identifier645\":");
        parseStringField(paramString, "\"identifier\":\"", (char *)&read_dlt645_command->keyword);
        if (device->params->node_read_dlt645_command == NULL)
        {
            device->params->node_read_dlt645_command= read_dlt645_command;
        }
        else
        {
            PARAMS_PROTOCOL_COMMAND *current= device->params;
            while (current->nextParams->node_read_modbus_command!= NULL)
            {
                current = current->nextParams;
            }
            current->nextParams->node_read_dlt645_command = read_dlt645_command;
        }
        break;
    case MODBUS:
        NODE_READ_MODBUS_COMMAND *read_modbus_command = malloc(sizeof(NODE_READ_MODBUS_COMMAND));
        read_modbus_command->bigLittleFormat = parseIntField(paramString, "\"bigLittleFormat\":");
        read_modbus_command->dataType = parseIntField(paramString, "\"dataType\":");
        read_modbus_command->decimalPoint = parseIntField(paramString, "\"precise\":");
        read_modbus_command->functionCode = parseIntField(paramString, "\"rFunctionCode\":");
        read_modbus_command->slaveAddress = parseIntField(paramString, "\"slaveAddress\":");
        read_modbus_command->registerAddress = parseIntField(paramString, "\"registerAddress\":");
        read_modbus_command->registerByteNum = parseIntField(paramString, "\"registerByteNum\":");
        if (device->params->node_read_dlt645_command == NULL)
        {
            device->params->node_read_dlt645_command= read_dlt645_command;
        }
        else
        {
            PARAMS_PROTOCOL_COMMAND *current= device->params;
            while (current->nextParams!= NULL)
            {
                current = current->nextParams;
            }
            current->nextParams->node_read_dlt645_command = read_dlt645_command;
        }
        break;
    default:
        break;
    }
		
}
/**
 * @brief  解析输入字符串的paramString数据,将数据保存到至该设备结构体下，此处解析commandList
 * @param  uint8_t *paramString输入的字符串数据,DEVICE_PARAMS *device节点信息
 * @retval 无
 */
void addCommandListParams(char *paramString, DEVICE_PARAMS *device)
{
	
}
// 提取int数据
int parseIntField(const char *data, const char *field)
{
    char *ptr = strstr(data, field) + strlen(field);
    int value;
    value = strtol(ptr, &ptr, 10);
    return value;
}

// 提取string字符串
void parseStringField(const char *data, const char *field, char *value)
{
    char *ptr = strstr(data, field) + strlen(field);
    sscanf(ptr, "%[^\"],", value);
}

// 不采用json解析硬解json数据
void processStringJson(uint8_t *data)
{
    GATEWAY_PARAMS *gateway;
    gateway = get_gateway_config_params();
    uint8_t *ptr = (uint8_t *)data;
    parseStringField((char *)&ptr, "\"messageTopic\":\"", (char *)&gateway->messageTopic);
    parseStringField((char *)&ptr, "\"commandTopic\":\"", (char *)&gateway->commandTopic);
    gateway->port = parseIntField((char *)&ptr, "\"port\":\"");
    parseStringField((char *)&ptr, "\"host\":\"", (char *)&gateway->host);
    parseStringField((char *)&ptr, "\"deviceId\":\"", (char *)&gateway->deviceId);
    // 解析最外层数据完成,申请空间存储节点信息

    int nodeNum = 1;
    char *node_index = malloc(10);
    sprintf(node_index, "node_%d", nodeNum);
    strstr(ptr, node_index); // 将指针指向第一个节点
    while (*ptr == NULL)
    {
    }
    free(node_index);
}
/**
 * @brief  从输入的input_string中寻找开始到结束位置的字符串数据，并将数据截取出来，传给result;
 * @param  input_string输入字符串，start_token字符串起始位置，end_token字符串结束位置，result截取出的字符串
* @retval 0:没有被截取到的字符串。1：有被截取到的字符串。
 */
int extract_substring(const char *input_string, const char *start_token, const char *end_token, char *result) {
    const char *start_ptr = strstr(input_string, start_token);
    
    if (start_ptr == NULL) {
        return 0;  // 未找到起始标记
    }
    
    start_ptr += strlen(start_token);  // 移动指针到起始标记之后
    
    const char *end_ptr = strstr(start_ptr, end_token);
    
    if (end_ptr == NULL) {
        // 如果未找到结束标记，将从起始标记开始的字符串一直复制到 \0 结束
        strcpy(result, start_ptr);
    } else {
        // 找到结束标记，计算截取的长度并复制
        size_t length = end_ptr - start_ptr;
        strncpy(result, start_ptr, length);
        result[length] = '\0';  // 添加字符串结束符
    }
		return 1;
}