import time
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
import chromedriver_autoinstaller
import subprocess
import shutil
import pyautogui

try:
    shutil.rmtree(r"C:\chrometemp")  # remove Cookie, Cache fileHjdy08254s
except FileNotFoundError:
    pass

try:
    subprocess.Popen(r'C:\Program Files\Google\Chrome\Application\chrome.exe --remote-debugging-port=9222 '
                     r'--user-data-dir="C:\chrometemp"')   # Open the debugger chrome
    
except FileNotFoundError:
    subprocess.Popen(r'C:\Users\binsu\AppData\Local\Google\Chrome\Application\chrome.exe --remote-debugging-port=9222 '
                     r'--user-data-dir="C:\chrometemp"')

option = Options()
option.add_experimental_option("debuggerAddress", "127.0.0.1:9222")

chrome_ver = chromedriver_autoinstaller.get_chrome_version().split('.')[0]
try:
    driver = webdriver.Chrome(f'./{chrome_ver}/chromedriver.exe', options=option)
    
except:
    chromedriver_autoinstaller.install(True)
    driver = webdriver.Chrome(f'./{chrome_ver}/chromedriver.exe', options=option)
driver.implicitly_wait(10)

driver.get(
    url='https://accounts.google.com/signin/v2/identifier?hl=ko&passive=true&continue=https%3A%2F%2Fwww.google.com%2F'
        '%3Fgws_rd%3Dssl&ec=GAZAmgQ&flowName=GlifWebSignIn&flowEntry=ServiceLogin')
# Google login page

pyautogui.write('아이디')    # Fill in your ID or E-mail
pyautogui.press('enter')
time.sleep(3)   # wait a process
pyautogui.write('비밀번호')   # Fill in your PW
pyautogui.press('enter')

import java.util.Scanner;//Scanner를 사용하기위해 import를 통해 외부 클래스를 호출
//Scanner는 java.util 패키지에 포함되어있다.

public class Worst_Fit2 { // Worst_Fit2 라는 객체를 생성
	public static void main(String[] args) {// 접근 한정자를 public으로 설정(어디서든지 사용가능)
		// static으로 메모리를 미리 할당
		// void는 함수가 끝날 때 리턴값이 없다.
		// main은 메인 함수로 쓰여지는것
		// String[] args는 args를 문자열로 사용하겠다 라는 의미

		Scanner in = new Scanner(System.in); // 객체를 생성 System.in은 키보드로 입력받기위해 사용
		int[] mem = new int[5]; // 정수형mem배열값을 5로 선언
		int[] ps = new int[5]; // 정수형ps배열값을 5로 선언
		int count = 0; // 정수형 변수 count 값을 0으로 초기화 - mem의 배열 인자값으로 사용할 변수
		int temp = 0; // 정수형 변수 temp값을 0으로 초기화

		System.out.println(); // 줄 띄우기

		System.out.print("메모리 입력 : "); // 메모리 입력 - 출력문
		for (int i = 0; i < 5; i++) { // i 는 0~4까지
			mem[i] = in.nextInt(); // mem[i] 에 값을 입력
		}
		System.out.print("프로세스값 입력 : "); // 프로세스 입력 - 출력문
		for (int i = 0; i < 5; i++) { // i는 0~4까지
			ps[i] = in.nextInt(); // ps[i] 에 값을 입력
		}

		System.out.println(); // 줄띄우기
		System.out.println(); // 줄띄우기

		for (int j = 0; j < 4; j++) { // 0~4까지 1씩 증가//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
			for (int i = 0; i < 4; i++) { // 0~3까지 1씩 증가 //조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
				if (mem[i] < mem[i + 1]) { // mem[i]가 mem[i+1]보다 클때 실행
					temp = mem[i]; // temp, mem[i] 을 템프로 교환
					mem[i] = mem[i + 1]; // mem[i] 와 mem[i+1]를 교환
					mem[i + 1] = temp; // mem[i+1]을 temp와 교환
				}
			}
		}

		for (int i = 0; i < 5; i++) { // i는 0~4까지
			if (ps[i] <= mem[count]) { // ps[i]값이 mem[count]값보다 작거나 같다면 조건문 실행
				System.out.print("p" + count + " - 사용된 메모리 공간 : " + mem[count]); // 사용된 메모리 공간 출력문
				mem[count] = mem[count] - ps[i]; // mem[count]값에 ps[i]값을 빼준다
				if (mem[count] < 0) { // 만약 값을 빼줬는데 0보다 작아진다면
					mem[count] = mem[count] + ps[i]; // 다시 ps[i]값을 더해주고
					count++; // count값을 다시 올려준뒤 - 다음 메모리로 이동
					mem[count] = mem[count] - ps[i];// 증가된 count값으로 mem[count] 에 ps[i]값을 다시 빼준다
				}
				System.out.print("[" + mem[count] + "]"); // mem[count]값 출력문
				System.out.println(); // 줄띄우기
			} else if (mem[count] < ps[i]) { // mem[count]값이 ps[i]보다 작다면
				count++; // count값 증가
				System.out.print("p" + count + " - 사용된 메모리 공간 : " + mem[count]); // 사용된 메모리 공간 출력문
				mem[count] = mem[count] - ps[i]; // mem[count]값에 ps[i]값 빼주기
				System.out.print("[" + mem[count] + "]"); // 빠진 메모릭값 출력문
				System.out.println(); // 줄띄우기
			}
		}

	}
}

