Real final

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;
import java.io.BufferedReader;
import java.io.BufferedWriter;

public class Escalonador {
//Estruturas
    public static class Fila{
        int Process;
        Fila prox;
        Fila ant;
    }

    public static class Processo{
        int numero;
        String nome;
        int[] bcp={0,0,0,0,0};
        /*BCP, um array que vai numeros
         * Posições:
         * [0]=Program counter
         * [1]=Estado atual (0=pronto, 1=executando, 2=bloqueado)
         * [2]=Prioridade
         * [3]=Registrador de uso geral X
         * [4]=Registrador de uso geral Y
         ** */
        //Se possivel tirar essa linha pra ler direto do arquivo de texto: (Pagina 2), trocar por "referencia a memoria"
        String[] linhas=new String[22];
        //Flag de terminado
        boolean terminado;

    }

    public static void main(String[] args) throws NumberFormatException, IOException {
        Escalonador esc=new Escalonador();
        //Criar estrutura de fila
        Fila prontos=new Fila();
        Fila firstPronto;
        int Quantidade=0;


        int[][] bloqueados=new int[3][2];
        Processo[] tabela=null;
        int[] creditos=carregaPrioridades();
        //Ler dos arquivos
        tabela=carregaProcessos();
        //Quantum lido do arquivo

            BufferedReader sq = new BufferedReader(new FileReader("processos/quantum.txt"));
            int Quantum=Integer.parseInt(sq.readLine());
            sq.close();

         //jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj
        String nome;
        if (Quantum > 9) {
            nome = Integer.toString(Quantum);
        } else {
            nome = "0" + Quantum;
        }
        File arquivo = new File("log" + nome + ".txt");
        FileWriter fw = new FileWriter(arquivo, true);
        BufferedWriter bw = new BufferedWriter(fw);
        //cria o log e os writers
        //kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk








        //Adiciona toda tabela na fila de prontos
            int x=0;
            firstPronto=null;
            ResetCreditos(tabela, creditos);
            firstPronto=OrdenaFila(creditos,tabela);

        //jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj
        //Varrendo a fila de prontos
        Fila auxiliarLeitura=firstPronto;
        while(true){
        //Le da forma
        bw.write("Carregando: "+tabela[auxiliarLeitura.Process].nome);
        bw.newLine();
        if(auxiliarLeitura.prox!=null){
        auxiliarLeitura=auxiliarLeitura.prox;
        }
        else{
        break;
        }
        }
        //kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk






        while(true){
        //Check de saida: Não tem ninguem na tabela de processos
       boolean saida=true;
       for(int i=0;i<11;i++){
           if(!tabela[i].terminado){
               saida=false;
           }
       }
       if(saida==true){
           break;
       }
       //Se não possui um pronto, então deve ter na fila de bloqueados
       if(firstPronto==null){
           DaemonDeFila(bloqueados, firstPronto, Quantidade, tabela,creditos);
       }

       //Seleciona o processo atual
       int atual=firstPronto.Process;

        //Rodar  Quantum
       int q=Quantum;
         while(q>0){
           q--;
           tabela[atual].bcp[1]=1;  //Seta que está executando
           //PC=PC+1
           tabela[atual].bcp[0]++;
           //Verifica o que está escrito na linha e chama o metodo que o trata
           if(tabela[atual].linhas[tabela[atual].bcp[0]].equals("SAIDA")){
               SAIDA(tabela, atual);
               DaemonDeFila(bloqueados, firstPronto, Quantidade, tabela,creditos); //Roda o daemon de fila antes, pois não passara por ele após o break
               break; //Sai do while pois o processo foi removido a força
           }
           if(tabela[atual].linhas[tabela[atual].bcp[0]].equals("E/S")){
               ES(tabela, atual, bloqueados,bw);
           }
           if(tabela[atual].linhas[tabela[atual].bcp[0]].equals("COM")){
               Comando(tabela, atual,bw);
           }
          if(tabela[atual].linhas[tabela[atual].bcp[0]].contains("X")){
            //Após ler que a linha possui x ou Y, copia o valor da linha para K
           String K=tabela[atual].linhas[tabela[atual].bcp[0]];
           //E de K é pego o valor alteravel
           int valor=Integer.valueOf(K.replaceAll("[^0-9]", ""));
               changeX(tabela, atual, valor,bw);
           }
           if(tabela[atual].linhas[tabela[atual].bcp[0]].contains("Y")){
               //Após ler que a linha possui x ou Y, copia o valor da linha para K
               String K=tabela[atual].linhas[tabela[atual].bcp[0]];
               //E de K é pego o valor que deve alterar
               int valor=Integer.valueOf(K.replaceAll("[^0-9]", ""));
               changeY(tabela, atual, valor, bw);
           }
           //Após ação, andar a fila de bloqueados
           DaemonDeFila(bloqueados, firstPronto, Quantidade, tabela,creditos);

       }


        //Remover credito
         creditos[atual]--;
        if(creditos[atual]==0){
            //Caso o credito acabe e esteja no final da fila
            if(firstPronto.prox==null){
            ResetCreditos(tabela, creditos);
            firstPronto=OrdenaFila(creditos,tabela);
            }
            else{
            //Apenas anda a fila e vai para o prox
            atual=firstPronto.prox.Process;
            firstPronto=firstPronto.prox;
            firstPronto.ant=null;
            }
        }
        //Condição de andar
        else if(creditos[atual]>creditos[firstPronto.prox.Process]){



            atual=firstPronto.prox.Process;
            //Remove da fila e coloca novamente
            int numAux=firstPronto.Process;
            firstPronto=firstPronto.prox;
            firstPronto.ant=null;
            firstPronto=AdicionaProntos(numAux, firstPronto, creditos);
        }





    }


        //Fim do while e log de finalização

    }

