package caoss.simulator.os.scheduling;

import static caoss.simulator.os.OperatingSystem.OS;

import java.util.Queue;
import java.util.concurrent.LinkedBlockingQueue;

import caoss.simulator.Program;
import caoss.simulator.configuration.Hardware;
import caoss.simulator.hardware.DeviceId;
import caoss.simulator.hardware.Timer;
import caoss.simulator.os.Dispatcher;
import caoss.simulator.os.Logger;
import caoss.simulator.os.ProcessControlBlock;
import caoss.simulator.os.Scheduler;


public class FSOScheduler implements Scheduler<SchedulingState> {

	private static final int QUANTUM = 10;
	private static final int QUOTA = 20;
	private static final int PERIOD = 150;
	private static final int PRIOLEVELS = 4;


	private final Queue<ProcessControlBlock<SchedulingState>>[] readyQueues;
	private final Queue<ProcessControlBlock<SchedulingState>> blockedQueue;
	private ProcessControlBlock<SchedulingState> running; // just one CPU

	private final Timer timer = (Timer) Hardware.devices.get(DeviceId.TIMER);

	private long lastUpgradeTime = 0;  // last priority upgrade time


	@SuppressWarnings("unchecked")
	public FSOScheduler( ) {
		this.readyQueues = (Queue<ProcessControlBlock<SchedulingState>>[]) new LinkedBlockingQueue[PRIOLEVELS];
		this.blockedQueue = new LinkedBlockingQueue<ProcessControlBlock<SchedulingState>>();

		for (int i = 0; i < PRIOLEVELS; i++) {
			this.readyQueues[i] = new LinkedBlockingQueue<ProcessControlBlock<SchedulingState>>();
		}

		this.lastUpgradeTime = Hardware.clock.getTime();
	}


	@Override
	public synchronized void newProcess(Program program) {

		ProcessControlBlock<SchedulingState> pcb =
				new ProcessControlBlock<SchedulingState>(program,
						new SchedulingState(0, QUOTA));
		Logger.info("Create process " + pcb.pid + " to run program " + program.getFileName());

		if (OS.getRunningProcess() == null)
			dispatch(pcb);
		else
			this.readyQueues[0].add(pcb);


		upgrade();
		logQueues();
	}

	@Override
	public synchronized void ioRequest(ProcessControlBlock<SchedulingState> pcb) {
		Logger.info("Process " + pcb.pid + ": IO request");

		// TODO:
		long time = Hardware.clock.getTime();
		long decorredTime = time - (pcb.getSchedulingState().getSchedulingTime());

		long quota = pcb.getSchedulingState().getQuota();
		pcb.getSchedulingState().setQuota((int) (quota - decorredTime));

		if (quota <= 0) {
			pcb.getSchedulingState().setQuota(QUOTA);
			int level = pcb.getSchedulingState().getLevel();
			if (level < readyQueues.length - 1)
				pcb.getSchedulingState().setLevel(level + 1);
		}

		blockedQueue.add(pcb);

		chooseNext();

		upgrade();
		logQueues();
	}

	@Override
	public synchronized void ioConcluded(ProcessControlBlock<SchedulingState> pcb) {
		Logger.info("Process " + pcb.pid + ": IO concluded");

		// TODO:
		blockedQueue.remove(pcb);

		if (OS.getRunningProcess() == null)
			dispatch(pcb);
		else {
			int level = pcb.getSchedulingState().getLevel();
			readyQueues[level].add(pcb);
		}

		upgrade();
		logQueues();
	}

	@Override
	public synchronized void quantumExpired(ProcessControlBlock<SchedulingState> pcb) {
		Logger.info("Process " + pcb.pid + ": quantum expired");

		// TODO:
		int quota = pcb.getSchedulingState().getQuota();
		pcb.getSchedulingState().setQuota(quota - QUANTUM);

		if ( (pcb.getSchedulingState().getQuota()) <= 0) {
			Logger.info("Process " + pcb.pid + ": quota expired");
			int currLevel = pcb.getSchedulingState().getLevel();
			if (currLevel < readyQueues.length - 1)
				pcb.getSchedulingState().setLevel(currLevel + 1);
			pcb.getSchedulingState().setQuota(QUOTA);
		}

		readyQueues[pcb.getSchedulingState().getLevel()].add(pcb);


		chooseNext();

		upgrade();
		logQueues();
	}

	@Override
	public synchronized void processConcluded(ProcessControlBlock<SchedulingState> pcb) {
		Logger.info("Process " + pcb.pid + ": execution concluded");

		long turnarround = Hardware.clock.getTime() - pcb.arrivalTime;
		Logger.info("Process " + pcb.pid + ": turnarround time: " + turnarround);

		chooseNext();

		upgrade();
		logQueues();
	}



	private void upgrade() {
		long currentTime = Hardware.clock.getTime();
		long elapsed = currentTime - this.lastUpgradeTime;
		if (elapsed >= PERIOD) {
			Logger.info("Upgrade priorities");

			// TODO:
			if (running != null) {
				running.getSchedulingState().setQuota(QUOTA);

				if (running.getSchedulingState().getLevel() == 3)
					running.getSchedulingState().setLevel(1);
				else
					running.getSchedulingState().setLevel(0);
			}

			for (ProcessControlBlock<SchedulingState> curr: blockedQueue) {
				curr.getSchedulingState().setQuota(QUOTA);
				if (curr.getSchedulingState().getLevel() == 3)
					curr.getSchedulingState().setLevel(1);
				else
					curr.getSchedulingState().setLevel(0);
			}

			for (ProcessControlBlock<SchedulingState> curr: readyQueues[0]) {
				curr.getSchedulingState().setQuota(QUOTA);
			}

			for (int j = 1; j <= 2; j++)
				while(!readyQueues[j].isEmpty()) {
					ProcessControlBlock<SchedulingState> pcb = readyQueues[j].poll();
					pcb.getSchedulingState().setQuota(QUOTA);
					pcb.getSchedulingState().setLevel(0);
					readyQueues[0].add(pcb);
				}

			while(!readyQueues[3].isEmpty()) {
				ProcessControlBlock<SchedulingState> pcb = readyQueues[3].poll();
				pcb.getSchedulingState().setQuota(QUOTA);
				pcb.getSchedulingState().setLevel(1);
				readyQueues[1].add(pcb);
			}

			this.lastUpgradeTime = currentTime;
		}
	}


	private void chooseNext() {
		for (Queue<ProcessControlBlock<SchedulingState>> queue : this.readyQueues) {
			if (queue.size() > 0) {
				dispatch(queue.poll());
				return;
			}
		}

		dispatch(null);
	}

	private void dispatch(ProcessControlBlock<SchedulingState> pcb) {
		Dispatcher.dispatch(pcb);
		running = pcb;

		if (pcb != null) {
			SchedulingState state = pcb.getSchedulingState();
			state.setSchedulingTime(Hardware.clock.getTime());
			timer.set(QUANTUM);
			Logger.info("Run process "+ pcb.pid +" (quantum="+ QUANTUM +", quota="+ state.getQuota()+")");
		}
		else
			timer.set(0);
	}


	private void logQueues() {
		int i = 0;
		for (Queue<ProcessControlBlock<SchedulingState>> queue : this.readyQueues) {
			Logger.info("Queue " + i + ": " + queue);
			i++;
		}
		Logger.info("Blocked " + blockedQueue);
	}
}