import java.util.Scanner;//Scanner를 사용하기위해 import를 통해 외부 클래스를 호출
//Scanner는 java.util 패키지에 포함되어있다.

public class Best_Fit2 { // Best_Fit2 라는 객체를 생성
	public static void main(String[] args) {// 접근 한정자를 public으로 설정(어디서든지 사용가능)
		// static으로 메모리를 미리 할당
		// void는 함수가 끝날 때 리턴값이 없다.
		// main은 메인 함수로 쓰여지는것
		// String[] args는 args를 문자열로 사용하겠다 라는 의미

		Scanner in = new Scanner(System.in); // 객체를 생성 System.in은 키보드로 입력받기위해 사용
		int[] mem = new int[5]; // 정수형mem배열값을 5로 선언
		int[] ps = new int[5]; // 정수형ps배열값을 5로 선언
		int count = 0; // 정수형 변수 count 값을 0으로 초기화 - mem의 배열 인자값으로 사용할 변수
		int temp = 0; // 정수형 변수 temp값을 0으로 초기화

		System.out.println(); // 줄띄우기

		System.out.print("메모리 입력 : "); // 메모리 입력 - 출력문
		for (int i = 0; i < 5; i++) { // i 는 0~4까지
			mem[i] = in.nextInt(); // mem[i] 에 값을 입력
		}
		System.out.print("프로세스값 입력 : "); // 프로세스 입력 - 출력문
		for (int i = 0; i < 5; i++) { // i는 0~4까지
			ps[i] = in.nextInt(); // ps[i] 에 값을 입력
		}

		System.out.println(); // 줄띄우기
		System.out.println(); // 줄띄우기

		for (int j = 0; j < 4; j++) { // 0~4까지 1씩 증가//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
			for (int i = 0; i < 4; i++) { // 0~3까지 1씩 증가 //조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
				if (mem[i] > mem[i + 1]) { // mem[i]가 mem[i+1]보다 클때 실행
					temp = mem[i]; // temp, mem[i] 을 템프로 교환
					mem[i] = mem[i + 1]; // mem[i] 와 mem[i+1]를 교환
					mem[i + 1] = temp; // mem[i+1]을 temp와 교환
				}
			}
		}
		for (int i = 0; i < 5; i++) { // i는 0~4까지
			if (ps[i] <= mem[count]) { // ps[i]값이 mem[count]값보다 작거나 같다면 조건문 실행
				System.out.print("p" + count + " - 사용된 메모리 공간 : " + mem[count]); // 사용된 메모리 공간 출력문
				mem[count] = mem[count] - ps[i]; // mem[count]값에 ps[i]값을 빼준다
				if (mem[count] < 0) { // 만약 값을 빼줬는데 0보다 작아진다면
					mem[count] = mem[count] + ps[i]; // 다시 ps[i]값을 더해주고
					count++; // count값을 다시 올려준뒤 - 다음 메모리로 이동
					mem[count] = mem[count] - ps[i];// 증가된 count값으로 mem[count] 에 ps[i]값을 다시 빼준다
				}
				System.out.print("[" + mem[count] + "]"); // mem[count]값 출력문
				System.out.println(); // 줄띄우기
			} else if (mem[count] < ps[i]) { // mem[count]값이 ps[i]보다 작다면
				count++; // count값 증가
				System.out.print("p" + count + " - 사용된 메모리 공간 : " + mem[count]); // 사용된 메모리 공간 출력문
				mem[count] = mem[count] - ps[i]; // mem[count]값에 ps[i]값 빼주기
				System.out.print("[" + mem[count] + "]"); // 빠진 메모릭값 출력문
				System.out.println(); // 줄띄우기
			}
		}

	}
}

