#include "TcpTask.h"
#include "RTCTask.h"
#include "FatfsTask.h"

#include "BSPLwip.h"

#include "lwip/api.h"
#include "lwip/sys.h"
#include "lwip/netdb.h"
#include "lwip/sockets.h"
#include "lwip/inet.h"
#include "lwip/ip_addr.h"
#include "ucos_ii.h"

#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>

#define CLIENTPORT 4566
#define SERVERPORT 4567
#define IS_NETCONN 1

#if IS_NETCONN
void ClientTask(void *thread_param)
{
    struct netconn *conn;
    err_t err;
    ip_addr_t server_ip;
    const char *message = "I am client";

//	static NETWORK_IPADDR ServerIpAddr = {192, 168, 1, 112};
//    server_ip.addr = (((uint32_t)ServerIpAddr.Addr0) << 24) |
//                     (((uint32_t)ServerIpAddr.Addr1) << 16) |
//                     (((uint32_t)ServerIpAddr.Addr2) << 8) |
//                     ((uint32_t)ServerIpAddr.Addr3);

	IP4_ADDR(&server_ip, 192, 168, 1, 112);
	
    while (1) {
        // 创建一个新的 TCP 连接
        conn = netconn_new(NETCONN_TCP);
        while (conn == NULL) {
			conn = netconn_new(NETCONN_TCP);
            OSTimeDlyHMSM(0, 0, 1, 0); // 延迟 1 秒后重试
        }
		conn->recv_timeout = 200;

        // 连接到服务器
        err = netconn_connect(conn, &server_ip, CLIENTPORT);
        if (err != ERR_OK) {
            netconn_delete(conn);
            OSTimeDlyHMSM(0, 0, 1, 0); 
            continue;
        }

        // 每秒向服务器发送数据
        while (1) {
            err = netconn_write(conn, message, strlen(message), NETCONN_NOCOPY);
            if (err != ERR_OK) {
                break;
            }
            OSTimeDlyHMSM(0, 0, 1, 0); // 延迟 1 秒
        }

        netconn_close(conn); 
        netconn_delete(conn); 
    }
}

void ServerCallbackTask(void *thread_param)
{
    struct netconn *conn, *newconn;
    struct netbuf *buf;
    void *data;
    u16_t len;
    err_t err;
	char timeStr[12];

	// 创建
	conn = netconn_new(NETCONN_TCP);
	while (conn == NULL) {
		conn = netconn_new(NETCONN_TCP);
		OSTimeDlyHMSM(0, 0, 1, 0); // 延迟 1 秒后重试
	}

	// 绑定
    err = netconn_bind(conn, IP_ADDR_ANY, SERVERPORT);
    if (err != ERR_OK) {
        netconn_delete(conn);
        return;
    }

	// 监听
    err = netconn_listen(conn);
    if (err != ERR_OK) {
        netconn_delete(conn);
        return;
    }

	// 主循环
    while (1) {
        err = netconn_accept(conn, &newconn);
        if (err != ERR_OK) {
            continue;
        }

		// 接受和处理数据
        while ((err = netconn_recv(newconn, &buf)) == ERR_OK) {
            do {
                netbuf_data(buf, &data, &len);
				if (len == 7 && strncmp((char *)data, "GET RTC", 7) == 0)
				{
					sprintf(timeStr, "%02u:%02u:%02u", time.hour, time.minute, time.second);
					err = netconn_write(newconn, timeStr, strlen(timeStr), NETCONN_COPY);
				}
				else
				{
					err = netconn_write(newconn, data, len, NETCONN_COPY);
				}
				OSTimeDlyHMSM(0, 0, 1, 0); 
				if (err != ERR_OK) {
					break;
				}
            } while (netbuf_next(buf) >= 0);

            netbuf_delete(buf);
        }

        netconn_close(newconn);
        netconn_delete(newconn);
    }
}

#else

void ClientTask(void *thread_param)
{
    int sock;
    struct sockaddr_in server_addr;
    const char *message = "I am client";
    int err;

    // 设置服务器 IP 地址
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(CLIENTPORT);
    inet_aton("192.168.1.112", &server_addr.sin_addr);

    while (1) {
        // 创建一个新的 TCP 套接字
        sock = socket(AF_INET, SOCK_STREAM, 0);
        while (sock < 0) {
            sock = socket(AF_INET, SOCK_STREAM, 0);
            sys_msleep(1000); // 延迟 1 秒后重试
        }

        // 连接到服务器
        err = connect(sock, (struct sockaddr *)&server_addr, sizeof(server_addr));
        if (err < 0) {
            close(sock);
            sys_msleep(1000); // 延迟 1 秒后重试
            continue;
        }

        // 每秒向服务器发送数据
        while (1) {
            err = send(sock, message, strlen(message), 0);
            if (err < 0) {
                break;
            }
            sys_msleep(1000); // 延迟 1 秒
        }

        close(sock); // 关闭套接字
    }
}

void ServerCallbackTask(void *thread_param)
{
    int sock, new_sock;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_addr_len;
    char buffer[128];
    int len;
//    char timeStr[12];

    // 创建套接字
    sock = socket(AF_INET, SOCK_STREAM, 0);
    while (sock < 0) {
        sock = socket(AF_INET, SOCK_STREAM, 0);
        sys_msleep(1000); // 延迟 1 秒后重试
    }

    // 绑定套接字
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(SERVERPORT);

    if (bind(sock, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        close(sock);
        return;
    }

    // 监听连接
    if (listen(sock, 5) < 0) {
        close(sock);
        return;
    }

    // 主循环
    while (1) {
        client_addr_len = sizeof(client_addr);
        new_sock = accept(sock, (struct sockaddr *)&client_addr, &client_addr_len);
        if (new_sock < 0) {
            continue;
        }

        // 接受和处理数据
        while ((len = recv(new_sock, buffer, sizeof(buffer) - 1, 0)) > 0) {
            buffer[len] = '\0'; // 确保字符串以 null 结尾
            if (len == 7 && strncmp(buffer, "GET RTC", 7) == 0) {
//                sprintf(timeStr, "%02u:%02u:%02u", time.hour, time.minute, time.second);
                if (send(new_sock, timeStr, strlen(timeStr), 0) < 0) {
                    break;
                }
            } else {
                if (send(new_sock, buffer, len, 0) < 0) {
                    break;
                }
            }
        }

        close(new_sock); // 关闭客户端套接字
		close(sock); // 关闭服务器套接字
    }
}

#endif