package test.testSOP;

import gridsim.dcworms.DCWormsTags;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;

import org.apache.commons.logging.Log;

import dcworms.schedframe.scheduling.ExecTask;

import schedframe.resources.computing.Node;
import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName;
import schedframe.scheduling.manager.resources.ClusterResourceManager;
import schedframe.scheduling.manager.tasks.JobRegistry;

public class Utility {
	public static int NUMBER_HOST_PIVOT = 1;
	public static String HOST_NUMBER_PATH = "src/test/testSOP_results/data/expectedHostNumber.txt";
	
	
	//Retrieve nodes by powerstateNames
	public static List<Node> getNodesByPowerState(List<Node> nodes, StandardPowerStateName psName) {
		ArrayList<Node> nodelist = new ArrayList<Node>();
		for (Node n : nodes) {
			if (n.getPowerInterface().getPowerState().equals(psName)) {
				nodelist.add(n);
			}
		}
		return nodelist;
	}

	
	public static int getExpectedHostNumber(JobRegistry jr, ClusterResourceManager resourceManager, Log log) {
		float cpuReq = 0;
		float memReq = 0;

		synchronized(jr.getTasks()) {
			for (ExecTask t : jr.getTasks()) {
	
				if (t.getStatus() != DCWormsTags.SUCCESS && t.getStatus() != DCWormsTags.FAILED
						&& t.getStatus() != DCWormsTags.CANCELED) {
	
					try {
						cpuReq += t.getCpuCntRequest();
						memReq += t.getMemoryRequest();
					} catch (NoSuchFieldException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
		}
		// Compute total capacity
		List<Node> nodes = resourceManager.getNodes();
		float cpuCapacity = 0;
		float memCapacity = 0;
		for (Node n : nodes) {
			try {
				cpuCapacity += n.getProcessorsNumber();
				memCapacity += n.getTotalMemory();
			} catch (NoSuchFieldException e) {
				e.printStackTrace();
			}
		}
		// log.debug("CPU capacity = "+cpuCapacity);
		// log.debug("MEM capacity = "+memCapacity);
		//log.debug("CPU req = " + cpuReq);
		//log.debug("MEM req = " + memReq);
		float averageHostCPUCapacity = cpuCapacity / (float) nodes.size();
		float averageHostMEMCapacity = memCapacity / (float) nodes.size();
		//log.debug("avgMaxHostCPUCapacity = " + averageHostCPUCapacity);
		//log.debug("averageHostMEMCapacity = " + averageHostMEMCapacity);
		int expectedHostNumberCPU = (int) (cpuReq / averageHostCPUCapacity);
		int expectedHostNumberMEM = (int) (memReq / averageHostMEMCapacity);
		int expectedHostNumber = Math.max(expectedHostNumberCPU, expectedHostNumberMEM);
		// log.debug("Expecting needing max ("+expectedHostNumberCPU+","+expectedHostNumberMEM+") Nodes");

		expectedHostNumber = expectedHostNumber + Utility.NUMBER_HOST_PIVOT;
		log.debug("Host to be on : " + expectedHostNumber);
		//
		// PrintWriter writer = null;
		// try {
		// writer = new PrintWriter(new FileWriter(HOST_NUMBER_PATH, true));
		// writer.println(String.format("%d", expectedHostNumber));
		// writer.close();
		// } catch (IOException e) {
		// e.printStackTrace();
		// } finally {
		// writer.close();
		// }
		return expectedHostNumber;
	}
	
	public static int getAllRunningTasks(JobRegistry jr) {
		int nb = 0;
		synchronized(jr.getTasks()) {
			for (ExecTask t : jr.getTasks()) {
				
				if (t.getStatus() != DCWormsTags.SUCCESS && t.getStatus() != DCWormsTags.FAILED && t.getStatus() != DCWormsTags.CANCELED) {
					nb++;
				}
			}
		}
		return nb;
	}
	
	public static void manageHosts(JobRegistry jr, ClusterResourceManager resourceManager, Log log) {
		List<Node> nodes = resourceManager.getNodes();
		int expectedHostNumber = getExpectedHostNumber(jr, resourceManager, log);

		//Counting ON and BOOT hosts
		int nbOnHosts = 0;
		int nbBootingHosts = 0;
		for (Node n : nodes) {
			if (n.getPowerInterface().getPowerState().equals(StandardPowerStateName.ON)) {
				nbOnHosts++;
			}
			if (n.getPowerInterface().getPowerState().equals(StandardPowerStateName.BOOT)) {
				nbBootingHosts++;
			}
		}
		synchronized(jr.getTasks()) {
			for (ExecTask t : jr.getTasks()) {
	
				if (t.getStatus() != DCWormsTags.SUCCESS && t.getStatus() != DCWormsTags.FAILED
						&& t.getStatus() != DCWormsTags.CANCELED) {
					log.debug(t.getJobId()+ " is still running");
				}
			}
		}
		log.debug("");
		//log.debug("There is "+(nbOnHosts+nbBootingHosts)+" powered ON("+nbOnHosts+") or BOOTING("+nbBootingHosts+")");
		int nbTotal = nbOnHosts+nbBootingHosts;
		
		PrintWriter writer = null;
		try {
			writer = new PrintWriter(new FileWriter(HOST_NUMBER_PATH, true));
			writer.println(String.format("%d\t%d", nbOnHosts, expectedHostNumber));
			log.debug("Wrote in HOST_NUMBER_PATH: "+HOST_NUMBER_PATH);
			writer.close();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			writer.close();
		}
		
		//We have to power on a host
		if (nbTotal < expectedHostNumber) {
			//log.debug("nbOnHosts < expectedHostNumber : We have to power on a host");
			Node n = findNodeToPowerON(resourceManager, log);
//			ArrayList<Node> nList = findNodeListToPowerON(resourceManager, log);
			if(n != null) {
				//log.debug("Powering ON node "+n.getName());
//				n.getPowerInterface().setPowerState(StandardPowerStateName.ON);
				n.getPowerInterface().turnOn();
			}
		}
		//We have to power off hosts
		else if (nbTotal > expectedHostNumber) {
			log.debug("nbOnHosts > expectedHostNumber : We have to power off hosts");
//			Node n = findNodeToPowerOFF(resourceManager, log);
			ArrayList<Node> nList = findNodeListToPowerOFF(resourceManager, log);
			if (nList!= null) {
				log.debug("Half the hosts nb is :"+Math.ceil((float)nList.size()/(float)2));
				for(int i = 0 ; i<Math.ceil((float)nList.size()/(float)2) ; i++) {
					//log.debug("Powering OFF node " +nList.get(i).getName());
					nList.get(i).getPowerInterface().turnOff();
				}
			}
		}
		//We do nothing
		else {
			log.debug("The right number of hosts, do nothing");
		}
	}
	
	//Find all nodes that we can power off
	private static ArrayList<Node> findNodeListToPowerOFF(ClusterResourceManager resourceManager, Log log) {
		List<Node> nodes = resourceManager.getNodes();
		ArrayList<Node> nodeList = new ArrayList<Node>();
		for (Node n : nodes) {
			if (n.getPowerInterface().getPowerState().equals(StandardPowerStateName.ON)) {
				if (nodeIsEmpty(n, log)) {
					nodeList.add(n);
				}
			}
		}
		if (nodeList.size() == 0) {
			log.debug("findNodeToPowerOFF() : no host found");
			return null;
		}
		else {
			return nodeList;
		}
	}


	/**
	 * Finds empty node to power off
	 * @param resourceManager
	 * @return
	 */
	//TODO: Find best node to poweroff, sort list?
	private static Node findNodeToPowerOFF(ClusterResourceManager resourceManager, Log log) {
		List<Node> nodes = resourceManager.getNodes();
		for (Node n : nodes) {
			if (n.getPowerInterface().getPowerState().equals(StandardPowerStateName.ON)) {
				if (nodeIsEmpty(n, log)) {
					return n;
				}
			}
		}
		log.debug("findNodeToPowerOFF() : no host found");
		return null;
	}

	/**
	 * Find first node to power ON
	 * @param resourceManager
	 * @return
	 */
	//TODO: Find best node to powerOn, sort list?
	private static Node findNodeToPowerON(ClusterResourceManager resourceManager, Log log) {
		List<Node> nodes = resourceManager.getNodes();
		for (Node n : nodes) {
			if (n.getPowerInterface().getPowerState().equals(StandardPowerStateName.OFF))
				return n;
		}
		//log.debug("findNodeToPowerON() : no host found");
		return null;
	}

	public static boolean nodeIsEmpty(Node n, Log log) {
		try {
			boolean ret =  (n.getFreeMemory() == n.getTotalMemory()) && (n.getFreeProcessorsNumber() == n.getProcessorsNumber());
			if (ret == false) {
				//log.debug("FreeMEM: "+n.getFreeMemory()+" // TotalMEM : " +n.getTotalMemory());
			}
			return ret;
		} catch (NoSuchFieldException e) {
			e.printStackTrace();
		}
		return false;
	}


	public static void deleteFile(String path, Log log) {
		//Delete migration file
		File file = new File(path);
		if (file.delete()) {
			log.debug("Successfully deleted file "+path);
		}
		else {
			log.debug("Failed to delete file "+path);
		}
		
	}
	
	/**
	 * Executes an external python program
	 * @param path path to executable
	 */
	public static void executeExternalProgram(String path) {
		ProcessBuilder pb = new ProcessBuilder("python",path);
		try {
			Process p = pb.start();
			p.waitFor();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}