import java.util.Scanner;//Scanner를 사용하기위해 import를 통해 외부 클래스를 호출
//Scanner는 java.util 패키지에 포함되어있다.

public class First_Fit2 { // First_Fit2 라는 객체를 생성
	public static void main(String[] args) {// 접근 한정자를 public으로 설정(어디서든지 사용가능)
		// static으로 메모리를 미리 할당
		// void는 함수가 끝날 때 리턴값이 없다.
		// main은 메인 함수로 쓰여지는것
		// String[] args는 args를 문자열로 사용하겠다 라는 의미

		Scanner in = new Scanner(System.in); // 객체를 생성 System.in은 키보드로 입력받기위해 사용
		int[] mem = new int[5]; // 정수형mem배열값을 5로 선언
		int[] ps = new int[5]; // 정수형ps배열값을 5로 선언
		int count = 0; // 정수형 변수 count 값을 0으로 초기화 - mem의 배열 인자값으로 사용할 변수

		System.out.println();// 줄띄우기

		System.out.print("메모리 입력 : "); // 메모리 입력 - 출력문
		for (int i = 0; i < 5; i++) { // i 는 0~4까지
			mem[i] = in.nextInt(); // mem[i] 에 값을 입력
		}
		System.out.print("프로세스값 입력 : "); // 프로세스 입력 - 출력문
		for (int i = 0; i < 5; i++) { // i는 0~4까지
			ps[i] = in.nextInt(); // ps[i] 에 값을 입력
		}

		System.out.println(); // 줄띄우기
		System.out.println(); // 줄띄우기

		for (int i = 0; i < 5; i++) { // i는 0~4까지
			if (ps[i] <= mem[count]) { // ps[i]값이 mem[count]값보다 작거나 같다면 조건문 실행
				System.out.print("p" + count + " - 사용된 메모리 공간 : " + mem[count]); // 사용된 메모리 공간 출력문
				mem[count] = mem[count] - ps[i]; // mem[count]값에 ps[i]값을 빼준다
				if (mem[count] < 0) { // 만약 값을 빼줬는데 0보다 작아진다면
					mem[count] = mem[count] + ps[i]; // 다시 ps[i]값을 더해주고
					count++; // count값을 다시 올려준뒤 - 다음 메모리로 이동
					mem[count] = mem[count] - ps[i];// 증가된 count값으로 mem[count] 에 ps[i]값을 다시 빼준다
				}
				System.out.print("[" + mem[count] + "]"); // mem[count]값 출력문
				System.out.println(); // 줄띄우기
			} else if (mem[count] < ps[i]) { // mem[count]값이 ps[i]보다 작다면
				count++; // count값 증가
				System.out.print("p" + count + " - 사용된 메모리 공간 : " + mem[count]); // 사용된 메모리 공간 출력문
				mem[count] = mem[count] - ps[i]; // mem[count]값에 ps[i]값 빼주기
				System.out.print("[" + mem[count] + "]"); // 빠진 메모릭값 출력문
				System.out.println(); // 줄띄우기
			}
		}

	}
}

public class Best_Fit { // Best_Fit이라는 객체를 생성
	public static void main(String[] args) {// 접근 한정자를 public으로 설정(어디서든지 사용가능)
		// static으로 메모리를 미리 할당
		// void는 함수가 끝날 때 리턴값이 없다.
		// main은 메인 함수로 쓰여지는것
		// String[] args는 args를 문자열로 사용하겠다 라는 의미

		int mem[] = { 10, 2, 1, 12, 4 }; // 정수형 mem 배열에 10, 2, 1, 12, 4 값으로 초기화 크기는 5 메모리값이다
		int selmem = 3; // 정수형 변수 selmem 값을 3으로 초기화 사용할 메모리값
		int temp = 0; // 정수형 변수 temp값을 0으로 초기화

		System.out.println();// 줄띄우기

		System.out.print("메모리 크기 : ");// 메모리크기 출력문
		for (int i = 0; i < 5; i++) { // i는 0~4까지
			System.out.print(mem[i] + "  "); // 메모리값 출력문
		}
		System.out.println(); // 줄띄우기
		System.out.println("현재 넣을 값 : " + selmem);// selmem값 출력문

		for (int j = 0; j < 4; j++) { // 0~4까지 1씩 증가//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
			for (int i = 0; i < 4; i++) { // 0~3까지 1씩 증가 //조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
				if (mem[i] > mem[i + 1]) { // mem[i]가 mem[i+1]보다 클때 실행
					temp = mem[i]; // temp, mem[i] 을 템프로 교환
					mem[i] = mem[i + 1]; // mem[i] 와 mem[i+1]를 교환
					mem[i + 1] = temp; // mem[i+1]을 temp와 교환
				}
			}
		}
		for (int i = 0; i < 5; i++) { // i는 0~4까지
			if (selmem < mem[i]) { // selmem값이 mem[i]보다 작다면 조건문 실행
				System.out.print("사용된 메모리 공간 : " + mem[i]); // mem값 출력문
				mem[i] = mem[i] - selmem; // mem[i]값에 selmem빼기
				System.out.print("[" + mem[i] + "]"); // 빠진 메모리값 출력문
				break; // 값을 빼줬다면 for문 탈출
			}
		}
	}
}

