#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>

#include "../../context.h"

int cpu_num = 1;
int length = 102400;
int split = 8;
int* array_ptr;
int gpu_num = 0;
int CPU_ANY = -1;
int CPU_CUDA = -1;

void print_queue(struct Element* element) {
    while (element) {
        printf("%p\n", ((struct Task *)(element->data)));
        element = element->next;
    }
}

void print_tree(struct Node* node) {
    if (node != 0) {
        printf("%d\n", node->value->Array.index);
        print_tree(node->left);
        print_tree(node->right);
    }
}

void *start_taskManager(struct Context *context) {
    goto initDataGears(context, Gearef(context, LoopCounter), Gearef(context, TaskManager));
    return 0;
}

#ifdef USE_CUDAWorker
#ifdef USE_CUDA_MAIN_THREAD
extern volatile int cuda_initialized;
#endif
#endif

__code initDataGears(struct LoopCounter* loopCounter, struct TaskManager* taskManager) {
    // loopCounter->tree = createRedBlackTree(context);
    loopCounter->i = 0;
    taskManager->taskManager = (union Data*)createTaskManagerImpl(context, cpu_num, gpu_num, 0);
#ifdef USE_CUDAWorker
#ifdef USE_CUDA_MAIN_THREAD
    while(! cuda_initialized) {};
#endif
#endif
    goto meta(context, C_createTask1);
}

__code initDataGears_stub(struct Context* context) {
    struct TaskManager* taskManager =  Gearef(context, TaskManager);
    taskManager->taskManager = 0;
#if (! defined(USE_CUDAWorker) || ! defined(USE_CUDA_MAIN_THREAD))
    struct LoopCounter* loopCounter = Gearef(context, LoopCounter);
    goto initDataGears(context, loopCounter, taskManager);
#else
    cuda_initialized = 0;
    pthread_t thread;
    pthread_create(&thread, NULL, (void*)&start_taskManager, context);
    while (taskManager->taskManager == 0);
    TaskManager *t = (TaskManager*)taskManager->taskManager;
    TaskManagerImpl *im = (TaskManagerImpl*)t->taskManager;
    struct Queue *q = (Queue *)im->workers[0];
    createCUDAWorker(context,0,q, im);
    pthread_join(thread,0);
    exit(0);
#endif
}

__code code1(struct Time* time) {
    printf("cpus:\t\t%d\n", cpu_num);
    printf("gpus:\t\t%d\n", gpu_num);
    printf("length:\t\t%d\n", length);
    printf("length/task:\t%d\n", length/split);
    /* puts("queue"); */
    /* print_queue(context->data[ActiveQueue]->queue.first); */
    /* puts("tree"); */
    /* print_tree(context->data[Tree]->tree.root); */
    /* puts("result"); */

    time->next = C_code2;
    goto meta(context, C_code2);
    //goto meta(context, C_exit_code);
    //goto meta(context, C_start_time);
}

__code code1_stub(struct Context* context) {
    goto code1(context, Gearef(context, Time));
}

__code code2(struct LoopCounter* loopCounter) {
    int i = loopCounter->i;

    if (i < length) {
        //printf("%d\n", array_ptr[i]);
        if (array_ptr[i] == (i*2)) {
            loopCounter->i++;
            goto meta(context, C_code2);
        } else
            puts("wrong result");

    }

    goto meta(context, C_exit_code);
}

__code createTask1(struct LoopCounter* loopCounter, struct TaskManager* taskManager) {
    int i = loopCounter->i;

    if (i < 1) {
        loopCounter->i++;
        taskManager->next = C_createTask2;
        goto meta(context, taskManager->taskManager->TaskManager.createTask);
    }

    loopCounter->i = 0;
    taskManager->next = C_code1;
    sleep(3);
    goto meta(context, taskManager->taskManager->TaskManager.shutdown);
}

__code createTask2(LoopCounter* loopCounter, TaskManager* taskManager, struct Context *task, Integer *integer1, Integer *integer2, Integer *integer3) {
    int i = loopCounter->i;
    task->idgCount = 1;
    task->next = C_mult;
    integer2->value = i+1;
    task->data[task->idg] = (union Data*)integer1;
    task->data[task->idg+1] = (union Data*)integer2;
    task->maxIdg = task->idg + 2;
    task->odg = task->maxIdg;
    task->data[task->odg] = (union Data*)integer3;
    task->maxOdg = task->odg + 1;
    taskManager->next = C_createTask3;
    taskManager->data = (union Data*)integer1;
    goto meta(context, taskManager->taskManager->TaskManager.setWaitTask);
}

