import java.util.Arrays;
import javax.swing.JOptionPane;

public class Banker_Dijkstra {
 static int available[]={3,3,2};   //可利用資源數 
 static int max[][]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};;   //每線程最大需求 
 static int allocation[][]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}}; //已分配資源 
 static int need[][]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};  //需求 
 static int request[]=new int[3];   //存放請求資源 
 static int thread; //線程號 
 static JOptionPane jpane = new JOptionPane();
 // static boolean m;
 public static void main(String[] argv){ 
  int n = 0 ;
  Banker_Dijkstra bd = new Banker_Dijkstra();

  for(int i=0;i<5;i++){
   if(bd.safeState(i)){
    JOptionPane.showMessageDialog(jpane, "系統狀態安全");
    n=1;
    break;
   }else{
    n=2;
    continue;   
   }
  }  
  if(n==1){
   bd.getThread();
   }
  else if(n==2){
   JOptionPane.showMessageDialog(jpane, "系統狀態不安全");
  }
 }

 protected void getThread(){//輸入測試線程號且輸出結果
  try{
  String xiancheng = JOptionPane.showInputDialog(jpane,"請輸入申請資源的線程:");
  thread = (int) Integer.parseInt(xiancheng);
  }catch(Exception e){
   int response = JOptionPane.showConfirmDialog(jpane, "請輸入0～4:",null, JOptionPane.YES_NO_OPTION); 
   // 處理異常
   if(response==0){
    getThread();
   }else if(response ==1){
    System.exit(0);
   }
  }

  if(thread<0||thread>4){ 
   JOptionPane.showMessageDialog(jpane, "請輸入0～4:"); 
   getThread(); 
  }else{ 
   for(int i=0;i<3;i++){ 
    String requestR = JOptionPane.showInputDialog(jpane,"請輸入申請的第"+(i+1)+"種資源(若不申請則填0)");
    try{
    request[i]=Integer.parseInt(requestR);}
    catch(Exception e){
     JOptionPane.showConfirmDialog(jpane, "請輸入申請的第"+(i+1)+"種資源(若不申請則填0)",null,JOptionPane.YES_NO_OPTION);
    }
   } 
   if(request[0]>need[thread][0]||request[1]>need[thread][1]||request[2]>need[thread][2]){ 
    JOptionPane.showMessageDialog(jpane,thread+"線程申請的資源超出其需要的資源，請重新輸入"); 
    getThread(); 
   }else{ 
    if(request[0]> available[0]||request[1]> available[1]||request[2]> available[2]){ 
    JOptionPane.showMessageDialog(jpane,thread+"線程申請的資源大于系統資源，請重新輸入"); 
     getThread(); 
    } 
   } 
   // 分配資源
   allocateData(thread); 
   // 判斷 繼續模擬選擇與處理
   int tag=0;
   if(check(thread)){ 
    try{
     String str = JOptionPane.showInputDialog(jpane,"是／否 繼續模擬？( 1/0 ):");
     tag = Integer.parseInt(str);
     }catch(Exception e){
      JOptionPane.showMessageDialog(jpane, "繼續 輸入(數值) 1，不繼續 輸入(數值) 0 ！");
     }
     if(tag==1){ 
      recoverData(thread); 
      getThread();
      }
     else{
     if( (JOptionPane.YES_NO_OPTION)==JOptionPane.CANCEL_OPTION)System.exit(0);
     if((JOptionPane.YES_NO_OPTION)==JOptionPane.YES_OPTION) recoverData(thread);
     }
   }else{ 
    recoverData(thread); 
    getThread(); 
    }
   }
 }
 // 安全算法
 private boolean check(int thread2) {
  boolean[] finish = new boolean[5];
   Arrays.fill(finish, false);
  int[] work = new int[3];
  int[] queue = new int[5];
  int q=0;//安全序列下標
  for(int i = 0;i<3;i++){
   work[i] = available[i];
  }
  int tT = thread2;
  while(tT<5){
   for(int R=0;R<3;R++){
    if((!(finish[tT]==false))||(!(work[R]>=need[tT][R]))){
     tT++;
     break;
    }else{
     if(R==2){
      for(int m =0;m<3;m++){
       work[m] += allocation[tT][m];
      }
      for(int s:work){
       System.out.print(s+" ");
      }
      System.out.println("");
      finish[tT] = true;
      queue[q] = tT;
      q++;
      tT =0;
     }
    }
   } 
  }

  for(int p =0;p<5;p++){
   if(finish[p]==false){
    JOptionPane.showMessageDialog(jpane, "安全序列生成失敗");
    return false;
    }
  }

   JOptionPane.showMessageDialog(jpane, "安全序列："+queue[0]+","+queue[1]+","
  +queue[2]+","+queue[3]+","+queue[4]);
   return true;

 }
 private boolean safeState(int thread3){
  boolean[] finish = new boolean[5];
   Arrays.fill(finish, false);
   int[] work = new int[3];
   int[] queue = new int[5];
   int q=0;//安全序列下標
   for(int i = 0;i<3;i++){
    work[i] = available[i];
   }
   int tT = thread3;
   while(tT<5){
    for(int R=0;R<3;R++){
     if((!(finish[tT]==false))||(!(work[R]>=need[tT][R]))){
      tT++;
      break;
     }
     else{
      if(R==2){
       for(int m =0;m<3;m++){
        work[m] += allocation[tT][m];
       }
       finish[tT] = true;
       queue[q] = tT;
       q++;
       tT =0;
      }
     }
//     if((finish[tT]==false)&&(work[R]>=need[tT][R])){
//      for(int m =0;m<3;m++){
//       work[m] += allocation[tT][m];}
//      finish[tT] = true;
//      queue[q] = tT;
//      q++;
//      tT=0;
//      }else{ 
//       tT++;
//       break;
//       }
    } 
   }
   for(int p =0;p<5;p++){
    if(finish[p]==false){
     return false;
     }
   }
    return true;
 }

 private void recoverData(int thread2) { // 生成失敗則重置已分配資源
  for(int i=0;i<3;i++){ 
   //重新調整系統資源數 
   available[i]+=request[i]; 
   //計算各個線程擁有資源 
   allocation[thread2][i]-=request[i]; 
   //重新計算需求 
   need[thread2][i]+=request[i]; 
  } 
 }

 private void allocateData(int thread2) { //分配
  for(int i=0;i<3;i++){ 
   //重新調整可用系統資源數 
   available[i]-=request[i]; 
   //計算各個線程分配后擁有資源 
   allocation[thread2][i]+=request[i]; 
   //重新計算需求 
   need[thread2][i]-=request[i]; 
  }  
 }
}