/*
 * task-1-29994705.c
 * 
 * FIT2100 Assignment 2 for S2/2020
 * 
 * Alexander Occhipinti
 * Student ID: 29994705
 * Created: 14 Oct 2020 
 * Modified: 19 Oct 2020 
 * 
 * This is the source file for Task 1 of Assignment 2.
 * This program simulates a FCFS (first-come-first-serve) scheduler with at most 10 simulated processes.
 * These processes are read from file, simulated, then results are exported to "process-data.txt".
 * These results include wait time, turnaround time and whether the deadline was met for each process.
 * The purpose of this is to compare various scheduling algorithms.
 *  
*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include "task-1-29994705.h"

// NOTE: the structs provided in the assignment document are in the header file

/*
 * Compares two pcb_t structs to determine the order between the two in a FCFS system.
 *  This function is designed to interface with C's qsort function.
 * 
 * Args:
 *  pcb_a: any given process' PCB as a pcb_t
 *  pcb_b: any given process' PCB as a pcb_t
 * 
 * Returns (int):
 *  -1 if pcb_a comes before b
 *  0 if both equal
 *  1 if pcb_a comes after b
 * 
*/
int fcfs_compare(const void *pcb_a, const void *pcb_b) {
    pcb_t *pcb_x = (pcb_t *) pcb_a;
    pcb_t *pcb_y = (pcb_t *) pcb_b;
    return pcb_x->entryTime - pcb_y->entryTime;
}

/*
 * Reads and interprets a file containing process PCBs to simulate in the given format:
 *  [Process Name] [Arrival Time] [Service Time] [Deadline]
 *  separated by spaces.
 * Writes these PCBs to a given array via a pointer to be simulated later.
 * 
 * Args:
 *  file_path: the path to the input file
 *  pcb_array: an array to write PCBs into
 *  array_size: the size of the given PCB array
 * 
 * Returns (int):
 *  The number of PCBs actually read from the file. (May be less than the maximum array size)
 * 
*/
int pcbs_from_file(char* file_path, pcb_t *pcb_array, int array_size) {
    FILE *fp;
    fp = fopen(file_path, "r");
    int i;

    /* Read PCBs in from file until array is full or the file ends */
    for (i = 0; i<array_size && !feof(fp); i++){
        pcb_t process;
        fscanf(fp, "%s %d %d %d", process.process_name, &process.entryTime, &process.serviceTime, &process.deadline);
        /* Initialise values in the struct */
        process.state = UNENTERED;
        process.remainingTime = process.serviceTime;
        pcb_array[i] = process;
    }
    fclose(fp);
    return i;
}

/* 
 * Calculates and exports results to the default file path after a simulation, provided a list of PCBs.
 *  Writes to a file information in the following format:
 *  [Process Name] [Wait Time] [Turnaround Time] [Deadline Met]
 *  separated by spaces.
 * 
 * Args:
 *  pcb_array: an array of process PCBs after a simulation (i.e. experimental data filled into each struct)
 *  num_pcbs: the number of PCBs in the array provided
 * 
 * Returns void
 * 
*/
void export_results(pcb_t *pcb_array, int num_pcbs) {
    FILE *fp;
    fp = fopen(RESULT_FILE_PATH, "w");
    for (int i = 0; i < num_pcbs; i++) {
        int wait_time, turnaround_time, met_deadline;
        wait_time = pcb_array[i].timeStarted - pcb_array[i].entryTime;
        turnaround_time = pcb_array[i].timeFinished - pcb_array[i].entryTime;
        met_deadline = turnaround_time <= pcb_array[i].deadline;
        fprintf(fp, "%s %d %d %d\n", pcb_array[i].process_name, wait_time, turnaround_time, met_deadline);
    }
    fclose(fp);
}

