#include <marsio.h>
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <pthread.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>

static char appsym[64] = "mrtest-fb";
static char dev_src_symbol[64] = "meth1";
static char dev_dst_symbol[64] = "meth0";
static char str_target_ipaddr[64] = "192.168.100.50";

uint64_t cpu_mask = 0xff;
unsigned int nr_thread;

struct mr_instance * mr_instance = NULL;
struct mr_vdev * dev_src_handler = NULL;
struct mr_vdev * dev_dst_handler = NULL;
struct mr_sendpath * to_dev_dst_sendpath = NULL;

#define BURST_MAX       64
unsigned int nr_burst = 32;

void * feedback_loop(void * arg)
{
    uintptr_t sid = (uintptr_t)arg;
    marsio_buff_t * rx_buff[BURST_MAX];
    marsio_buff_t * feedback_buffs[BURST_MAX];
    unsigned int ret = 0;

    marsio_thread_init(mr_instance);

    for (;;)
    {
        ret = marsio_recv_burst(dev_src_handler, sid, rx_buff, nr_burst);

        int alloc_ret = marsio_buff_malloc_device(dev_dst_handler, feedback_buffs, 32, 0, sid);
        if (alloc_ret < 0)
        {
            printf("Alloc marsio buffer failed. ");
            marsio_buff_free(mr_instance, rx_buff, ret, 0, 0);
            continue;
        }
    }

    return (void *)NULL;
}

int help()
{
    return 0;
}

int main(int argc, char * argv[])
{
    int opt = 0;
    while ((opt = getopt(argc, argv, "s:d:a:c:b:t:h?")) != -1)
    {
        char * endptr = NULL;
        switch (opt)
        {
        case '?':
        case 'h':
        {
            help();
            break;
        }
        case 's':
        {
            snprintf(dev_src_symbol, sizeof(dev_src_symbol), "%s", optarg);
            break;
        }
        case 'd':
        {
            snprintf(dev_dst_symbol, sizeof(dev_dst_symbol), "%s", optarg);
            break;
        }
        case 't':
        {
            snprintf(str_target_ipaddr, sizeof(str_target_ipaddr), "%s", optarg);
            break;
        }
        case 'a':
        {
            snprintf(appsym, sizeof(appsym), "%s", optarg);
            break;
        }
        case 'c':
        {
            cpu_mask = strtoull(optarg, &endptr, 0);
            if (cpu_mask == 0 && endptr == optarg) help();
            break;
        }
        case 'b':
        {
            nr_burst = strtoull(optarg, &endptr, 0);
            if (nr_burst == 0 && endptr == optarg) help();
            break;
        }

        default:
            help();
            break;
        }
    }


    mr_instance = marsio_create();
    if (mr_instance == NULL)
    {
        fprintf(stderr, "Marsio instance create failed. ");
        abort();
    }

    struct in_addr target_ip_addr;
    inet_pton(AF_INET, str_target_ipaddr, &target_ip_addr);
    
    unsigned int opt_value = 1;
    marsio_option_set(mr_instance, MARSIO_OPT_EXIT_WHEN_ERR, &opt_value, sizeof(opt_value));
    marsio_option_set(mr_instance, MARSIO_OPT_THREAD_MASK, &cpu_mask, sizeof(cpu_mask));
    marsio_init(mr_instance, appsym);

    nr_thread = __builtin_popcountll(cpu_mask);
    dev_src_handler = marsio_open_device(mr_instance, dev_src_symbol, nr_thread, nr_thread);
    dev_dst_handler = marsio_open_device(mr_instance, dev_dst_symbol, nr_thread, nr_thread);
    to_dev_dst_sendpath = marsio_sendpath_create_by_droute(dev_dst_handler, target_ip_addr);
    
    fprintf(stdout, "Thread Count = %d\n", nr_thread);

    pthread_t __tmp_pid[nr_thread];
    for (int i = 0; i < nr_thread; i++)
    {
        pthread_create(&__tmp_pid[i], NULL, feedback_loop, (void *)(uintptr_t)i);
    }

    for (int i = 0; i < nr_thread; i++)
    {
        pthread_join(__tmp_pid[i], NULL);
    }

    marsio_destory(mr_instance);
    fprintf(stdout, "Feedback is terminated. ");
    return 0;
}