潘钊 / bsth_control · Files

package com.bsth.service.realcontrol.buffer;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.bsth.entity.realcontrol.ScheduleRealInfo;
import com.google.common.collect.ArrayListMultimap;

/**
 * 
 * @ClassName: ScheduleRealInfoBuffer 
 * @Description: TODO(当天实际排班缓存) 
 * @author PanZhao
 * @date 2016年6月14日 上午9:40:38 
 *
 */
public class ScheduleBuffer {
	
	static Logger logger = LoggerFactory.getLogger(ScheduleBuffer.class);
	
	/**
	 * 当天实际排班   K 线路编码 V 按时间升序的班次
	 */
	public static ArrayListMultimap<String, ScheduleRealInfo> realSchedulListMap;
	
	/**
	 * K: 车辆自编号  V: 未完成班次链表
	 */
	/*public static Map<String, LinkedList<ScheduleRealInfo>> vehLinkedMap;*/
	
	/**
	 * K: 车辆自编号  V: 班次链表
	 */
	public static ArrayListMultimap<String, ScheduleRealInfo> carSchListMap;
	/*public static Map<String, LinkedList<ScheduleRealInfo>> vehSchLinkedMap;*/
	
	
	/**
	 * K: 车辆自编号  V: 已执行班次链表
	 */
	/*public static LinkedListMultimap<String, ScheduleRealInfo> finishLinkedMap;*/
	
	
	/**
	 * 主键 和 排班映射
	 */
	public static Map<Long, ScheduleRealInfo> pkSchedulMap;
	
	/**
	 * 需要持久化的排班
	 */
	public static LinkedList<ScheduleRealInfo> persistentList;
	
	/** K: 线路编码_上下行  V: 班次平均间隔时间
	public static Map<String , Long> schSpaceMap; */
	
	/**
	 * 线路是否托管  K：线路编码  V：0 托管  1 非托管
	 */
	public static Map<Integer, Integer> trustMap; 
	
	static ScheduleComparator scheduleComparator = new ScheduleComparator();
	
	static final Long DAY_TIME = 1000 * 60 * 60 * 24L;
	
	static{
		clear();
	}
	
	public static void clear(){
		realSchedulListMap = ArrayListMultimap.create();
		pkSchedulMap = new HashMap<>();
		persistentList = new LinkedList<>();
		/*vehLinkedMap = new HashMap<>();
		finishLinkedMap = LinkedListMultimap.create();*/
		carSchListMap = ArrayListMultimap.create();
		trustMap = new HashMap<>();
	}
	
	public static int init(List<ScheduleRealInfo> list){
		SimpleDateFormat sdfyyyyMMdd = new SimpleDateFormat("yyyy-MM-dd");
		
		try{
			//计算时间戳
			for(ScheduleRealInfo schedul : list){
				//真实日期默认是排班日期
				schedul.setRealExecDate(sdfyyyyMMdd.format(schedul.getScheduleDate()));
				schedul.syncTime();
			}
			
			//发车顺序号排序
			Collections.sort(list, scheduleComparator);
			
			String zbh;
			for(ScheduleRealInfo schedul : list){
				
				realSchedulListMap.put(schedul.getXlBm(), schedul);
				pkSchedulMap.put(schedul.getId(), schedul);
				
				//初始化车辆和班次列表对照
				zbh = schedul.getClZbh();
				carSchListMap.put(zbh, schedul);
			}
			
			//计算真实计划发车时间
			calcRealOutTime();
			
			//计算起点应到时间
			Set<String> lineCodes = realSchedulListMap.keySet();
			for(String lineCode : lineCodes)
				calcArrDateQd(lineCode);
			
			//标记停车场既是起点站的班次
			Set<String> cars = carSchListMap.keySet();
			for(String nbbm : cars)
				markParkIsFirstStation(nbbm);
			
			//markParkIsFirstStation
			
			//计算班次平均间隔
			//calcAvgSpace();
			
		}catch(Exception e){
			logger.error("缓存排班数据失败...", e);
			return -1;
		}
		return 0;
	}
	
	private static void calcRealOutTime() {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Set<String> keys = carSchListMap.keySet();
		
		List<ScheduleRealInfo> list;
		ScheduleRealInfo schedule;
		for(String key : keys){
			list = carSchListMap.get(key);
			
			//发车顺序号排序
			Collections.sort(list, scheduleComparator);
			for(int i = 0; i < list.size(); i ++){
				schedule = list.get(i);
				if(i > 0 && schedule.getFcsjT() < list.get(i - 1).getFcsjT()){
					//加一天
					schedule.setFcsjAll(schedule.getFcsjT() + DAY_TIME);
					schedule.setRealExecDate(sdf.format(new Date(schedule.getFcsjT())));
					schedule.syncTime();
				}
			}
		}
	}
	
