//#define _GNU_SOURCE
#include <ctime>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

#include <iostream>
#include <string>
#include <mutex>
#include <boost/asio.hpp>
#include <boost/thread.hpp>


#include "cpuUsage.h"
#include "ini.h"
#include "minIni.h"

#ifdef __cplusplus
extern "C" {
#endif

#include "test.h"
#include "zsvar_type.h"
#include "user_variables.h"

#ifdef __cplusplus
}
#endif   // extern "C"



#ifdef WIN32
#define strdup(s) _strdup(s)
#endif

using boost::asio::ip::udp;

// extern ExtY_test_T test_Y;
// extern ExtU_test_T test_U;

#define MATCH(s, n) (strcmp(section, s) == 0 && strcmp(name, n) == 0)
#define sizearray(a)  (sizeof(a) / sizeof((a)[0]))
#define DEST_ADDR "127.0.0.1"
#define UDP_PORT 6000

#define USER_PROGRAME_EXIT_CHK          if(UserProgrameControl.value ==  Stop) break
#define IF_USER_PROGRAME_HALT          (UserProgrameControl.value ==  Halt)

enum UserProgramControl{
    Ready=0,
    Run,
    Halt,
    Continue,
    Stop,
};


ZsVar_t UserProgrameControl;

long usTicks;

#define INCREASE_USTICK         usTicks++ //ʵ��us����

boost::thread udp_receiver_thread;
boost::thread manager_thread;
boost::thread var_fbk_thread;

boost::mutex mtx;
udp::endpoint senderEndpoint;   
bool src_ip_got = false;
float cpu_occupation = 0.0;

#define STR_EQL(str1, str2, n)	(strncmp(str1, str2, sizeof(str1)) == 0)

#define ZSDELAY(_US)        boost::this_thread::sleep(boost::posix_time::microseconds(_US))//sleep(_US)
//boost::this_thread::sleep(boost::posix_time::microseconds(calload))
// std::this_thread::sleep_until(std::chrono::steady_clock::now() + std::chrono::microseconds(1000000));
// std::this_thread::sleep_until(std::chrono::high_resolution_clock::now() + std::chrono::microseconds(1000000));
void handlerForThread(const char* str)
{
   
    if(Zsvar_CjsonDeserialize(str,&UserProgrameControl)){
        std::cout << "Errformate: " << std::string(str) << std::endl;
    }else{
        
    }
    
    
}



void UDPReceiver(boost::asio::io_context& io_context)
{
    udp::socket socket(io_context, udp::endpoint(udp::v4(), UDP_PORT));

    char recvBuffer[1024];
    memset(recvBuffer,0,sizeof(recvBuffer));
    while (1)
    {
        
        //senderEndpoint用于保存提取到的对端UDP地址和端口信�?
        size_t read_len = socket.receive_from(boost::asio::buffer(recvBuffer), senderEndpoint);

        if (read_len > 0)
        {
            src_ip_got = true;
        }


        std::cout << "From address: " << senderEndpoint.address().to_string() << std::endl;
        // std::cout << "Received message: " << std::string(recvBuffer) << std::endl;

        handlerForThread(recvBuffer);        

        USER_PROGRAME_EXIT_CHK;


    }
}

clock_t simStartTick;
clock_t start, end;

void DoSomething(void)
{
    // boost::mutex::scoped_lock lock(mtx);

#ifndef WIN32
    

    start = clock();
#endif
    test_step();

#ifndef WIN32
    // end = clock();

    // cpu_occupation = ((float)(end - start) / CLOCKS_PER_SEC) * 10000.0;
    // std::this_thread::sleep_until(std::chrono::steady_clock::now() + std::chrono::microseconds(UserProgrameControl.sampleUs));

    end = clock();
    // UserProgrameControl.timestampUs = end - start;
    // printf("CPU Clock : %d\n", UserProgrameControl.timestampUs);
#endif
    // printf("CPU Clock : %d\n", end);
}

