package com.nms.server.thread.mission;

import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import com.nms.server.bean.MissionResult2;
import com.nms.server.common.Common;
import com.nms.server.common.Constants;
import com.nms.server.dao.CommonDao;
import com.nms.server.service.UpgradeService;
import com.nms.server.util.BoneCPPool;
import com.nms.server.util.ExceptionPrintUtils;
import com.nms.server.util.StringUtil;


/**
 * 任务结果处理线程
 *  @date Nov 16, 2011 1:25:26 PM
 *	@author ZhangGang
 *
 */
public class MissionResultThread implements Runnable{
	private Logger logger = Logger.getLogger(MissionResultThread.class);
	private String name;
	volatile boolean stop = false;//线程是否被取消标志
	public MissionResultThread (String name){
		this.name= name;
	}
	public void run() {
		Thread.currentThread().setName(name);
		boolean upFlag = false;
		boolean loopFlag = false; 

		CommonDao dao = null;			//数据库链接
		try {
			dao = new CommonDao();
			UpgradeService service = new UpgradeService(dao);	//专属Service
			//-- 获取1-6 五种任务类型的结果集合，批量入库保存
			for(int i=1 ;i<=6&&!stop ; i++){
				try {
					//-- 获取结果集合
					LinkedList<MissionResult2> mr2List = Common.getResultListClone(i);
					
					//-- 集合不为空则进行解析 存在removeList情况 ，优化方式可参考 监测数据解析的实现方式
					if(mr2List!=null && mr2List.size()>0){
						upFlag = true;	// 开启任务是否完成的检查操作
						
						service.updateMissionResult2ByBatch(i,mr2List);		//保存mr2List中的数据
						Common.removeResultsFormList(i, mr2List);	//在Common中删除掉已保存的任务结果
						//更新mission_state_table表里的mission_state_desc字段（只对新录入结果的任务更新，没录入任务结果的任务不需要更新）
						service.updateCommonMissionStateDesc(i,mr2List);//i代表任务类型（1,4,6）-非周期任务
						if (i==4){
							loopFlag = true;	// 开启周期任务是否完成的检查操作
							service.updateLoopMissionStateDesc(mr2List);//更新任务类型4的周期任务的状态描述
						}
						
						dao.commit();
						mr2List.clear();	//清除mr2List
					}
				}catch (InterruptedException e) {
					logger.error("Task result data parsing thread is interrupted",e);
					stop = true;
				}catch (Exception e1) {
					logger.error("The task result data parsing thread ,which is abnormal when task type： "+i+" is parsed ,ends the entry of the result of this type of task,and continues to enter the result of the next type of task",e1);
				}
				
				//判断当前线程是否被中断
				if (Thread.currentThread().isInterrupted()) {
					// 线程中断状态，不会改变中断状态的值
					logger.info("任务结果数据解析线程 被中断");
					stop = true;
				}
			}
			
			//-- 任务执行进度校验，并更新已完成任务
			if(upFlag){
//				service.checkAndUpdateMissionComplete();//任务状态：完成（3）
				service.updateCommonMissionComplete();//任务状态：成功（31）、部分成功（32）、全部失败（30）
				if(loopFlag){
//					service.checkAndUpdateLoopMissionComplete();--此方法有问题
					service.updateLoopMissionComplete();
				}
			}			
			
			/**
			 * 针对过期未完成的【周期】任务进行清理（非周期任务不需要清理，因为没有结束时间endTime，所以不会超时）：
			 *     1.会不会重复添加过期任务呢？-不会，因为此处将结果加入缓存后，会先执行上面的结果录入，和任务状态的改变，再执行过期任务清理时，之前的过期任务的状态已修改为3或者7，不会被统计
			 *     2.清理时，将超时的任务（mission_state_table表中state=2或者6的，且endTime小于当前时间的）的结果存入缓存(Common.addResultToResultList)
			 *     3.对于过期的周期任务：
			 *        除了修改周期结果的状态（3->1），
			 *        还需要修改loopmission_state_table表的状态(2->3或者6->7,对于状态为0的不需要修改，因为界面不会显示？更新状态时也不会统计)，
			 *        及mission_state_table的状态(2->3或者6->7，对于1的情况，在初始化任务时，已经做过超时检查了，初始化后任务的状态变为2了就，所以此处不用对1的做超时检查)，
			 *        注：将过期周期任务结果存入缓存后，上面进行统计时，就会根据结果的状态，统计loop表的状态，及mission_state_table表的状态，所以步骤3的3个修改，我们只需要做第一步，将结果存入缓存
			 * 
			 */
			service.checkTimeoutLoopMisssionAndAddResult();
			
//			SimpleDateFormat format = new SimpleDateFormat("HH:mm:ss");
//			Date date = format.parse(Constants.MISSION_LOOP_FINISHING_DAILY);
//			System.out.println(format.format(new Date()));
//			if(loopFinishingFlag && ){
//				service.checkAndUpdateLoopMissionComplete();
//			}else{
//				
//			}
			
			/**
			 * 对于执行任务节点网络都不通的情况，第一周期之后就不会有结果入库，所以要定期的执行，不能加有周期结果入库的条件才操作
			 * 将下发失败的节点再次下发（包括部分不通及全部不通的所有任务）
			 */
			List<String> missIds = service.checkLoopMissAssignFail();//统计周期任务中，执行节点全都不通的情况			
			if(missIds!=null && missIds.size()>0) {
				Common.addAllAssignFailMissionIds(missIds);
			}
			String[] idsTmp = new String[0];
			idsTmp = Common.getAssignFailMissIds().toArray(idsTmp);
			String assignFailMissionIds = StringUtil.linkToString(idsTmp, ",", "");				
			
			if(StringUtils.isNotBlank(assignFailMissionIds)) {
				//下发的时候会过滤，只下发result=3的
				Common.scheduled.schedule(new InitRunningMissionThread(assignFailMissionIds),Constants.MISSION_FIRST_START, TimeUnit.SECONDS);								
				Common.removeAllAssignFailMissionIds();
			}
		} catch (Exception e) {
			logger.error(ExceptionPrintUtils.printExceptionStack(e));
			try {
				if(dao!=null)dao.rollback();
			} catch (Exception e1) {
				logger.error(ExceptionPrintUtils.printExceptionStack(e1));
			}
		}finally{
			if(dao!=null){
				dao.close();
				dao=null;
			}
		}
	}
	