	/**
	 * 
	 * @Title: markParkIsFirstStation 
	 * @Description: TODO(标记停车场即首发站的班次) 
	 * @throws
	 */
	public static void markParkIsFirstStation(String nbbm){
		List<ScheduleRealInfo> list = carSchListMap.get(nbbm);
		
		String type;
		for(ScheduleRealInfo sch : list){
			type = sch.getBcType();
			if(!type.equals("out") && !type.equals("in"))
				continue;
			
			for(ScheduleRealInfo sch2 : list){
				
				if(sch.getId() == sch2.getId())
					continue;
				
				if(sch.getFcsjT().equals(sch2.getFcsjT())//出场，发车时间一致
						|| sch.getFcsjT().equals(sch2.getZdsjT())//进场，上一班次站点时间为进场起点时间
						){
					sch.setParkIsFirstStation(true);
					sch2.setFirstStationIsPark(true);
					//做双休关联
					sch2.setTwins(sch);
					sch.setTwins(sch2);
					break;
				}
			}
		}
	}

	//计算平均间隔
/*	public static void calcAvgSpace(){
		schSpaceMap = new HashMap<>();
		Set<String> set = realSchedulListMap.keySet();
		
		List<ScheduleRealInfo> list = null
				,upList = null
				,downList =  null;
		for(String lineCode : set){
			list = realSchedulListMap.get(lineCode);
			Long sumUp = 0L, sumDown = 0L;
			
			upList = new ArrayList<>();
			downList = new ArrayList<>();
			//按上下行分组
			for(ScheduleRealInfo sch : list){
				if(sch.getXlDir().equals("0"))
					upList.add(sch);
				else
					downList.add(sch);
			}
			for(int i = 1; i < upList.size(); i ++){
				sumUp += (upList.get(i).getFcsjT() - upList.get(i - 1).getFcsjT());
			}
			
			for(int i = 1; i < downList.size(); i ++){
				sumDown += (downList.get(i).getFcsjT() - downList.get(i - 1).getFcsjT());
			}
			
			schSpaceMap.put(lineCode + "_0", sumUp / upList.size());
			schSpaceMap.put(lineCode + "_1", sumDown / downList.size());
		}
	}*/
	
	public static int put(ScheduleRealInfo sch){
		realSchedulListMap.put(sch.getXlBm(), sch);
		
		pkSchedulMap.put(sch.getId(), sch);
		String zbh = sch.getClZbh();
		carSchListMap.put(zbh, sch);
		
		//List<ScheduleRealInfo> list = vehSchListMap.get(sch.getClZbh());
		
		/*if(!vehLinkedMap.containsKey(zbh))
			vehLinkedMap.put(zbh, new LinkedList<ScheduleRealInfo>());
		vehLinkedMap.get(zbh).add(sch);*/
		
		//重新排序
		Collections.sort(realSchedulListMap.get(sch.getXlBm()), scheduleComparator);
		//Collections.sort(vehSchListMap.get(zbh), scheduleComparator);
		
		//重新计算应到时间
		calcArrDateQd(carSchListMap.get(zbh));
		return 0;
	}
	
	public static class ScheduleComparator implements Comparator<ScheduleRealInfo>{

		@Override
		public int compare(ScheduleRealInfo o1, ScheduleRealInfo o2) {
			//return (int) (o1.getFcsjT() - o2.getFcsjT());
			return o1.getFcno() - o2.getFcno();
		}
	}
	
	/**
	 * 
	 * @Title: finishSch 
	 * @Description: TODO(完成一个班次) 
	 * @param @param sch
	 * @return ScheduleRealInfo  返回 下一个未执行的班次
	 * @throws
	 */
	public static ScheduleRealInfo finishSch(ScheduleRealInfo sch){
		//LinkedList<ScheduleRealInfo> list = vehLinkedMap.get(sch.getClZbh());
		//状态修改为已执行
		sch.setStatus(2);
		persistentList.add(sch);
		
		//下一个班次
		ScheduleRealInfo next = getNext(sch);
		if(next != null)
			next.setQdzArrDateSJ(sch.getZdsjActual());
		/*ScheduleRealInfo temp;
		int len = list.size();
		for(int i = 0; i < len; i ++){
			temp = list.poll();
			if(temp.equals(sch)){
				//加入已执行
				finishLinkedMap.put(sch.getClZbh(), sch);
				break;
			}
		}
		ScheduleRealInfo next = list.getFirst();*/
		//next.setQdzArrDateSJ(sch.getZdsjActual());
		return next;
	}
	
