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

// signal handling
#include <signal.h>
// context switch
#include <ucontext.h>
// timer
#include <sys/time.h>

#define UPPER_BOUND 500000000
#define QUANTUM_SEC 0
#define QUANTUM_MICRO_SEC 500000

// stores the context of the thread_function context
static ucontext_t thread_context;
// stores the context of the scheduler_function context
static ucontext_t scheduler_context;

int thread_finished;
int i;

// This function provides the signal handling.
// It saves the context of the thread_function and swaps to the scheduler_function context
static void signal_handler_function(int sig_nr, siginfo_t* info, void *context) {

    if (sig_nr == SIGPROF) {
        printf("\n[Signal Handler]\tSIGPROF was raised at %d...", i);
    } else {
        printf("\n[Signal Handler]\tA different signal was raised...");
        return;
    }

    // saves the thread context
    thread_context = *((ucontext_t*)context);

    // swaps back to scheduler context
    setcontext(&scheduler_context);
}

// This function simulates a thread function. It consists of two simple for-loops and prints, whether every loop finished successfully.
void thread_function(void) {
    printf("\n[Thread Function]\tFunction starts...");

    for (i = 0; i < UPPER_BOUND; ++i) {
        // do nothing but counting
    }

    if (i == UPPER_BOUND) {
        printf("\n[Thread Function]\t1st counting worked fine...");
    } else {
        printf("\n[Thread Function]\tError: 1st counting didn't finished (%d)...", i);
    }

    for (i = 0; i < UPPER_BOUND; ++i) {
        // do nothing but counting
    }

    if (i == UPPER_BOUND) {
        printf("\n[Thread Function]\t2nd counting worked fine...");
    } else {
        printf("\n[Thread Function]\tError: 2nd counting didn't finished (%d)...", i);
    }

    thread_finished = 1;

    printf("\n[Thread Function]\tFunction finishes...");
}

// The context will swap into this function after a signal was raised. The while-loop ends, when thread_finished == 1.
// thread_finished is set to 1 at the end of the thread_function.
void scheduler_function() {

    printf("\n[Scheduler Function]\tScheduler starts...");

    // thread_finished is a global variable, which is set to 1, if the thread function is finished
    while(thread_finished != 1) {
        swapcontext(&scheduler_context, &thread_context);
        printf("\n[Scheduler Function]\tSwap back is done...");
    }

    printf("\n[Scheduler Function]\tScheduler finishes...");
}

// main initializes all needed stuff (timer, signal handler) and starts the scheduler_function.
int main(int argc, char **argv) {
    printf("\n[Main Function]\t\tProgram starts...");
    thread_finished = 0;

    char thread_stack[65536];

    // initializing scheduler context
    if (getcontext(&scheduler_context) == 0) {
        printf("\n[Main Function]\t\tscheduler_context was initialized...");
    } else {
        printf("\n[Main Function]\t\tError while initializing scheduler_context...");
        return -1;
    }

    // initializing thread context
    if (getcontext(&thread_context) == 0) {
        thread_context.uc_stack.ss_sp = thread_stack;
        thread_context.uc_stack.ss_size = sizeof(thread_stack);
        thread_context.uc_link = &scheduler_context;
        printf("\n[Main Function]\t\tthread_context was initialized...");
    } else {
        printf("\n[Main Function]\t\tError while initializing thread_context...");
        return -1;
    }

    // initialize alternate stack for signal handling
    char * alternate_stack = (char*)malloc(65536);

    stack_t new_signal_stack;

    new_signal_stack.ss_sp = alternate_stack;
    new_signal_stack.ss_size = 65536;
    new_signal_stack.ss_flags = 0;

    sigaltstack(&new_signal_stack, NULL);

    // sets the signal handler for swapping to the scheduler context
    struct sigaction scheduling_interuption_handler;
    scheduling_interuption_handler.sa_sigaction = signal_handler_function;
    scheduling_interuption_handler.sa_flags = SA_RESTART | SA_SIGINFO | SA_ONSTACK;
    sigemptyset(&scheduling_interuption_handler.sa_mask);
    if (sigaction(SIGPROF, &scheduling_interuption_handler, NULL) == -1) {
        printf("\n[Main Function]\t\tAn error occurred while initializing the signal handler for swapping to the scheduler context...");
    }

    // sets the timer which sends SIGPROF periodically
    struct itimerval timeslice;
    timeslice.it_value.tv_sec = QUANTUM_SEC;
    timeslice.it_value.tv_usec = QUANTUM_MICRO_SEC;
    timeslice.it_interval = timeslice.it_value;

    if (setitimer(ITIMER_PROF, &timeslice, NULL) == 0) {
        printf("\n[Main Function]\t\tThe timer was initialized...");
    } else {
        printf("\n[Main Function]\t\tAn error occurred while executing setitimer...");
    }

    // sets the thread function
    makecontext(&thread_context, thread_function, 0);

    // this function handles the swapping part
    scheduler_function();

    printf("\n[Main Function]\t\tProgram finishes...");
}