import java.awt.AWTException;
import java.awt.Robot;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.*;


public class AllocateTask {
	
	private TaskList tasklist_list = null;
	private TreeMap<Long,Object> task =null;
	public static boolean task_finish = false; 
	
	
	public void allocate_task(TaskList tasklist) throws AWTException
	{
		//排序任务
		int i=0;
		Long  task_hash;
		Long  nodes_hash;
		SeverList serverlist = null;
		task = new TreeMap<Long,Object>();
		 Robot  r   =   new   Robot(); 
		tasklist_list = tasklist;
		//开始产生新的进程实时更新节点使用情况
		UpdateServer updatesever = new UpdateServer();
		updatesever.start();
		ExtremeTask extremtask=  new ExtremeTask();
		
		while(tasklist_list.getNext() != null)
		{
			tasklist_list = tasklist_list.getNext();
			
			task_hash = main_program.uniloop.hash(main_program.uniloop.computeMd5("task-" + (++i)),1);
			task.put(task_hash, tasklist_list);
			
			//System.out.println(tasklist_list.get_taskName()+":"+task_hash);
			
			//System.out.println(task_hash);
			//根据任务的的hash分配
			nodes_hash = this.getServerlistInfo(task_hash);
			serverlist = (SeverList) main_program.nodes.get(nodes_hash);
			
			//判断是不是极端任务
			if( extremtask.taskSolve(tasklist_list) )
			{
				continue;	
			}
			
			//轮训节点，看看那个可以，直到可以为之，若是没有就
			while(! isAllcate(serverlist,tasklist_list))
			{
				//为了防止不前进，出现死循环
				nodes_hash++;
				if(task_hash == nodes_hash)
				{
					System.out.println("出现死循环询问");
				}
				//System.out.println("节点已满内存，找下一个节点："+nodes_hash+"用于执行"+tasklist_list.get_taskName()+":" + tasklist_list.get_need_Memory());
				nodes_hash = this.getServerlistInfo(nodes_hash);
				serverlist = (SeverList) main_program.nodes.get(nodes_hash);
				//serverlist.print_server();
				//r.delay(100);
			}
			//分配成功，打印分配节点信息
			//System.out.println("任务："+tasklist_list.get_taskName()+"分配给："+serverlist.get_host_name());
			//serverlist.print_server();	
			//根据实时的内存的使用率来重新分配虚拟节点的权值，每分配10个任务一次
			if( i%50 == 0 )
			//if( false )
			{
				System.out.println("更新虚拟服务器环内节点比例");
				main_program.uniloop.loopInit(main_program.serverlist_head);
				main_program.nodes = main_program.uniloop.getHashnodes();
			}
		}
		//延时作用
		 r.delay(3000);
		 task_finish = true;
	}
	
	/**
	 * 判断任务是否能够执行，并为此任务生成多线程进行任务计算
	 * **/
	public boolean isAllcate(SeverList serverlist,TaskList tasklist_list)
	{
		//判断服务器能不能允许跑
		if(serverlist.isDispose)
		{
			serverlist.lock.lock();
				if( (serverlist.rest_Memory >=  tasklist_list.get_need_Memory()))
				{
					//serverlist.print_server();
					//调度多线程模拟任务执行
					serverlist.lock.unlock();
					
					serverlist.syntask.reduce_memory(serverlist, tasklist_list);
					
					TaskThread t = new TaskThread(serverlist,tasklist_list);
					t.start();
					
					return  true;
				}	 
			serverlist.lock.unlock();
			return false;
		}
		else
		{
			System.out.println("该服务器被锁了"+serverlist.get_host_name()+":"+serverlist.rate_memory);
			return false;
		}
		
	}
	

	
	 /**
     * 根据key的hash值取得最近服务器节点的hash值
     * @param hash
     * @return
     */
	public Long getServerlistInfo(long hash) {
        Long key = hash;
        //该方法调用返回此映射，其键大于或等于key的部分视图。就是返回大于或等于hash的所有key，value        
        SortedMap<Long,Object> tailMap=main_program.nodes.tailMap(key);
        
		if(tailMap.isEmpty()) {
			//返回第一个（最小那个hash）1
			
			key = main_program.nodes.firstKey();
		} else {
			key = tailMap.firstKey();
		}
        return key; 
    }
	/**
	 * 返回节点hash
	 * **/
	
}