	public static ScheduleRealInfo getNext(ScheduleRealInfo sch){
		List<ScheduleRealInfo> list = carSchListMap.get(sch.getClZbh());
		
		boolean flag = false;
		ScheduleRealInfo next = null;
		for(ScheduleRealInfo temp : list){
			if(temp.getId() == sch.getId()){
				flag = true;
				continue;
			}
			//忽略烂班
			if(temp.getStatus() == -1)
				continue;
			
			if(flag){
				next = temp;
				break;
			}
		}
		
		
		/*int size = list.size();
		for(int i = 0; i < size; i ++){
			current = list.get(i);
			if(current.getId() == sch.getId()
					&& i < (size - 1)){
				next = list.get(i + 1);
				break;
			}
		}*/
		return next;
	}
	
	/**
	 * 
	 * @Title: getFinishSchNo 
	 * @Description: TODO(获取车辆已完成的班次数) 
	 * @param @param nbbm
	 * @throws
	 */
	public static int getFinishSchNo(String nbbm){
		List<ScheduleRealInfo> list = carSchListMap.get(nbbm);
		int no = 0;
		for(ScheduleRealInfo sch : list){
			if(sch.getStatus() == 2)
				no ++;
		}
		return no;
		//return finishLinkedMap.get(nbbm) == null ? 0 : finishLinkedMap.get(nbbm).size();
	}
	
	/**
	 * 
	 * @Title: findCurrent 
	 * @Description: TODO(获取车辆当前正在执行的班次) 
	 * @param @param nbbm
	 * @throws
	 */
	public static ScheduleRealInfo findCurrent(String nbbm){
		List<ScheduleRealInfo> list = ScheduleBuffer.carSchListMap.get(nbbm);
		
		int size = list.size();
		ScheduleRealInfo sch;
		//最后一个状态为 正在执行的班次
		for(int i = size - 1; i > 0; i --){
			sch = list.get(i);
			if(sch.getStatus() == 1)
				return sch;
		}
		return null;
	}
	
	/**
	 * 
	 * @Title: findNextList 
	 * @Description: TODO(获取后续班次) 
	 * @param @param sch
	 * @throws
	 */
	public static List<ScheduleRealInfo> findNextList(ScheduleRealInfo sch){
		List<ScheduleRealInfo> list = carSchListMap.get(sch.getClZbh()),
					rs = null;
		
		for(ScheduleRealInfo temp : list){
			if(temp.getId() == sch.getId())
				rs = new ArrayList<>();
			
			if(rs != null)
				rs.add(temp);
		}
		return rs == null?new ArrayList<ScheduleRealInfo>():rs;
	}
	
	public static void calcArrDateQd(List<ScheduleRealInfo> list){
		//排序
		Collections.sort(list, scheduleComparator);
		int len = list.size();
		if(len == 0)
			return;
		
		ScheduleRealInfo prve = list.get(0), curr;
		for(int i = 1; i < len; i ++){
			curr = list.get(i);
			if(prve.getZdzName().equals(curr.getQdzName()))
				curr.setQdzArrDateJH(prve.getZdsj());
			
			prve = curr;
		}
	}
	
	/**
	 * 
	 * @Title: calcArrDateQd 
	 * @Description: TODO(计算计划起点时间) 
	 * @throws
	 */
	public static void calcArrDateQd(String lineCode){
		List<ScheduleRealInfo> list = realSchedulListMap.get(lineCode);
		//按车辆分组
		ArrayListMultimap<String, ScheduleRealInfo> map = ArrayListMultimap.create();
		for(ScheduleRealInfo sch : list){
			map.put(sch.getClZbh(), sch);
		}
		
		//链接班次
		Set<String> set = map.keySet();
		for(String k : set){
			calcArrDateQd(map.get(k));
		}
	}
	
	public static ScheduleRealInfo findOne(Long id){
		return pkSchedulMap.get(id);
	}
	
	public static List<ScheduleRealInfo> findByLineAndUpDown(Integer lineCode, Integer upDown){
		List<ScheduleRealInfo> list = realSchedulListMap.get(String.valueOf(lineCode))
				,subList = new ArrayList<>();
		//按走向过滤
		for(ScheduleRealInfo sch : list){
			if(Integer.parseInt(sch.getXlDir()) == upDown){
				subList.add(sch);
			}
		}
		return subList;
	}
	
	public static ScheduleRealInfo getFirst(String nbbm){
		List<ScheduleRealInfo> list = carSchListMap.get(nbbm);
		if(list.size() > 0)
			return list.get(0);
		else
			return null;
	}
}