__code createTask2_stub(struct Context* context) {
    Integer* integer1 = &ALLOCATE_DATA_GEAR(context, Integer)->Integer;
    Integer* integer2 = &ALLOCATE_DATA_GEAR(context, Integer)->Integer;
    Integer* integer3 = &ALLOCATE_DATA_GEAR(context, Integer)->Integer;
    goto createTask2(context,
            Gearef(context, LoopCounter),
            Gearef(context, TaskManager),
            Gearef(context, TaskManager)->context,
            integer1,
            integer2,
            integer3);
}

__code createTask3(struct TaskManager* taskManager) {
    taskManager->next = C_createTask4;
    goto meta(context, taskManager->taskManager->TaskManager.spawn);
}

__code createTask4(struct TaskManager* taskManager) {
    taskManager->next = C_createTask5;
    goto meta(context, taskManager->taskManager->TaskManager.createTask);
}

__code createTask5(LoopCounter* loopCounter, TaskManager* taskManager, struct Context* task, Integer *integer1, Integer *integer2, Integer *integer3) {
    int i = loopCounter->i;
    task->next = C_add;
    task->idgCount = 0;
    integer1->value = i;
    integer2->value = i+1;
    task->data[task->idg] = (union Data*)integer1;
    task->data[task->idg+1] = (union Data*)integer2;
    task->maxIdg = task->idg + 2;
    task->odg = task->maxIdg;
    task->data[task->odg] = (union Data*)integer3;
    task->maxOdg = task->odg + 1;
    taskManager->next = C_createTask1;
    goto meta(context, taskManager->taskManager->TaskManager.spawn);
}

__code createTask5_stub(struct Context* context) {
    Integer* integer1 = &ALLOCATE_DATA_GEAR(context, Integer)->Integer;
    Integer* integer2 = &ALLOCATE_DATA_GEAR(context, Integer)->Integer;
    goto createTask5(context,
            Gearef(context, LoopCounter),
            Gearef(context, TaskManager),
            Gearef(context, TaskManager)->context,
            integer1,
            integer2,
            &Gearef(context, TaskManager)->data->Integer);
}


void init(int argc, char** argv) {
    for (int i = 1; argv[i]; ++i) {
        if (strcmp(argv[i], "-cpu") == 0)
            cpu_num = (int)atoi(argv[i+1]);
        else if (strcmp(argv[i], "-l") == 0)
            length = (int)atoi(argv[i+1]);
        else if (strcmp(argv[i], "-s") == 0)
            split = (int)atoi(argv[i+1]);
        else if (strcmp(argv[i], "-cuda") == 0) {
            gpu_num = 1;
            CPU_CUDA = 0;
        }
    }
}


int main(int argc, char** argv) {
    init(argc, argv);

    array_ptr = NEWN(length, int);

    for(int i=0; i<length; i++)
        array_ptr[i]=i;

    struct Context* main_context = NEW(struct Context);
    initContext(main_context);
    main_context->next = C_initDataGears;

    goto start_code(main_context);
}

__code add(struct Integer* input1, struct Integer* input2, struct Integer* output) { 
    output->value = input1->value + input2->value; 
    printf("%d + %d = %d\n", input1->value, input2->value, output->value); 
    goto meta(context, context->next); 
}

__code add_stub(struct Context* context) { 
    goto add(context, 
            &context->data[context->idg]->Integer,
            &context->data[context->idg + 1]->Integer,
            &context->data[context->odg]->Integer);

}

__code mult(struct Integer* input1, struct Integer* input2, struct Integer* output) { 
    output->value = input1->value * input2->value; 
    printf("%d * %d = %d\n", input1->value, input2->value, output->value); 
    goto meta(context, context->next);
}

__code mult_stub(struct Context* context) { 
    goto mult(context, 
            &context->data[context->idg]->Integer,
            &context->data[context->idg + 1]->Integer,
            &context->data[context->odg]->Integer);

}