extern crate rand;

use rand::prelude::*;
use std::cell::RefCell;
use std::collections::VecDeque;

#[derive(Debug)]
struct Server {
    current_time:    f64,
    total_work_time: f64,
    total_idle_time: f64,
}

impl Server {
    fn new() -> Server {
        Server {
                current_time:    0.0,
                total_work_time: 0.0,
                total_idle_time: 0.0,
        }
    }
}

#[derive(Clone, Copy)]
struct Request {
    receive_time: f64,
    process_time: f64
}

impl Request {
    fn new(frequency: f64, avg_process_time: f64) -> Request {
        Request {
            receive_time: (-1.0 / frequency)*(rand::thread_rng().gen::<f64>().ln()),
            process_time: (-avg_process_time)*(rand::thread_rng().gen::<f64>().ln())
        }
    }
}

fn main() {
    const COUNT_OF_SERVERS: usize = 1;
    const MAX_BUFFER_SIZE: usize  = 2;

    let mut servers = Vec::<RefCell<Server>>::new();
    for _ in 0..COUNT_OF_SERVERS {
        servers.push(RefCell::<Server>::new(Server::new()));
    }

    let mut buffer = VecDeque::<Request>::new();

    let mut time_servers_vec = Vec::<f64>::new();
    let mut time_buffer_vec  = Vec::<f64>::new();

    time_servers_vec.resize(COUNT_OF_SERVERS + 1, 0.0);
    time_buffer_vec.resize(MAX_BUFFER_SIZE + 1, 0.0);

    let mut total_time: f64 = 0.0;

    while total_time <= 3600.0 {
        let request = Request::new(1.5, 2.0);

        let mut free_servers      = servers.iter().filter(|s| s.borrow().current_time <= request.receive_time).collect::<Vec<_>>();
        let mut busy_servers      = servers.iter().filter(|s| s.borrow().current_time > 0.0).collect::<Vec<_>>();
        let after_receive_servers = servers.iter().filter(|s| s.borrow().current_time > request.receive_time).collect::<Vec<_>>();

        let mut current_receive_time = request.receive_time;
        let mut last_process_time    = 0.0;

        let mut request_accepted = false;

        while current_receive_time > 0.0 {
            if free_servers.len() > 0 {

                free_servers.sort_by(|s1, s2| s1.borrow().current_time.partial_cmp(&s2.borrow().current_time).unwrap());

                let mut is_process_complete = false;

                let mut current_free_server = free_servers[0].borrow_mut();

                time_buffer_vec[buffer.len()] +=  current_free_server.current_time - last_process_time;

                if buffer.is_empty() {
                    time_servers_vec[busy_servers.len()] += current_free_server.current_time - last_process_time;
                }

                current_receive_time -= current_free_server.current_time - last_process_time;
                last_process_time     = current_free_server.current_time;

                if !buffer.is_empty() {
                    current_free_server.current_time += buffer.pop_front().unwrap().process_time;

                    is_process_complete = current_free_server.current_time >= request.receive_time;

                    if is_process_complete {
                        current_free_server.total_work_time += request.receive_time;
                        current_free_server.current_time    -= request.receive_time;
                    }
                }
                else if !request_accepted {
                    current_free_server.total_idle_time += request.receive_time - current_free_server.current_time;
                    current_free_server.total_work_time += current_free_server.current_time;
                    current_free_server.current_time     = request.process_time;

                    request_accepted    = true;
                    is_process_complete = true;

                    busy_servers = busy_servers.into_iter().filter(|s| s.as_ptr() != free_servers[0].as_ptr()).collect::<Vec<_>>();
                }
                else {
                    current_free_server.total_work_time += current_free_server.current_time;
                    current_free_server.total_idle_time += request.receive_time - current_free_server.current_time;
                    current_free_server.current_time     = 0.0;

                    is_process_complete = true;

                    busy_servers = busy_servers.into_iter().filter(|s| s.as_ptr() != free_servers[0].as_ptr()).collect::<Vec<_>>();
                }

                if is_process_complete {
                    free_servers.remove(0);
                }

            }
            else {
                time_buffer_vec[buffer.len()] += current_receive_time;

                if buffer.is_empty() {
                    time_servers_vec[busy_servers.len()] += current_receive_time;
                }

                if buffer.len() < MAX_BUFFER_SIZE {
                    buffer.push_back(request);
                }

                break;
            }
        }

        for server in after_receive_servers {
            server.borrow_mut().current_time     -= request.receive_time;
            server.borrow_mut().total_work_time  += request.receive_time;
        }

        total_time += request.receive_time;

    }

    println!("The time servers payload: {:?}", time_servers_vec);
    println!("The time servers + buffer payload: {:?}", time_buffer_vec);


}