/* Includes ------------------------------------------------------------------*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#ifdef CFG_DEV_TYPE_LAND_PD
/* 标准C库头文件. */
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <sys/prctl.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <termios.h>
#include <fcntl.h>

/* 用户代码头文件. */
#include "main.h"
#include "cmd.h"
#include "fifo.h"
#include "pd_dau.h"
#include "pd_hf.h"
#include "pd_csg.h"

/* Define --------------------------------------------------------------------*/
#define DUA_UDP_PORT    23760
#define DUA_SEND_FIFO_NUM  (8)

/* Private typedef -----------------------------------------------------------*/

/* Private variables ---------------------------------------------------------*/
dau_t daus[PD_SLOTS_MAX];

/* Private function prototypes -----------------------------------------------*/

/* Internal functions --------------------------------------------------------*/
/* 包头填充 */
void _dau_head_init(dau_t *dau, dau_head_init_t *head_data)
{
    dau_pkt_head_t *head = (dau_pkt_head_t*)head_data->pkt;

    /* 封装报文头. */
    head->len = head_data->len;
    head->dev_type_m = dau->info.type_m;
    head->dev_type_s= dau->info.type_s;
    head->dev_id = dau->info.dev_id;
    head->cmd_type = head_data->cmd_type;
    head->cmd = head_data->cmd;
    head->version = 1;
    head->pkt_id = head_data->pkt_id;
}

/* dau 插入处理 */
int _dau_insert(dau_t *dau) 
{
    if (3 == dau->info.type_m && 1 == dau->info.type_s)
    {
        dau->recv_cb = hf_recv_process;
        dau->send_cb = hf_send_process;
        dau->private_data = hf_data_malloc();
    }
    else
    {
        return E_NOT_FOUND;
    }

    dau->state.is_connect = TRUE;

    return E_NONE;
}

