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

#define RR_QUANTUM 2
#define CNTXT_SWITCH 1
int MAX_PROCESSES = 0;

enum pstate {
    WAITING,
    READY,
    RUNNING,
    FINISHED
};

struct pinfo {
    int id;
    int arrival_time;
    int execution_time;
    int priority;
    
    int wait_time;
    int turnaround_time;
    int remaining_time;
    int nb_time_pre_empted;  // Ajouté pour compter les préemptions
    enum pstate state;

    struct pinfo * next_pinfo;
};

int n_processes(struct pinfo * head) {
    int n = 0;

    while (head != NULL) {
        n++;
        head = head->next_pinfo;
    }

    return n;
}

struct perf_info {
    int total_time;
    int total_nr_ctxt_switch;
    int total_time_ctxt_switch;
};

void print_perf(struct perf_info * perf) {
    printf("Total time: %d\n", perf->total_time);
    printf("Total number of context switches: %d\n", perf->total_nr_ctxt_switch);
    printf("Total time spent on context switching: %d\n", perf->total_time_ctxt_switch);
}

void print_pinfo(struct pinfo * info) {
    printf("<Process {\n");
    printf("  PID: %d\n", info->id);
    printf("  Arrival time: %d\n", info->arrival_time);
    printf("  Execution time: %d\n", info->execution_time);
    printf("  Priority: %d\n", info->priority);
    printf("  Wait time: %d\n", info->wait_time);
    printf("  Turnaround time: %d\n", info->turnaround_time);
    printf("  Remaining time: %d\n", info->remaining_time);
    printf("  NEXT -> %p\n", info->next_pinfo);
    printf("}>\n");
}

void print_processes(struct pinfo * processes) {
    while (processes != NULL) {
        print_pinfo(processes);
        processes = processes->next_pinfo;
    }
}

struct pinfo * create_process(int id, int arrival_time, int execution_time, int priority) {
    struct pinfo * info = malloc(sizeof(struct pinfo));
    info->id = id;
    info->arrival_time = arrival_time;
    info->execution_time = execution_time;
    info->priority = priority;
    info->wait_time = 0;
    info->turnaround_time = 0;
    info->remaining_time = execution_time;
    info->nb_time_pre_empted = 0; // Initialiser le nombre de préemptions
    info->state = WAITING;
    info->next_pinfo = NULL;
    return info;
}

// Méthode de planification FCFS
struct perf_info schedule_FCFS(struct pinfo * processes) {
    int current_time = 0;
    struct pinfo * process = processes;

    struct perf_info perf = {0, 0, 0};
    
    while (process != NULL) {
        int wait_time = current_time - process->arrival_time;
        if (wait_time < 0) {
            wait_time = 0;
        }
        process->wait_time = wait_time;
        process->turnaround_time = process->execution_time + process->wait_time;
        current_time = process->arrival_time + process->turnaround_time;

        process = process->next_pinfo;
    }
    perf.total_time = current_time;
    
    return perf;
}

struct prio_list {
    struct pinfo ** proc;
    int length;
};

/**
 * Pops and returns the last element (highest priority) of the given priority list
 * 
 * Returns NULL if the list is empty
 */
struct pinfo * prio_list_pop(struct prio_list * list) {
    if (list->length == 0) {
        return NULL;
    }

    list->length--;
    return *(list->proc + list->length);
}

/**
 * Adds the given process in the priority list at
 * the appropriate place (according to its priority)
 */
void prio_list_add(struct prio_list * list, struct pinfo * proc) {
    struct pinfo * proc2;
    int idx = 0;

    // Find first element (from the right) with lower priority
    for (int i=list->length-1; i>=0; i--) {
        proc2 = *(list->proc + i);
        if (proc2->priority > proc->priority) {
            idx = i+1;
            break;
        }
    }
    // Shift elements
    for (int j=list->length-1; j>=idx; j--) {
        *(list->proc + j + 1) = *(list->proc + j);
    }
    *(list->proc + idx) = proc;
    list->length++;
}

/**
 * Creates a new priority list
 */
struct prio_list * create_prio_list(int max_size) {
    struct pinfo ** processes = (struct pinfo **) malloc(sizeof(struct pinfo *) * max_size);
    struct prio_list * list = (struct prio_list *) malloc(sizeof(struct prio_list));
    list->length = 0;
    list->proc = processes;
    return list;
}

/**
 * Returns the last element (highest priority) of the given priority list
 */
struct pinfo * prio_list_last(struct prio_list * list) {
    return *(list->proc + list->length - 1);
}

/**
 * Prints the pids of the processes in the given priority list
 */
void prio_list_print(struct prio_list * list) {
    printf("queue: ");
    for (int i=0; i < list->length; i++) {
        if (i != 0) {
            printf(", ");
        }
        printf("%d", (*(list->proc + i))->id);
    }
    printf("\n");
}