    public static void SAIDA(Processo[] p,int processo){
        p[processo].terminado=true; //Termina o processo
         p[processo].bcp[1]=-1; //Seta o estado como -1
         /* Escreve no log*/

    }

    public static void changeX(Processo[] p,int processo,int valor, BufferedWriter bw){
        p[processo].bcp[3]=valor; //Atualiza valor X
        p[processo].bcp[1]=0; //Seta o estado como pronto
        /* Escreve no log*/

    }
    public static void changeY(Processo[] p,int processo,int valor, BufferedWriter bw){
        p[processo].bcp[4]=valor; //Atualiza valor Y
        p[processo].bcp[1]=0; //Seta o estado como pronto
        /* Escreve no log*/
    }
    public static void ES(Processo[] p,int processo,int[][] bloqueados, BufferedWriter bw){
        //Encontra espaço da fila
        int i=0;
        while(true){
        if(bloqueados[i][0]!=0){
        i++;
        }
        else{
            break;
        }
        }
        //Adiciona na fila de espera
        bloqueados[i][0]=processo;
        bloqueados[i][1]=2;//Tempo de espera
        p[processo].bcp[1]=2; //Seta o estado como bloqueado

        /* Escreve no log*/

    }
    public static void Comando(Processo[] p,int processo, BufferedWriter bw){
         p[processo].bcp[1]=0;
        /* Escreve no log*/


        //for(Programa programa: bcp.programas){
        //  bw.write("Carregando: "+programa.nome);
        //  bw.newLine();
        //}


    }
    public static void DaemonDeFila(int[][] bloqueados, Fila FirstPronto, int quantidade, Processo[] tabela, int[] creditos){

        //Remove 1 tempo de cada processo na fila de bloqueados
        if(bloqueados[0][0]!=0){
            bloqueados[0][1]--;
            if(bloqueados[0][1]==0){
                FirstPronto=AdicionaProntos(bloqueados[0][0], FirstPronto,creditos);
                tabela[bloqueados[0][0]].bcp[1]=0;

          }
        }
        if(bloqueados[1][0]!=0){
            bloqueados[1][1]--;
            if(bloqueados[1][1]==0){
                FirstPronto=AdicionaProntos(bloqueados[1][0], FirstPronto,creditos);
                tabela[bloqueados[1][0]].bcp[1]=0;

            }
        }
        if(bloqueados[2][0]!=0){
            bloqueados[2][1]--;
            if(bloqueados[0][1]==0){
                FirstPronto=AdicionaProntos(bloqueados[2][0], FirstPronto,creditos);
                tabela[bloqueados[2][0]].bcp[1]=0;

            }
        }

    }
    private static Fila AdicionaProntos(int processo, Fila FirstPronto,int[] creditos) {
        //Adiciona na fila e retorna o primeiro processo da fila
        if(FirstPronto==null){
            //Adiciona o primeiro
            FirstPronto=new Fila();
            FirstPronto.ant=null;
            FirstPronto.prox=null;
            FirstPronto.Process=processo;
            return FirstPronto;
        }
        else{
            //Verificação 1: Se o processo adicionado tem maior prioridade e então vira o novo FirstPronto
            if(creditos[processo]>creditos[FirstPronto.Process]){
                Fila aux=new Fila();
                aux.ant=null;
                aux.prox=FirstPronto;
                FirstPronto.ant=aux;
                return aux;
            }
            Fila atual=FirstPronto;
            while(true){
            if(creditos[atual.Process]>=creditos[processo]){
                //Se o processo adicionado for menor que o atual, então anda pro proximo
                if(atual.prox==null){
                    //Se o proximo for nulo, então adiciona aqui de qualquer jeito
                    Fila aux=new Fila();
                    aux.ant=atual;
                    aux.prox=null;
                    return FirstPronto;
                }
                else{
                    atual=atual.prox;
                }
            }
            else{ //Processo adicionado é maior que o atual
                Fila aux=new Fila();
                aux.prox=atual;
                aux.ant=atual.ant;
                atual.ant=aux;
                return FirstPronto;
            }


            }

        }


    }

    private static Fila OrdenaFila(int[] creditos,Processo[] tabela){
       //Adiciona todo mundo e retorna o first pronto
        Fila FirstPronto=null;
        for(int i=0;i<11;i++){
            if(!tabela[i].terminado){
                //Se o processo está pronto pra ser usado, então adiciona ele na fila
                FirstPronto=AdicionaProntos(i, FirstPronto,creditos);
            }
        }




        return FirstPronto;

    }

    private static void ResetCreditos(Processo[] p, int[] creditos){
        //Restaura o valor de creditos baseado no valor salvo no bcp
        for(int i=0;i<10;i++){
            if(!p[i].terminado){
                creditos[i]=p[i].bcp[2];
            }
        }
    }
    private static Processo[] carregaProcessos() {
        Processo[] processos = new Processo[10];

        for (int i = 1; i < 11; i++) {
            try {
                BufferedReader br = new BufferedReader(new FileReader("processos/" + (i == 10 ? i : "0" + i) + ".txt"));


                Processo processo = new Processo();
                int contador = 0;

                processo.nome = br.readLine();
                while (contador < 22) {
                    String linha = br.readLine();
                    if (linha != null) {
                        processo.linhas[contador++] = linha;
                        break;
                    }
                }

                processos[i - 1] = processo;
                br.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        return processos;
}
  private static int[] carregaPrioridades() {
        int[] prioridades = new int[10];

        try (BufferedReader br = new BufferedReader(new FileReader("processos/prioridades.txt"))) {
            for (int i = 0; i < 10; i++) {
                prioridades[i] = Integer.parseInt(br.readLine());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return prioridades;
    }



}