	public static void main(String[] args) {
//		LinkedList<String> lks = new LinkedList<String>();
//		lks.add("1");
//		lks.add("2");
//		lks.add("3");
//		
//		LinkedList<String> lks2 = null;
//		lks2 = (LinkedList<String>)lks.clone();
//		for(String s:lks2) {
//			System.out.println(s);
//		}
//		
//		lks.add("4");
//		lks.set(0, "00");
//		
//		lks2.remove(0);
//		for(String s:lks2) {
//			System.out.println(s);
//		}
//		
//		for(String s:lks) {
//			System.out.println(s);
//		}
		String data = "2695$@$4$@$58$@$0$@$1365574748735$@$1365574761781$@$$@$1$@$执行失败，详细信息如下：执行“/home/xian/hello.sh”失败，结果文件“/home/xian/3.txt”不存在;";
		CommonDao dao = null;			//数据库链接
		try {
//			String [] result = data.split(Constants.COMMON_DATA_SPLIT);
//			MissionResult2 result2 = Common.resoveMissionResult(result);
//			Common.addResultToResultList(result2);
//			
//			Common.service.submit(new MissionResultThread("test"));
			BoneCPPool.initPool();
			dao = new CommonDao();
			UpgradeService service = new UpgradeService(dao);	//专属Service
			
//			service.checkTimeoutLoopMisssionAndAddResult();
			
			List<String> missIds = service.checkLoopMissAssignFail();//统计周期任务中，执行节点全都不通的情况
			
			if(missIds!=null && missIds.size()>0) {
				Common.addAllAssignFailMissionIds(missIds);
			}
			
			Common.addAssignFailMissionIds("5122");
			
			String[] idsTmp = new String[0];
			idsTmp = Common.getAssignFailMissIds().toArray(idsTmp);
			String assignFailMissionIds = StringUtil.linkToString(idsTmp, ",", "");				
			
			if(StringUtils.isNotBlank(assignFailMissionIds)) {
				//下发的时候会过滤，只下发result=3的
				Common.scheduled.schedule(new InitRunningMissionThread(assignFailMissionIds),Constants.MISSION_FIRST_START, TimeUnit.SECONDS);								
				Common.getAssignFailMissIds().clear();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
//		
//		Future<?> future2 = Common.service.submit(new MissionResultThread("任务结果入库线程"));
//		Common.getFutureMap().put(Constants.MISSION_RESULT_RESOVE, future2);
//		
//		System.out.println("启动ok。。。");
//		
//		Future<?> future = Common.getFutureMap().get(Constants.MISSION_RESULT_RESOVE);
//		System.out.println(future.isCancelled());
//		System.out.println(future.isDone());
//		try
//		{
////			Thread.sleep(1000);
//			if(future!=null&&!future.isCancelled()&&!future.isDone()) {
//					System.out.println("开始中断。。。");
//					Thread.sleep(536);//这个时间是经过多次测试出来的
//	//				Thread.sleep(100);
//					future.cancel(true);//停解析任务结果数据入库线程
//			}
//			Thread.sleep(3000);
//			Common.service.shutdownNow();
//			System.out.println(future.isCancelled());
//			System.out.println(future.isDone());
//		} catch (InterruptedException e)
//		{
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
//		
	}
	
}