public class Worst_Fit {// Worst_Fit이라는 객체를 생성
	public static void main(String[] args) {// 접근 한정자를 public으로 설정(어디서든지 사용가능)
		// static으로 메모리를 미리 할당
		// void는 함수가 끝날 때 리턴값이 없다.
		// main은 메인 함수로 쓰여지는것
		// String[] args는 args를 문자열로 사용하겠다 라는 의미

		int mem[] = { 10, 2, 1, 12, 4 }; // 정수형 mem 배열에 10, 2, 1, 12, 4 값으로 초기화 크기는 5 메모리값이다
		int selmem = 3; // 정수형 변수 selmem 값을 3으로 초기화 사용할 메모리값
		int temp = 0; // 정수형 변수 temp값을 0으로 초기화

		System.out.println();// 줄 띄우기

		System.out.print("메모리 크기 : ");// 메모리크기 출력문
		for (int i = 0; i < 5; i++) { // i는 0~4까지
			System.out.print(mem[i] + "  "); // 메모리값 출력문
		}
		System.out.println(); // 줄 띄우기

		System.out.println("현재 넣을 값 : " + selmem); // selmem 값 출력문
		for (int j = 0; j < 4; j++) { // 0~4까지 1씩 증가//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
			for (int i = 0; i < 4; i++) { // 0~3까지 1씩 증가 //조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
				if (mem[i] < mem[i + 1]) { // mem[i]가 mem[i+1]보다 클때 실행
					temp = mem[i]; // temp, mem[i] 을 템프로 교환
					mem[i] = mem[i + 1]; // mem[i] 와 mem[i+1]를 교환
					mem[i + 1] = temp; // mem[i+1]을 temp와 교환
				}
			}
		}

		for (int i = 0; i < 5; i++) { // i는 0~4까지
			if (selmem < mem[i]) { // selmem이 mem[i]보다 작다면 조건문 실행
				System.out.print("사용된 메모리 공간 : " + mem[i]); // 사용된 메모리 공간 출력문
				mem[i] = mem[i] - selmem; // mem[i]값에서 selmem값을 빼기
				System.out.print("[" + mem[i] + "]"); // 빠진 메모리값 출력문
				break; // 값이 빠졌다면 for문 탈출
			}
		}
	}
}

public class First_Fit { // First_Fit 이라는 객체를 생성
	public static void main(String[] args) { // 접근 한정자를 public으로 설정(어디서든지 사용가능)
												// static으로 메모리를 미리 할당
												// void는 함수가 끝날 때 리턴값이 없다.
												// main은 메인 함수로 쓰여지는것
												// String[] args는 args를 문자열로 사용하겠다 라는 의미

		int mem[] = { 10, 2, 1, 12, 4 }; // 정수형 mem 배열에 10, 2, 1, 12, 4 값으로 초기화 크기는 5 메모리값이다
		int selmem = 3; // 정수형 변수 selmem 값을 3으로 초기화 사용할 메모리값

		System.out.println(); // 줄 띄우기

		System.out.print("메모리 크기 : "); // 메모리크기 출력문
		for (int i = 0; i < 5; i++) { // i는 0~4까지
			System.out.print(mem[i] + "  "); // 메모리 크기
		}
		System.out.println(); // 줄 띄우기
		System.out.println("현재 넣을 값 : " + selmem); // selmem값 출력문

		for (int i = 0; i < 5; i++) { // i는 0~4까지
			if (selmem < mem[i]) { // selmem보다 mem[i]가 작다면 조건문 실행
				System.out.print("사용된 메모리 공간 : " + mem[i]); // 사용된 메모리공간 출력문
				mem[i] = mem[i] - selmem; // mem[i]에 selmem값 빼기
				System.out.println("[" + mem[i] + "]"); // 빠진 메모리값 보여주기
				break; // 값을 뻈으면 for문 탈출
			}
		}

	}
}

