import java.util.LinkedList;

public class FCFS implements Escalonador {

    public LinkedList<Processos> processos = new LinkedList<>();
    private LinkedList<Processos> finalizados = new LinkedList<>();

    public FCFS(LinkedList<Processos> processos) {
        this.processos = processos;
    }

    public String escalonar()
    {
        int clock = 0;
        int quantidade = processos.size();

        LinkedList<Processos> prontos = new LinkedList<>();

        while(finalizados.size() < quantidade)
        {
            // pra cada processo verifica se ele ja chegou e o coloca na lista de prontos
            while (true)
                if (!processos.isEmpty() && processos.get(0).chegada <= clock)
                    prontos.add(processos.remove(0));
                else break;

            // se nenhum chegou, adianta o clock para o primeiro da fila
            if (prontos.isEmpty())
            {
                prontos.addFirst(processos.remove(0));
                clock = prontos.get(0).chegada;
            }

            // pega o primeiro processo da lista e remove ja que ele vai ser exec
            Processos processo = prontos.remove(0);

            processo.espera = clock - processo.chegada;
            processo.resposta = processo.espera;
            processo.retorno = clock + processo.duracao - processo.chegada;

            // atualiza o clock
            clock += processo.duracao;

            System.out.println(processo);
            finalizados.add(processo);
        }

        return calcularMetricas();
    }

    public String calcularMetricas() {
        double resposta = 0;
        double espera = 0;
        double retorno = 0;
        int quantidade = finalizados.size();

        for (Processos p : finalizados) {
            resposta += p.resposta;
            espera += p.espera;
            retorno += p.retorno;
        }

        return "FCFS " + (retorno / quantidade) + " " + (espera / quantidade) + " " + (resposta / quantidade);
    }
}