/* 初始化UDP服务器 */
int32_t _dau_udp_server_init(dau_t *dau) 
{
    struct sockaddr_in server = {0};
    int fd = -1;

    fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (fd < 0) 
    {
        log_err(LOG_DAU, "ERROR at socket creating return %s!", safe_strerror(errno));
        return E_SYS_CALL;
    }
    
    /* 绑定端口 */
    bzero(&server, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = htonl(INADDR_ANY);
    server.sin_port = htons(DUA_UDP_PORT + dau->slot);
    if (bind(fd, (struct sockaddr*)&server, sizeof(server)) < 0)
    {
        log_err(LOG_DAU, "ERROR at socket bind return %s!", safe_strerror(errno));
        close(fd);
        return E_SYS_CALL;
    }

    dau->fd = fd;
    return E_NONE;
}

/* dau 开机联络处理函数 */
void _dau_recv_connect(dau_t *dau, uint16_t recv_len)
{
    dau_head_init_t head_data;
    dau_pkt_head_t *head = (dau_pkt_head_t*)dau->buf_recv;
    dau_contact_t *pnet = (dau_contact_t*)(dau->buf_recv + sizeof(dau_pkt_head_t));
    dau_ack_t *ack = (dau_ack_t*)(dau->buf_recv + sizeof(dau_pkt_head_t));
    dau_contact_t *info = NULL;
    
    /* 复制设备信息 */
    memcpy(&dau->info, pnet, sizeof(dau_contact_t));
    
    /* 添加 dau */
    LD_N_RETURN_N(_dau_insert(dau));

    /* 回复报文 */
    ack->result = 0;
    head_data.cmd_type = DAU_REQUEST;
    head_data.cmd = DAU_C_CONTACT;
    head_data.pkt_id = head->pkt_id;
    head_data.pkt = dau->buf_recv;
    head_data.len = sizeof(dau_pkt_head_t) + sizeof(dau_ack_t);
    dau_data_send(dau, &head_data);    

    /* 给后台发送添加信息 */
    /* 申请内存 */
    info = XMALLOC(MTYPE_CSG, sizeof(dau_contact_t));
    if (!info)
    {
        DBG(DBG_M_PD_DAU_ERR, "XMALLOC ERROR!\r\n");
        return;
    }

    /* 复制设备信息 */
    memcpy(info, &dau->info, sizeof(dau_contact_t));

    /* 发送给后台 */
    if (dau_msg_send_cmd(DAU_SEND_ADD, info) != E_NONE)
    {
        XFREE(MTYPE_CSG, info);
    }

    return;
}

/* dau 数据包处理函数 */
void _dau_recv_data_process(dau_t *dau, uint16_t recv_len, struct sockaddr_in *server)
{
    dau_pkt_head_t *head = (dau_pkt_head_t*)dau->buf_recv;
    
    if (DAU_REPLY == head->cmd_type && DAU_C_CONTACT == head->cmd)
    {
        /* 响应连接报文 */
        if (head->len > DAU_BUF_SIZE)
        {
            DBG(DBG_M_PD_DAU_ERR, "Recvfrom len %d ERROR!\r\n", head->len);
            return;
        }
    
        memcpy(&dau->server, server, sizeof(struct sockaddr_in));
        _dau_recv_connect(dau, recv_len);
    }
    else
    {
        /* 响应其他报文 */
        if (dau->recv_cb)
        {
            dau->recv_cb(dau->slot, dau->buf_recv, recv_len);
        }
    }

    return;
}

/* dau 收包线程 */
void *_dau_recv_handle(void *arg)
{
    dau_t *dau = (dau_t*)arg;
    struct sockaddr_in server;
    socklen_t server_len = sizeof(struct sockaddr_in);
    uint16_t data_len = 0;

    /* 初始化 socket */
    if (_dau_udp_server_init(dau) != E_NONE)
    {
        return NULL;
    }

    /* 等待初始化完成 */
    while(!is_system_init)
    {
        sleep(1);
    }

    while(1)
    {
        /* 读取数据. */
        data_len = recvfrom(dau->fd, dau->buf_recv, DAU_BUF_SIZE, 0, (struct sockaddr*)&server, &server_len);
        if (data_len <= 0)
        {
            DBG(DBG_M_PD_DAU_ERR, "Recvfrom return ERROR %s!\r\n", safe_strerror(errno));
            continue;
        }

        _dau_recv_data_process(dau, data_len, &server);
    }

    return NULL;
}

/* dau 收包线程 */
void *_dau_send_handle(void *arg)
{
    dau_t *dau = (dau_t*)arg;
    dau_send_msg_t *recv_msg = NULL;

    /* 等待初始化完成 */
    while(!is_system_init)
    {
        sleep(1);
    }

    while(1)
    {
        if (fifo_read(dau->fifo_send, (void**)&recv_msg) != 0)
        {
            DBG(DBG_M_PD_DAU_ERR, "ERROR at fifo %d read!\r\n", dau->fifo_send);
            continue;
        }

        /* 响应其他报文 */
        if (dau->send_cb)
        {
            dau->send_cb(dau->slot, recv_msg->type, recv_msg->data);
        }

        /* 释放数据内存, 注意一定要在 fifo_push 之前调用, 因为 fifo_push 后 recv_msg 已被释放. */
        XFREE(MTYPE_CSG, recv_msg->data);
        fifo_push(dau->fifo_send);
    }

    return NULL;
}

/* dau 预初始化 */
int32_t dau_handle_init(void)
{
    uint8_t i = 0;
    
    memset(&daus, 0, sizeof(dau_t) * PD_SLOTS_MAX);

    for (i = 0; i < PD_SLOTS_MAX; i++) 
    {
        daus[i].slot = i;
    }

    return E_NONE;
}

/* dau 初始化 */
int32_t dau_handle_init_after(void)
{
    thread_param_t param = {0};
    char fifo_name[THREAD_NAME_LEN];
    uint8_t i = 0;

    /* 初始收包线程 */
    for (i = 0; i < DAU_ETH_SLOTS_SUM; i++) 
    {
        snprintf(fifo_name, THREAD_NAME_LEN, "DAU_SEND_%d", i);
        daus[i].fifo_send = fifo_create(fifo_name, DUA_SEND_FIFO_NUM);
    
        param.arg = (void*)(&daus[i]);
        param.priority = 80;
        param.log_module = LOG_DAU;
        snprintf(param.thread_name, THREAD_NAME_LEN, "DAU_RECV_%d", i);
        create_thread(_dau_recv_handle, &param);

        param.arg = (void*)(&daus[i]);
        param.priority = 50;
        param.log_module = LOG_DAU;
        snprintf(param.thread_name, THREAD_NAME_LEN, "DAU_SEND_%d", i);
        create_thread(_dau_send_handle, &param);
    }
    
    return E_NONE;
}

/* 数据发送 */
void dau_data_send(dau_t *dau, dau_head_init_t *head_data)
{
    int32_t rv = 0;

    /* 封装报文头. */
    _dau_head_init(dau, head_data);

    rv = sendto(dau->fd, head_data->pkt, head_data->len, 0, (struct sockaddr*)&dau->server, sizeof(dau->server));
    if (rv < 0)
    {
        DBG(DBG_M_PD_DAU_ERR, "Sendto return %s!\r\n", safe_strerror(errno));
    }
}

/* 发送数据到后台通讯进程. */
int32_t dau_msg_send_cmd(uint32_t type, void *data)
{
    dau_send_msg_t msg;
    
    /* 封装消息. */
    msg.type = type;
    msg.data = data;

    /* 发送消息 */
    if (fifo_write(csg.fifo_cmd_id, (void*)(&msg), sizeof(dau_send_msg_t)) != sizeof(dau_send_msg_t))
    {
        DBG(DBG_M_PD_DAU_ERR, "DAU write ERROR! type=%d\r\n", type);
        return E_ERROR;
    }
    
    return E_NONE;
}

#endif