#include <iostream>
#include <string>
#include <list>
#include <map>
#include <pthread.h>
#include <fstream>

#include <sstream> // for ostringstream

#define N_THREAD 7

using namespace std;

// Prototypes
int main();
int scheduler();
void register_exception_handler();
void *worker_thread(void *ptr);
void *worker_thread1(void *ptr);
string atomic_output(int my_int, int thread_id);

// Global variables
//pthread_t thread0, thread1, thread2, thread3, thread4, thread5, thread6, thread7;

pthread_t m_thread[N_THREAD];
int count = 1;
pthread_mutex_t count_mutex     = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t  condition_var   = PTHREAD_COND_INITIALIZER;


// Main
int main() {

    cout << "Launching main. \n";

    //Start to monitor for exceptions
    register_exception_handler();

    //Start scheduler
    scheduler();

    return 0;
}

// Scheduler
int scheduler() {
    // Starting scheduler log file
    ofstream scheduler_log;
    scheduler_log.open ("scheduler_log.txt");
    //scheduler_log << "[Scheduler] Starting." << endl;
    cout << "[Scheduler] Starting.  \n";

    // Scheduler::Main Section

    int thread_id[N_THREAD];

    for(int i=0;i<N_THREAD;i++) {
        thread_id[i] = i;
        pthread_create( &m_thread[i], NULL, worker_thread, (void *) &thread_id[i]);
    }

    for(int i=0;i<N_THREAD;i++)
        pthread_join(m_thread[i], NULL);


    cout << "[Scheduler] Ending. \n";
    // Closing scheduler log file
    scheduler_log.close();

    return 0;
}

string atomic_output(int my_int, int thread_id) {
    ostringstream stm;
    stm << "Thread ";
    stm << thread_id;
    stm << ": ";


    //count fn
    stm << my_int;
    stm << "\n";


    //stm << "Finished. \n";

    return stm.str();
}

void *worker_thread(void *ptr) {
    string line;
    //int boo = 0;

    int thread_id = *(int *) ptr;

    //if(thread_id == 0)
    //  pthread_mutex_lock( &count_mutex );

    for(int i=0;i<10;i++) {
        //boo++;

        if (thread_id == 1) {
            while(0) {
                pthread_mutex_lock(&count_mutex);
                if (count == 1)
                    pthread_cond_wait( &condition_var, &count_mutex );
                pthread_mutex_unlock(&count_mutex);
            }
        }

        if (thread_id == 3)
            while(0) {
                pthread_mutex_lock(&count_mutex);
                if (count == 1)
                    pthread_cond_wait( &condition_var, &count_mutex );
                pthread_mutex_unlock(&count_mutex);
            }

        if (i == 5) {
            if(thread_id == 0) {
                pthread_mutex_lock( &count_mutex );
                count = 0;
                pthread_mutex_unlock( &count_mutex );
                pthread_cond_broadcast(&condition_var);
            }
        }

        //count fn
        line = atomic_output(i, *(int *)ptr);
        cout << line;

    }

    //line = atomic_output(0, *(int *)ptr);
    //cout << line;
}


void *worker_thread1(void *ptr){
    for(int i=0;i<40;i++)
        cout << i << endl;
}

// Registers the first exception handler
// Protection against hack hijack
void register_exception_handler() {

    //
    // register_virtual_exception_handler()
}

/*
Launching main.
[Scheduler] Starting.
Thread 0: 0
Thread 1: 0 <--- Again, no respect for the condition, count = 1
Thread 3: 0
Thread 3: 1
Thread 3: 2
Thread 3: 3
Thread 3: 4
Thread 3: 5
Thread 3: 6
Thread 3: 7
Thread 3: 8
Thread 3: 9
Thread 0: 1
Thread 0: 2
Thread 0: 3
Thread 0: 4
Thread 2: 0
Thread 2: 1
Thread 2: 2
Thread 2: 3
Thread 2: 4
Thread 2: 5
Thread 2: 6
Thread 2: 7
Thread 2: 8
Thread 2: 9
Thread 0: 5
Thread 0: 6
Thread 0: 7
Thread 0: 8
Thread 0: 9
Thread 6: 0
Thread 1: 1
Thread 1: 2
Thread 1: 3
Thread 1: 4
Thread 1: 5
Thread 1: 6
Thread 1: 7
Thread 1: 8
Thread 1: 9
Thread 6: 1
Thread 6: 2
Thread 6: 3
Thread 6: 4
Thread 6: 5
Thread 6: 6
Thread 6: 7
Thread 6: 8
Thread 6: 9
Thread 5: 0
Thread 5: 1
Thread 5: 2
Thread 5: 3
Thread 5: 4
Thread 5: 5
Thread 4: 0
Thread 4: 1
Thread 4: 2
Thread 5: 6
Thread 5: 7
Thread 5: 8
Thread 5: 9
Thread 4: 3
Thread 4: 4
Thread 4: 5
Thread 4: 6
Thread 4: 7
Thread 4: 8
Thread 4: 9
[Scheduler] Ending.
*/