struct remtime_list {
    struct pinfo ** proc;
    int length;
};

/**
 * Pops and returns the last element (shortest remaining time) of the given remtime list
 * 
 * Returns NULL if the list is empty
 */
struct pinfo * remtime_list_pop(struct remtime_list * list) {
    if (list->length == 0) {
        return NULL;
    }

    list->length--;
    return *(list->proc + list->length);
}

/**
 * Adds the given process in the remtime list at
 * the appropriate place (according to its remaining time)
 */
void remtime_list_add(struct remtime_list * list, struct pinfo * proc) {
    struct pinfo * proc2;
    int idx = 0;

    // Find first element (from the right) with longer remaining time
    for (int i=list->length-1; i>=0; i--) {
        proc2 = *(list->proc + i);
        if (proc2->remaining_time > proc->remaining_time) {
            idx = i+1;
            break;
        }
    }
    // Shift elements
    for (int j=list->length-1; j>=idx; j--) {
        *(list->proc + j + 1) = *(list->proc + j);
    }
    *(list->proc + idx) = proc;
    list->length++;
}

/**
 * Creates a new remtime list
 */
struct remtime_list * create_remtime_list(int max_size) {
    struct pinfo ** processes = (struct pinfo **) malloc(sizeof(struct pinfo *) * max_size);
    struct remtime_list * list = (struct remtime_list *) malloc(sizeof(struct remtime_list));
    list->length = 0;
    list->proc = processes;
    return list;
}

/**
 * Returns the last element (shortest remaining time) of the given remtime list
 */
struct pinfo * remtime_list_last(struct remtime_list * list) {
    return *(list->proc + list->length - 1);
}

/**
 * Prints the pids of the processes in the given remtime list
 */
void remtime_list_print(struct remtime_list * list) {
    printf("queue: ");
    for (int i=0; i < list->length; i++) {
        if (i != 0) {
            printf(", ");
        }
        printf("%d", (*(list->proc + i))->id);
    }
    printf("\n");
}

struct perf_info schedule_Pr(struct pinfo * processes) {
    struct perf_info perf = {0, 0, 0};

    int current_time = 0;
    struct pinfo * current = NULL;
    struct pinfo * next = processes;

    int N = n_processes(processes);
    printf("N = %d\n", N);

    struct prio_list * queue = create_prio_list(N);
    
    int finished = 0;

    while (finished != N) {
        printf("\nCurrent time: %d / ", current_time);
        if (current != NULL) {
            printf("Current: %d / ", current->id);
        } else {
            printf("Current: none / ");
        }
        if (next != NULL) {
            printf("Next: %d\n", next->id);
        } else {
            printf("Next: none\n");
        }

        if (current == NULL) {
            printf("No running process: running %d\n", next->id);
            current = next;
            current->state = RUNNING;
            next = next->next_pinfo;
        
        } else if (next != NULL) {
            next->state = READY;
            prio_list_print(queue);
            printf("Processing next process (%d)\n", next->id);

            // If current finished before next
            while (current != NULL && current_time + current->remaining_time <= next->arrival_time) {
                printf("  Process %d finished before next\n", current->id);
                current->state = FINISHED;
                current_time += current->remaining_time;
                current->turnaround_time = current_time - current->arrival_time;
                current->remaining_time = 0;
                finished++;
                current = prio_list_pop(queue);
            }

            if (current != NULL) {
                printf("Removing time from current process\n");
                current->remaining_time -= next->arrival_time - current_time;
                current->turnaround_time += next->arrival_time - current_time;
            }
            if (next->arrival_time > current_time) {
                current_time = next->arrival_time;
            }
            next->state = READY;

            // If no running process, immediately run next process
            if (current == NULL) {
                printf("Queue is empty, running next process %d\n", next->id);
                current = next;
                current->state = RUNNING;
                next = next->next_pinfo;

            } else if (next->priority < current->priority) {
                // Preempt current process
                printf("Next process (%d) has higher priority\n", next->id);
                if (current->state == RUNNING) {
                    printf("  Preempting current process (%d)\n", current->id);
                    current->nb_time_pre_empted++;
                    current_time += CNTXT_SWITCH;
                    perf.total_nr_ctxt_switch++;
                }
                current->state = READY;
                prio_list_add(queue, current);

                // Run process with higher priority
                current = next;
                current->state = RUNNING;
                next = next->next_pinfo;
            } else {
                printf("Adding next process (%d) to list\n", next->id);
                prio_list_add(queue, next);
                next = next->next_pinfo;
            }
            if (current != NULL) {
                current->state = RUNNING;
            }

            
        } else {
            printf("No new processes, emptying queue\n");
            while (current != NULL) {
                printf("Completing process %d\n", current->id);
                current->state = FINISHED;
                current_time += current->remaining_time;
                current->turnaround_time = current_time - current->arrival_time;
                current->remaining_time = 0;
                finished++;
                current = prio_list_pop(queue);
                if (current != NULL) {
                    current->state = RUNNING;
                }
            }
        }
    }
    perf.total_time = current_time;
    perf.total_time_ctxt_switch = perf.total_nr_ctxt_switch * CNTXT_SWITCH;

