//#include <QCoreApplication>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <chrono>

#include <fstream>
#include <iostream>
#include <vector>

#include <ff_api.h>

#define MAX_BUFFER_SIZE 1024
#define MAX_EVENTS 512

/* kq */
static int kq;
static int sockfd;
static int sockBroad;

/* kevent set */
static struct kevent kevSet;
/* events */
static struct kevent events[MAX_EVENTS];

static socklen_t client_len;
static char buffer[MAX_BUFFER_SIZE];
static struct sockaddr_in server_addr, client_addr;
static long pack_index=0;
static int sendTime=0;
int loop(void *arg)
{
    /* Wait for events to happen */
    int nevents = ff_kevent(kq, nullptr, 0, events, MAX_EVENTS, nullptr);
    int i;

    if (nevents < 0) {
        printf("ff_kevent failed:%d, %s\n", errno,
                        strerror(errno));
        return -1;
    }

    for (i = 0; i < nevents; ++i) {
        struct kevent event = events[i];
        int clientfd = (int)event.ident;

        /* Handle disconnect */
        if (event.flags & EV_EOF) {
            /* Simply close socket */
            ff_close(clientfd);
        } else if (event.filter == EVFILT_READ) {
            socklen_t client_len;
            char buffer[MAX_BUFFER_SIZE];
            // 接收来自客户端的数据
            client_len = sizeof(client_addr);
            ssize_t recv_len = ff_recvfrom(sockfd, buffer, sizeof (buffer), 0, (struct linux_sockaddr *)&client_addr, &client_len);
            if (recv_len < 0) {
                perror("Failed to receive data");
                exit(EXIT_FAILURE);
            }

            // 打印接收到的数据
            pack_index++;
            printf("Received data from %s:%d -- %ld \n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port), pack_index);
            //printf("Data: %s\n", buffer);

            // 回复客户端
            //memset(&client_addr, 0, sizeof(client_addr));
            //client_addr.sin_family = AF_INET;
            //client_addr.sin_port = htons(56050);
            //client_addr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
            //client_addr.sin_addr.s_addr = inet_addr("192.168.1.255");


            unsigned char imgbuffer[1024];
            pack_index=0;

            // 获取开始时间
            std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
            int iCycTime;
            if(sendTime == 0)
            {
                sendTime = 1;
                iCycTime = 10;
            }
            else {
                iCycTime = 100000;
            }
            while (pack_index<iCycTime) {
                pack_index++;

                FILE *file = fopen("/home/uos/Pictures/Wallpapers/abc-123.jpg", "rb");
                while (!feof(file)) {
                  size_t len = fread(imgbuffer, 1, 1024, file);
                  if (len == 0)
                  {
                      printf("编码数据读取结束.");
                      break;
                  }

                  ssize_t send_len = ff_sendto(sockfd, imgbuffer, len, 0, (struct linux_sockaddr *)&client_addr, client_len);
                  //printf("read len:%d  --  send len:%d\n", len, send_len);
                }
                fclose(file);
            }
            // 获取结束时间
            std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();

            // 计算并打印耗费的时间
            printf("send 4096Byte * 1000000times, spend %ds:%dms:%dµs\n",
                   std::chrono::duration_cast<std::chrono::seconds>(end - begin).count(),
                   std::chrono::duration_cast<std::chrono::milliseconds>(end - begin).count(),
                   std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count());

	    /*
            ssize_t send_len = ff_sendto(sockfd, buffer, recv_len, 0, (struct linux_sockaddr *)&client_addr, client_len);
            if (send_len < 0) {
                perror("Failed to send data");
                exit(EXIT_FAILURE);
            }
	    */
        } else {
            printf("unknown event: %8.8X\n", event.flags);
        }
    }

    return 0;
}

int main(int argc, char *argv[])
{
    printf("pre init...\n");
    ff_init(argc, argv);
    printf("init success\n");

    kq = ff_kqueue();
    if (kq < 0) {
        printf("ff_kqueue failed, errno:%d, %s\n", errno, strerror(errno));
        exit(1);
    }

    // 创建F-Stack套接字
    sockfd = ff_socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0) {
        perror("Failed to create socket");
        exit(EXIT_FAILURE);
    }

    sockBroad = ff_socket(AF_INET, SOCK_DGRAM,0);
    if(sockBroad < 0) {
	perror("Failed to create socket Broad");
    }
    const int opt = 1;
    int nb = 0;
    nb = ff_setsockopt(sockBroad, SOL_SOCKET, SO_BROADCAST, (char *)&opt, sizeof(opt));
    if(nb == -1)
    {
	perror("set socket error");
    }

    /* Set non blocking */
    int on = 1;
    ff_ioctl(sockfd, FIONBIO, &on);
    //ff_ioctl(sockBroad, FIONBIO, &on);

    // 设置服务器地址和端口
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(1234);
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);

    // 绑定套接字到服务器地址和端口
    if (ff_bind(sockfd, (struct linux_sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        perror("Failed to bind socket");
        exit(EXIT_FAILURE);
    }
    printf("UDP server listening on port 1234...\n");

    EV_SET(&kevSet, sockfd, EVFILT_READ, EV_ADD, 0, MAX_EVENTS, nullptr);
    /* Update kqueue */
    ff_kevent(kq, &kevSet, 1, nullptr, 0, nullptr);

    // 关闭套接字
    ff_run(loop, nullptr);
    return 0;
}