int main(int argc, char **argv)
{
    const char *input_file = "input.txt";
    const char *output_file = "output.txt";

    int i, j, k, n;
    int cars_arrived, total_cars, max_queue_len, running_queue_len;
    int arrival_time, wait_time, max_wait_time, running_wait_time;
    int departure_period, departure_timer;
    int light_timer, light_duration[3] = {0, 0, 0};
    int time, increment, runtime;
    int avg_wait_time, avg_queue_len;
    double arrival_rate, lambda;

    Light light;
    queue_t *queue = (queue_t *)malloc(sizeof(queue));
    parameters *param_list = read_input_file(input_file, &n);

    FILE *output_fp = fopen(output_file, "w");
    fprintf(output_fp, "%sn", STUDENT_ID);

    for (i = 0; i < n; i++)
    {
        /* simulation setup */
        light = RED;
        runtime = param_list[i][2] * 60 * 1000; /* minutes to millseconds*/
        increment = param_list[i][3];           /* millseconds*/
        arrival_rate = param_list[i][0] / (double)(60 * 1000); /* per minute to per millsecond */
        departure_period = param_list[i][1] * 1000; /* seconds to millseconds*/

        for (k = 0; k < 3; k++)
            light_duration[k] = param_list[i][k + 4] * 1000; /* seconds to millseconds*/

        lambda = arrival_rate * increment;

        /* counters initialization */
        total_cars = 0;
        running_queue_len = 0;
        max_queue_len = 0;
        max_wait_time = 0;
        running_wait_time = 0;
        departure_timer = 0;
        light_timer = 0;

        for (time = 0; time < runtime; time += increment)
        {
            /* change lights */
            if (light_timer > light_duration[light])
            {
                /* GREEN -> AMBER -> RED -> GREEN */
                if (light == GREEN)
                    light = AMBER;
                else if (light == AMBER)
                    light = RED;
                else
                {
                    light = GREEN;
                    departure_timer = 0; /* reset */
                }
                light_timer = 0;  /* reset */
            }
            /* enqueue cars arrived */
            cars_arrived = samplePoisson(lambda);
            for (k = 0; k < cars_arrived; k++)
                queue = enqueue(queue, time);

            total_cars += cars_arrived;
            /* a car departs on green light */
            if (departure_timer >= departure_period && light == GREEN)
            {
                if (!queue_empty(queue))
                {
                    queue = dequeue(queue, &arrival_time);
                    wait_time = time - arrival_time;
                    max_wait_time = max_wait_time > wait_time ? max_wait_time : wait_time;
                    running_wait_time += wait_time;
                }
                departure_timer = 0; /* reset */
            }

            running_queue_len += queue->length;
            max_queue_len = max_queue_len > queue->length ? max_queue_len : queue->length;

            departure_timer += increment;
            light_timer += increment;
        }

        while(!queue_empty(queue)) /* dequeue remaining cars */
        {
            queue = dequeue(queue, &arrival_time);
            wait_time = time - arrival_time;
            max_wait_time = max_wait_time > wait_time ? max_wait_time : wait_time;
            running_wait_time += wait_time;
        }

        avg_wait_time = running_wait_time / total_cars;
        avg_queue_len = running_queue_len / runtime;

        /* write the output to the file */
        fprintf(output_fp, "Arrival rate: %d cars per minn", param_list[i][0]);
        fprintf(output_fp, "Departure rate: %d s per carn", param_list[i][1]);
        fprintf(output_fp, "Runtime: %d minn", param_list[i][2]);
        fprintf(output_fp, "Time increment:  %d msn", param_list[i][3]);
        fprintf(output_fp, "Light sequence: Green %d s; Amber %d s; Red %d sn",
                param_list[i][6], param_list[i][5], param_list[i][4]);
        fprintf(output_fp, "Average length: %d carsn", avg_queue_len);
        fprintf(output_fp, "Maximum length: %d carsn", max_queue_len);
        fprintf(output_fp, "Average wait: %d sn", avg_wait_time / 1000);
        fprintf(output_fp, "Maximum wait: %d sn", max_wait_time / 1000);
    }

    fclose(output_fp);
    /* free memory */
    free(queue);
    free(param_list);

    return 0;

}