    return perf;
}

void compute_waiting_time(struct pinfo * processes) {
    while (processes != NULL) {
        processes->wait_time = processes->turnaround_time - processes->execution_time;
        processes = processes->next_pinfo;
    }
}

struct perf_info schedule_RR(struct pinfo *processes) {
    struct perf_info perf = {0, 0, 0}; // Initialisation de la structure de performance

    // Conversion de la liste chaînée en array
    int N = n_processes(processes);
    struct pinfo ** proc_list = (struct pinfo **) malloc(sizeof(struct pinfo *) * N);
    struct pinfo * p = processes;
    int i = 0;
    while (p != NULL) {
        proc_list[i] = p;
        p = p->next_pinfo;
        i++;
    }

    struct pinfo *current_process = processes;
    int current_time = 0; // Temps actuel
    int finished_processes = 0; // Compteur de processus terminés
    int running_processes = 0;
    struct pinfo * last_running = NULL;
    while (finished_processes < N) {
        printf("\n");
        for (int i = 0; i < N; i++) {
            p = proc_list[i];
            if (p->state == FINISHED) {
                continue;
            }
            printf("Current time: %d, pid: %d\n", current_time, p->id);
            
            if (p->state == WAITING) {
                if (p->arrival_time <= current_time) {
                    p->state = READY;
                    running_processes++;
                    if (last_running != NULL) {
                        printf("Preempting last running process (current time: %d, pid: %d)\n", current_time, last_running->id);
                        last_running->nb_time_pre_empted++;
                        perf.total_nr_ctxt_switch++;
                        current_time += CNTXT_SWITCH;
                    }
                    printf("Process %d is now ready\n", p->id);
                    printf("Running processes: %d\n", running_processes);
                }
            }

            if (p->state == READY) {
                last_running = p;
                p->remaining_time -= RR_QUANTUM;
                current_time += RR_QUANTUM;
                printf("Executing quantum for process %d, remaining_time %d\n", p->id, p->remaining_time);
                if (p->remaining_time <= 0) {
                    printf("  Process has finished\n");
                    p->remaining_time = 0;
                    p->turnaround_time = current_time - p->arrival_time;
                    p->state = FINISHED;
                    last_running = NULL;
                    finished_processes++;
                    running_processes--;
                } else if (running_processes > 1) {
                    printf("  Preempting process (current time: %d, pid: %d)\n", current_time, p->id);
                    last_running = NULL;
                    p->nb_time_pre_empted++;
                    perf.total_nr_ctxt_switch++;
                    current_time += CNTXT_SWITCH;
                }
            }
        }
        if (finished_processes < N && running_processes == 0) {
            current_time++;
        }
    }

    perf.total_time = current_time;
    perf.total_time_ctxt_switch = perf.total_nr_ctxt_switch * CNTXT_SWITCH;
    return perf;
}

struct perf_info schedule_SRTF(struct pinfo *processes) {
    struct perf_info perf = {0, 0, 0};

    int current_time = 0;
    struct pinfo * current = NULL;
    struct pinfo * next = processes;

    int N = n_processes(processes);
    printf("N = %d\n", N);

    struct remtime_list * queue = create_remtime_list(N);
    
    int finished = 0;