public class HRN {						//HRN이라는 객체를 생성
	public static void main(String[] args) {		//접근 한정자를 public으로 설정(어디서든지 사용가능)
								//static으로 메모리를 미리 할당
								//void는 함수가 끝날 때 리턴값이 없다.
								//main은 메인 함수로 쓰여지는것
								//String[] args는 args를 문자열로 사용하겠다 라는 의미
		float temp=0;				//프로세스 우선순위의 값을 정렬할 실수로 선언된 temp
		int temp2=0;				//나머지 도착시간,시작시간,종료시간,실행시간 정렬을위해 정수로 선언된 temp
		int[] end = new int[5];			//종료시간 크기5 end 배열 선언
		int[] start = new int[5];			//시작시간 크기5 start 배열 선언
		int[] wait = new int[5];			//대기시간 크기5 wait 배열 선언
		int[] arrival = {0, 1, 2, 3, 4};		//도착시간 크기5 arrival 0,1,2,3,4로 초기화한 배열 선언
		int[] run = {10, 28, 6, 4, 14};		//실행시간 크기5 run 10,28,6,4,14로 초기화한 배열 선언
		int[] process_num = {1, 2, 3, 4, 5};	//프로세스 번호 크기5 process_num 1,2,3,4,5로 초기화한 배열 선언
		float[] process = new float[5];		//프로세스 우선순위 값 크기5 인 배열 선언
		end[0] = 10; start[0] = 0;			//프로세스 1번째 종료시간과 시작시간 값 초기화
		
		for(int i=1; i<5; i++) {			//1 ~ 4까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
								//시간들 계산하는 for문	1번 프로세스는 고정 그래서 1부터 시작
			wait[i] = run[0] - arrival[i];		//대기시간 구하는 계산식
			process[i] = (run[i] + wait[i] + process[i-1])/run[i];		//프로세스 우선순위 값 구하는 계산식
			end[i] = end[i] + run[i];						//종료시간 계산식
		}
		for(int j=1; j<3; j++) {					//1 ~ 2까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
			for(int i=1; i<4; i++) {				//1 ~ 4까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식	
										//1부터 시작하는 이유는 프로세스1번은 정렬을 할 필요가 없기 때문
				if(process[i] < process[i+1]) {		//프로세스 우선순위 값이 큰 순서대로 나머지 값도 다 같이 정렬해주는 if문
					temp = process[i];			//우선순위값인 process 정렬
					process[i] = process[i+1];
					process[i+1] = temp;
					temp2 = process_num[i];		//프로세스번호 변수인 process_num 값 정렬
					process_num[i] = process_num[i+1];
					process_num[i+1] = temp2;
					temp2 = end[i];			//종료시간 변수인 end 값 정렬
					end[i] = end[i+1];
					end[i+1] = temp2;
					temp2 = arrival[i];			//도착시간 변수인 arrival 값 정렬
					arrival[i] = arrival[i+1];
					arrival[i+1] = temp2;
					temp2 = run[i];			//실행시간 변수인 run 값 정렬
					run[i] = run[i+1];
					run[i+1] = temp2;
				}
			}
		}
		for(int i=1; i<5; i++) {			//1 ~ 4까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
								//프로세스1번 말고 나머지 종료시간, 시작시간 구하는 for문
			end[i] = end[i] + end[i-1];	//종료시간값 구하는 계산식
			start[i] = end[i-1]+1;		//시작시간값 구하는 계산식
		}
		System.out.print("프로세스번호  도착시간	 시작시간	 종료시간	 실행시간");	//프로세스번호, 도착시간, 시작시간, 종료시간, 실행시간 출력문
		System.out.println();										//줄바꿈
		for(int i=0; i<5; i++) {					//0 ~ 4까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
			System.out.println("  p" + process_num[i] +"	  	"+ arrival[i]+" 	  "+start[i]+" 		  "+end[i]+" 		  "+run[i]);	
		}								//프로세스번호, 도착시간, 시작시간, 종료시간, 실행시간 배열값 출력문
	}
}