void OperatorThread(boost::asio::io_context& io_context)
{
	while (1)
	{
        if (IF_USER_PROGRAME_HALT)
        {
            boost::this_thread::sleep(boost::posix_time::microseconds(1));
            continue;
        }

        mtx.lock();

        DoSomething();

        mtx.unlock();
        USER_PROGRAME_EXIT_CHK;
        

        int caclTicks = UserProgrameControl.sampleUs-end +start;
        if(caclTicks>0) ZSDELAY(caclTicks);
        else  printf("Calculation overflow.: %d\n", caclTicks);

        // std::this_thread::sleep_until(std::chrono::high_resolution_clock::now() + std::chrono::microseconds(UserProgrameControl.sampleUs));
        
	}
}


void ZsVarFbk(boost::asio::io_context& io_context)
{
    //默认发往127.0.0.1:6001
    std::string receiverIP = "127.0.0.1";
    unsigned short receiverPort = 6001;

    udp::socket socket(io_context);

    try {
        socket.open(udp::v4());

        udp::resolver resolver(io_context);
        
        while (1)
        {
            if (IF_USER_PROGRAME_HALT)
            {
                ZSDELAY(1000);
                continue;
            }

            mtx.lock();
            std::string message = "test_Y.Out1 is " + std::to_string(1) + "\n";//test_Y.Out1
            mtx.unlock();

// #ifndef WIN32
//             //Linux下才增加系统tick信息
//             message.append("CPU occupation: " + std::to_string(cpu_occupation) + "%\n");
// #endif
            //如果收到UDP数据，那么使用收到的UDP数据的ip和端口进行回传数�?
            if (src_ip_got)
            {
                src_ip_got = false;
                receiverIP = senderEndpoint.address().to_string();
                receiverPort = senderEndpoint.port();
            }

            udp::endpoint receiver_endpoint = *resolver.resolve(udp::v4(), receiverIP, std::to_string(receiverPort)).begin();

            socket.send_to(boost::asio::buffer(message), receiver_endpoint);

            // std::cout << "Sent: " << message << std::endl;

            USER_PROGRAME_EXIT_CHK;
            ZSDELAY(100000);
        }

        socket.close();
    } catch (std::exception& e) {
        std::cerr << "Sending error: " << e.what() << std::endl;
    }

}


int main(int argc, char* argv[])
{
	boost::asio::io_context io_context;

    UserProgrameControl.sampleUs = 1000;//
    UserProgrameControl.path = "Programe Controller";
    UserProgrameControl.id = 123;//(int)(&UserProgrameControl);
    UserProgrameControl.value = Halt;//��ͣ

    udp_receiver_thread = boost::thread([&io_context]() { UDPReceiver(io_context); });
    manager_thread = boost::thread([&io_context]() { OperatorThread(io_context); });
    var_fbk_thread = boost::thread([&io_context]() { ZsVarFbk(io_context); });

    printUserVariable();
    setUserVariable(200);
    printUserVariable();


#if 0
    
#endif

    simStartTick = clock();
    
    Zsvar_CjsonPrintf(&UserProgrameControl,1);

    printf("CLOCKS_PER_SEC=%d\n",CLOCKS_PER_SEC);
    printf("-------System ready. %d--------\n",simStartTick);
	
    while (1)
    {
        
        // UserProgrameControl.timestampUs =((float) UserProgrameControl.timestampUs/CLOCKS_PER_SEC)*1000000;//convert to us

        UserProgrameControl.timestampUs = clock()-simStartTick;
        Zsvar_CjsonPrintf(&UserProgrameControl,0);

        USER_PROGRAME_EXIT_CHK;
        ZSDELAY(1000000);


    }

	

    if (udp_receiver_thread.joinable()) {
       udp_receiver_thread.join();
    }

    if (manager_thread.joinable()) {
       manager_thread.join();
    }
    
    if (var_fbk_thread.joinable()) {
       var_fbk_thread.join();
    }

    printf("System exit.\n");
    
    return 0;
}