    while (finished != N) {
        printf("\nCurrent time: %d / ", current_time);
        if (current != NULL) {
            printf("Current: %d / ", current->id);
        } else {
            printf("Current: none / ");
        }
        if (next != NULL) {
            printf("Next: %d\n", next->id);
        } else {
            printf("Next: none\n");
        }

        if (current == NULL) {
            printf("No running process: running %d\n", next->id);
            current = next;
            current->state = RUNNING;
            next = next->next_pinfo;
        
        } else if (next != NULL) {
            next->state = READY;
            remtime_list_print(queue);
            printf("Processing next process (%d)\n", next->id);
            int delta = next->arrival_time - current_time;

            // If current finished before next
            while (current != NULL && current->remaining_time <= delta) {
                printf("  (%d) Process %d finished before next\n", current_time, current->id);
                current->state = FINISHED;
                current_time += current->remaining_time;
                delta = next->arrival_time - current_time;
                current->turnaround_time = current_time - current->arrival_time;
                current->remaining_time = 0;
                finished++;
                current = remtime_list_pop(queue);
            }

            if (current != NULL) {
                printf("Removing time from current process (%d)\n", current->id);
                current->remaining_time -= delta;
                current->state = RUNNING;
                printf("  New remaining time %d\n", current->remaining_time);
            }
            if (next->arrival_time > current_time) {
                current_time = next->arrival_time;
            }
            next->state = READY;
            

            // If no running process, immediately run next process
            if (current == NULL) {
                printf("Queue is empty, running next process %d\n", next->id);
                current = next;
                current->state = RUNNING;
                next = next->next_pinfo;

            } else if (next->remaining_time < current->remaining_time) {
                // Preempt current process
                printf("Next process (%d) has shorter remaining time\n", next->id);
                if (current->state == RUNNING) {
                    printf("  Preempting current process (%d)\n", current->id);
                    current->nb_time_pre_empted++;
                    current->remaining_time -= next->arrival_time - current_time;
                    current_time += CNTXT_SWITCH;
                    perf.total_nr_ctxt_switch++;
                }
                current->state = READY;
                remtime_list_add(queue, current);

                // Run process with shortest remaining time
                current = next;
                current->state = RUNNING;
                next = next->next_pinfo;
            } else {
                printf("Adding next process (%d) to list\n", next->id);
                remtime_list_add(queue, next);
                next = next->next_pinfo;
            }
            if (current != NULL) {
                current->state = RUNNING;
            }

            
        } else {
            printf("No new processes, emptying queue\n");
            while (current != NULL) {
                printf("Completing process %d\n", current->id);
                current->state = FINISHED;
                current_time += current->remaining_time;
                current->turnaround_time = current_time - current->arrival_time;
                current->remaining_time = 0;
                finished++;
                current = remtime_list_pop(queue);
                if (current != NULL) {
                    current->state = RUNNING;
                }
            }
        }
    }
    perf.total_time = current_time;
    perf.total_time_ctxt_switch = perf.total_nr_ctxt_switch * CNTXT_SWITCH;

    return perf;
}

void write_file(struct pinfo * process, struct perf_info * perf) {
    FILE *myStream_execution = fopen("executionRR.csv", "w");
    FILE *myStream_performance = fopen("performanceRR.csv", "w");

    if (myStream_execution == NULL || myStream_performance == NULL) {
        perror("Erreur à l'ouverture des fichiers");
        return;
    }

    while (process != NULL) {
        fprintf(myStream_execution, "%d,%d,%d,%d\n", 
                process->id,
                process->turnaround_time,
                process->wait_time,
                process->nb_time_pre_empted);
        process = process->next_pinfo;
    }
    fclose(myStream_execution);

    fprintf(myStream_performance, "%d,%d,%d\n",
            perf->total_time,
            perf->total_nr_ctxt_switch,
            perf->total_time_ctxt_switch);
    
    fclose(myStream_performance);
}

struct pinfo * read_file() {
    FILE * file = fopen("tasks.csv", "r");
    unsigned long buf_size = sizeof(char) * 64;
    char * line = (char *) malloc(buf_size);
    char * pid_str;
    char * arrival_str;
    char * execution_str;
    char * prio_str;

    struct pinfo * first = NULL;
    struct pinfo * last = NULL;
    struct pinfo * process;

    while (fgets(line, buf_size, file)) {

        MAX_PROCESSES += 1;
        pid_str = strtok(line, " ");
        arrival_str = strtok(NULL, " ");
        execution_str = strtok(NULL, " ");
        prio_str = strtok(NULL, " ");

        process = create_process(
            atoi(pid_str),
            atoi(arrival_str),
            atoi(execution_str),
            atoi(prio_str)
        );

        // Si la liste n'est pas initialisée
        if (first == NULL) {
            first = process;
        }

        // Si un élément est déjà dans la liste
        if (last != NULL) {
            last->next_pinfo = process;
        }
        last = process;

        print_pinfo(process);
    }
    free(line);
    fclose(file);

    printf("Maximum des processus : %d\n", MAX_PROCESSES);
    return first;

}

void free_processes(struct pinfo * next) {
    struct pinfo * cur;
    while (next != NULL) {
        cur = next;
        next = cur->next_pinfo;
        free(cur);
    }
}



int main() {
    struct pinfo * processes = read_file();

    //struct perf_info perf = schedule_FCFS(processes);
    struct perf_info perf = schedule_RR(processes); 
    //struct perf_info perf = schedule_Pr(processes);
    //struct perf_info perf = schedule_SRTF(processes);

    compute_waiting_time(processes);

    write_file(processes, &perf);
    print_processes(processes);
    print_perf(&perf);

    free_processes(processes);

    return 0;
}