/*
 * Scan through an array of PCBs and given a time, sets those that are due to enter the system to READY.
 *  Intended to simulate processes in the system being started while the scheduler is running.
 * 
 * Args:
 *  pcb_array: an array of PCBs (pcb_t) to search through
 *  num_pcbs: the number of PCBs in the array provided
 *  time: the current unit of time that the scheduler is up to.
*/
int scan_ready_procs(pcb_t *pcb_array, int num_pcbs, int time){
    int total_ready = 0;
    for (int i = 0; i < num_pcbs; i++) {
        if (pcb_array[i].entryTime <= time && pcb_array[i].state == UNENTERED) {
            pcb_array[i].state = READY;
            total_ready++;
            printf("Time %d: Process %s entered the system.\n", time, pcb_array[i].process_name);
        }
    }
    return total_ready;
}


/*
 * The function that runs the main FCFS scheduling simulation loop, provided an array of process PCBs to simulate.
 *  Each loop represents a single unit of time, where processes may either be become ready, start running or finish.
 *  For each unit of time, the following happens (in order):
 *   Each process is checked to see if it is ready (i.e. simulating the user or system starting a new process)
 *   The current running process is checked to see if it has finished executing
 *   The next process in the array (determined by FCFS) is checked to see if it is able to be run (i.e. no other process running)
 *   The scheduler sleeps for a short amount of time (one second by default) and the simulated time is incremeneted by one unit
 *  The simulation terminates once every process has been completed, then the results are exported. 
 * 
 * Args:
 *  pcb_array: An array of process PCB structs to run the simulation on
 *  num_pcbs: the number of PCBs in the provided array
 * 
 * Returns void
*/
void perform_fcfs_scheduling(pcb_t *pcb_array, int num_pcbs) {

    qsort(pcb_array, num_pcbs, sizeof(pcb_t), fcfs_compare); // Sort the PCB array in the order determined by the FCFS algorithm (via comparison function)
    int time = 0;
    int procs_done = 0;
    pcb_t *next_process;
    while (procs_done < num_pcbs) { // Loop until all processes are finished

        next_process = &pcb_array[procs_done]; // Set the next_process pointer to the process to be worked on

        /* Go through each PCB and mark the ones that are ready as ready */
        scan_ready_procs(pcb_array, num_pcbs, time); // Scan and mark processes that are now ready as 'READY'

        /* Checks if the current process has completed, sets its status to EXIT if so */
        if (next_process->state == RUNNING) {
            if (--next_process->remainingTime == 0) { // Is there no remaining time left?
                next_process->state = EXIT;
                next_process->timeFinished = time;
                printf("Time %d: Process %s has finished executing.\n", time, next_process->process_name);
                next_process = &pcb_array[++procs_done]; // Change the current process to the next process along
            }
        }

        /* Checks if the current process ready for execution and sets its status to RUNNING */
        if (next_process->state == READY) {
            next_process->state = RUNNING;
            next_process->timeStarted = time;
            printf("Time %d: Process %s is now running.\n", time, next_process->process_name);
        }

        // Sleep and continue to the next unit of time
        sleep(WAIT_PER_CYCLE);
        time++;
    }

    export_results(pcb_array, num_pcbs);
}


/*
 * The Main function, called when the program is started
 * Reads PCBs from file, simulates the scheduler on them, then exports the results.
 * 
 * Interprets the following program arguments:
 *  0 args: runs with the DEFAULT_INPUT_PATH as the input file
 *  1 arg: (a path to a text file): exports the results to the given path 
*/
int main(int argc, char *argv[]) {
    char in_path[MAX_PATH_SIZE] = DEFAULT_INPUT_PATH; // Initialise the PCB input file path to the default one
    if (argc > 1) strncpy(in_path, argv[1], MAX_PATH_SIZE); // Set the input path to the first argument if it was provided

    pcb_t pcb_array[MAX_NUM_PROCS]; // Init the array that will hold the PCBs
    int num_pcbs = pcbs_from_file(in_path, pcb_array, MAX_NUM_PROCS); // Read the PCBs from the provided file path, into the PCB array
    perform_fcfs_scheduling(pcb_array, num_pcbs); // Run the simulation on the read-in PCB array
    return 0;
}