#include "tcpserverc.h"
#include "lwip/netif.h"
#include "lwip/ip.h"
#include "lwip/tcp.h"
#include "lwip/init.h"
#include "netif/etharp.h"
#include "lwip/udp.h"
#include "lwip/pbuf.h"
#include <stdio.h>
#include <string.h>
#include "usart.h"
#include "main.h"
#include "ht1200m.h"
struct tcp_pcb *server_pcb_hart1 = NULL;
struct tcp_pcb *server_pcb_hart2 = NULL;
struct tcp_pcb *server_pcb_ble1 = NULL;
struct tcp_pcb *server_pcb_ble2 = NULL;
extern uint8_t tcp_echo_flags_hart1;
extern uint8_t tcp_echo_flags_hart2;
extern uint8_t tcp_echo_flags_ble1;
extern uint8_t tcp_echo_flags_ble2;
/*接收回调函数*/
static err_t tcpecho_recv_hart1(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块   接收到的数据
    if (p != NULL)
    {
        /* 更新窗口*/
        tcp_echo_flags_hart1 = 1;
        tcp_recved(tpcb, p->tot_len); // 读取数据的控制块   得到所有数据的长度
        memcpy(&server_pcb_hart1, &tpcb, sizeof(struct tcp_pcb *));
#if 0
        memcpy(hart2_uart2.tx_data, (int *)p->payload, p->tot_len);
        HART2_RTS_SEND;
        HAL_UART_Transmit(&huart2, hart2_uart2.tx_data, p->tot_len, 1000);
        HART2_RTS_RECEIVE;
#endif
#if 1
        memcpy(hart1_uart5.tx_data, (int *)p->payload, p->tot_len);
        HART1_RTS_SEND;
        dma_usart_send(&huart5, hart1_uart5.tx_data, p->tot_len);
        // HART1_RTS_RECEIVE;
#endif
        memset(p->payload, 0, p->tot_len);
        pbuf_free(p);
    }
    else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
    {
        return tcp_close(tpcb);
    }
    return ERR_OK;
}

static err_t tcpecho_recv_hart2(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块   接收到的数据
    if (p != NULL)
    {
        /* 更新窗口*/
        tcp_echo_flags_hart2 = 1;
        tcp_recved(tpcb, p->tot_len); // 读取数据的控制块   得到所有数据的长度
        memcpy(&server_pcb_hart2, &tpcb, sizeof(struct tcp_pcb *));
#if 1
        memcpy(hart2_uart2.tx_data, (int *)p->payload, p->tot_len);
        HART2_RTS_SEND;
        dma_usart_send(&huart2, hart2_uart2.tx_data, p->tot_len);
#endif
#if 0
        memcpy(hart1_uart5.tx_data, (int *)p->payload, p->tot_len);
        HART1_RTS_SEND;
        HAL_UART_Transmit(&huart5, hart1_uart5.tx_data, p->tot_len, 100);
        HART1_RTS_RECEIVE;
#endif

        memset(p->payload, 0, p->tot_len);
        pbuf_free(p);
    }
    else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
    {
        return tcp_close(tpcb);
    }
    return ERR_OK;
}

static err_t tcpecho_recv_ble1(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块   接收到的数据
    if (p != NULL)
    {
        /* 更新窗口*/
        tcp_echo_flags_ble1 = 1;
        tcp_recved(tpcb, p->tot_len); // 读取数据的控制块   得到所有数据的长度
        memcpy(&server_pcb_ble1, &tpcb, sizeof(struct tcp_pcb *));

        memcpy(ble1_uart6.tx_data, (int *)p->payload, p->tot_len);
        dma_usart_send(&huart6, ble1_uart6.tx_data, p->tot_len);

        memset(p->payload, 0, p->tot_len);
        pbuf_free(p);
    }
    else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
    {
        return tcp_close(tpcb);
    }
    return ERR_OK;
}

