//=-------------------------------------------------------------------------=//
//  Main                                                                     //
//                                                                           //
//  Copyright © 2021 The Gem-graph Project                                   //
//                                                                           //
//  This file is part of gem-graph.                                          //
//                                                                           //
//  This program is free software: you can redistribute it and/or modify     //
//  it under the terms of the GNU Affero General Public License as           //
//  published by the Free Software Foundation, either version 3 of the       //
//  License, or (at your option) any later version.                          //
//                                                                           //
//  This program is distributed in the hope that it will be useful,          //
//  but WITHOUT ANY WARRANTY; without even the implied warranty of           //
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            //
//  GNU Affero General Public License for more details.                      //
//                                                                           //
//  You should have received a copy of the GNU Affero General Public License //
//  along with this program.  If not, see <https://www.gnu.org/licenses/>.   //
//=-------------------------------------------------------------------------=//

#include "../include/base.h"
#include "../include/server.h"
#include "../include/scheduler.h"


#define ARROW_NUMBER 150
#define MAX_CYCLES 40000
#define SPACE_SIZE 10000
#define MAX_THREAD 0

void SchedulerCrashTest(void)
{
    const int maxthread = 2000;

    SchedulerParams_t *parameters =
        (SchedulerParams_t*) calloc(1, sizeof(SchedulerParams_t));

    pthread_t **schedThread =
        (pthread_t**) malloc(sizeof(pthread_t*) * maxthread);

    for (int i=0; i < maxthread; i++) {
        schedThread[i] = SchedInit(parameters);
    }

    for (int i=0; i < maxthread; i++) {
        SchedWait(schedThread[i]);
        SchedDestroy(schedThread[i]);
    }

    free(parameters);
}

int main(int argc, char **argv)
{
    //
    // Creating parameters structure for the Scheduler
    //
    SchedulerParams_t *parameters =
        (SchedulerParams_t*) malloc(sizeof(SchedulerParams_t));

    parameters->globalPreemptionSpace =
        (BoolArray_t*) malloc(sizeof(BoolArray_t));
    parameters->globalPreemptionSpace->space =
        (bool*) malloc(sizeof(bool)*SPACE_SIZE);
    parameters->globalPreemptionSpace->size = SPACE_SIZE;

    parameters->globalDrawingSpace = (IntArray_t*) malloc(sizeof(IntArray_t));
    parameters->globalDrawingSpace->space =
        (int*) malloc(sizeof(int)*SPACE_SIZE);
    parameters->globalDrawingSpace->size = SPACE_SIZE;

    parameters->arrowList = (IntArray_t*) malloc(sizeof(IntArray_t));
    parameters->arrowList->space = (int*) malloc(sizeof(int)*ARROW_NUMBER);
    parameters->arrowList->size = ARROW_NUMBER;
    
    parameters->nmaxThread = MAX_THREAD;
    parameters->nmaxCycles = MAX_CYCLES;

    //
    // Creating the Scheduler thread
    //
    pthread_t *schedThread = SchedInit(parameters);

    SchedWait(schedThread);

    SchedDestroy(schedThread);

    free(parameters->globalDrawingSpace->space);
    free(parameters->globalDrawingSpace);

    free(parameters->globalPreemptionSpace->space);
    free(parameters->globalPreemptionSpace);

    free(parameters->arrowList->space);
    free(parameters->arrowList);

    free(parameters);

    SchedulerCrashTest();

    return 0;
}