static err_t tcpecho_recv_ble2(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块   接收到的数据
    if (p != NULL)
    {
        /* 更新窗口*/
        tcp_echo_flags_ble2 = 1;
        tcp_recved(tpcb, p->tot_len); // 读取数据的控制块   得到所有数据的长度
        memcpy(&server_pcb_ble2, &tpcb, sizeof(struct tcp_pcb *));

        memcpy(ble2_uart3.tx_data, (int *)p->payload, p->tot_len);
        dma_usart_send(&huart3, ble2_uart3.tx_data, p->tot_len);

        memset(p->payload, 0, p->tot_len);
        pbuf_free(p);
    }
    else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
    {
        return tcp_close(tpcb);
    }
    return ERR_OK;
}
static err_t tcpecho_accept_hart1(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
                                                                                // 形参的数量和类型必须一致
{
    tcp_recv(newpcb, tcpecho_recv_hart1); // 当收到数据时，回调用户自己写的tcpecho_recv

    return ERR_OK;
}

static err_t tcpecho_accept_hart2(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
{
    tcp_recv(newpcb, tcpecho_recv_hart2); // 当收到数据时，回调用户自己写的tcpecho_recv

    return ERR_OK;
}

static err_t tcpecho_accept_ble1(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
{
    tcp_recv(newpcb, tcpecho_recv_ble1); // 当收到数据时，回调用户自己写的tcpecho_recv

    return ERR_OK;
}
static err_t tcpecho_accept_ble2(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
{
    tcp_recv(newpcb, tcpecho_recv_ble2); // 当收到数据时，回调用户自己写的tcpecho_recv

    return ERR_OK;
}
void tcp_echo_init(void)
{
    struct tcp_pcb *server_hart1 = NULL;
    struct tcp_pcb *server_hart2 = NULL;
    struct tcp_pcb *server_ble1 = NULL;
    struct tcp_pcb *server_ble2 = NULL;

    /* 创建一个TCP控制块  */
    server_hart1 = tcp_new();

    /* 绑定TCP控制块 */
    tcp_bind(server_hart1, IP_ADDR_ANY, TCP_PORT_HART1);

    /* 进入监听状态 */
    server_hart1 = tcp_listen(server_hart1);

    /* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
    tcp_accept(server_hart1, tcpecho_accept_hart1); // 侦听到连接后，回调用户编写的tcpecho_accept

    /* 创建一个TCP控制块  */
    server_hart2 = tcp_new();

    /* 绑定TCP控制块 */
    tcp_bind(server_hart2, IP_ADDR_ANY, TCP_PORT_HART2);

    /* 进入监听状态 */
    server_hart2 = tcp_listen(server_hart2);

    /* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
    tcp_accept(server_hart2, tcpecho_accept_hart2); // 侦听到连接后，回调用户编写的tcpecho_accept

    /* 创建一个TCP控制块  */
    server_ble1 = tcp_new();

    /* 绑定TCP控制块 */
    tcp_bind(server_ble1, IP_ADDR_ANY, TCP_PORT_BLE1);

    /* 进入监听状态 */
    server_ble1 = tcp_listen(server_ble1);

    /* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
    tcp_accept(server_ble1, tcpecho_accept_ble1); // 侦听到连接后，回调用户编写的tcpecho_accept

    /* 创建一个TCP控制块  */
    server_ble2 = tcp_new();

    /* 绑定TCP控制块 */
    tcp_bind(server_ble2, IP_ADDR_ANY, TCP_PORT_BLE2);

    /* 进入监听状态 */
    server_ble2 = tcp_listen(server_ble2);

    /* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
    tcp_accept(server_ble2, tcpecho_accept_ble2); // 侦听到连接后，回调用户编写的tcpecho_accept
}

void user_send_data_hart1(uint8_t *data, uint16_t len)
{
    if (tcp_echo_flags_hart1 == 1)
    {
        tcp_write(server_pcb_hart1, data, len, 1);
    }
}
void user_send_data_hart2(uint8_t *data, uint16_t len)
{
    if (tcp_echo_flags_hart2 == 1)
    {
        tcp_write(server_pcb_hart2, data, len, 1);
    }
}

void user_send_data_ble1(uint8_t *data, uint16_t len)
{
    if (tcp_echo_flags_ble1 == 1)
    {
        tcp_write(server_pcb_ble1, data, len, 1);
    }
}
void user_send_data_ble2(uint8_t *data, uint16_t len)
{
    if (tcp_echo_flags_ble2 == 1)
    {
        tcp_write(server_pcb_ble2, data, len, 1);
    }
}