潘钊 / bsth_control · Files

package com.bsth.data.schedule;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.bsth.common.Constants;
import com.bsth.common.ResponseCode;
import com.bsth.data.LineConfigData;
import com.bsth.data.gpsdata_v2.GpsRealData;
import com.bsth.data.gpsdata_v2.utils.GpsDataRecovery;
import com.bsth.data.schedule.f_a_l.FirstAndLastHandler;
import com.bsth.entity.realcontrol.LineConfig;
import com.bsth.entity.realcontrol.ScheduleRealInfo;
import com.bsth.entity.report.RepairReport;
import com.bsth.entity.schedule.SchedulePlanInfo;
import com.bsth.repository.realcontrol.ScheduleRealInfoRepository;
import com.bsth.service.schedule.SchedulePlanInfoService;
import com.bsth.websocket.handler.SendUtils;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.ListMultimap;
import com.google.common.collect.Multimaps;
import org.apache.commons.lang3.StringUtils;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.jdbc.core.BatchPreparedStatementSetter;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Component;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ConcurrentMap;

/**
 * @author PanZhao
 * @ClassName: DayOfSchedule
 * @Description: TODO(当日实际排班)
 * @date 2016年8月15日 上午10:16:12
 */
@Component
public class DayOfSchedule {

    Logger logger = LoggerFactory.getLogger(this.getClass());

    //按线路分组的 “原始计划” 排班数据
    public static Map<String, List<SchedulePlanInfo>> schedulePlanMap;

    // 按车辆索引的班次数据
    private static ListMultimap<String, ScheduleRealInfo> nbbmScheduleMap;

    // 按营运公司索引的班次数据
    private static ListMultimap<String, ScheduleRealInfo> gsBmScheduleMap;

    //按线路索引计划用车
    private static HashMultimap<String, String> lineNbbmsMap;

    //按路牌索引班次数据 线路编码_路牌名称 ——> 班次list
    private static ArrayListMultimap<String, ScheduleRealInfo> lpScheduleMap;

    // 班次主键映射
    private static ConcurrentMap<Long, ScheduleRealInfo> id2SchedulMap;

    //车辆 ——> 当前执行班次
    private static ConcurrentMap<String, ScheduleRealInfo> carExecutePlanMap;

    // 持久化
    public static ConcurrentLinkedQueue<ScheduleRealInfo> pstBuffer;

    // 排序器
    private static ScheduleComparator.FCSJ schFCSJComparator;

    private static ScheduleComparator.DFSJ schDFSJComparator;

    private static Long sch_max_id=-1L;

    private Map<String, RepairReport> incode2report = new ConcurrentHashMap<String, RepairReport>();

    @Autowired
    LineConfigData lineConfigData;

    @Autowired
    ScheduleRealInfoRepository schRepository;

    @Autowired
    SchedulePlanInfoService schPlanService;

    @Autowired
    SchAttrCalculator schAttrCalculator;

    @Autowired
    SendUtils sendUtils;

    @Autowired
    GpsRealData gpsRealData;

    /**
     * 线路当前使用的排班的日期
     */
    public static Map<String, String> currSchDateMap;

    static {
        nbbmScheduleMap = ArrayListMultimap.create();
        nbbmScheduleMap = Multimaps.synchronizedListMultimap(nbbmScheduleMap);

        gsBmScheduleMap = ArrayListMultimap.create();
        lpScheduleMap = ArrayListMultimap.create();
        lineNbbmsMap = HashMultimap.create();

        id2SchedulMap = new ConcurrentHashMap<>();
        pstBuffer = new ConcurrentLinkedQueue<>();
        schFCSJComparator = new ScheduleComparator.FCSJ();
        schDFSJComparator = new ScheduleComparator.DFSJ();
        currSchDateMap = new HashMap<>();
        carExecutePlanMap = new ConcurrentHashMap<>();

        schedulePlanMap = new HashMap<>();
    }

    @Autowired
    LineConfigData lineConfigs;

    @Autowired
    GpsDataRecovery gpsDataRecovery;

    private static DateTimeFormatter fmtyyyyMMdd = DateTimeFormat.forPattern("yyyy-MM-dd"), fmtHHmm = DateTimeFormat.forPattern("HH:mm");

    //数据恢复
    public void dataRecovery() {
        Collection<LineConfig> confs = lineConfigs.getAll();
        String lineCode, currSchDate;
        for (LineConfig conf : confs) {
            lineCode = conf.getLine().getLineCode();
            currSchDate = calcSchDate(lineCode);
            //加载班次数据
            reloadSch(lineCode, currSchDate, false);
        }

        //恢复gps数据
        gpsDataRecovery.recovery();
    }

    public Map<String, String> getCurrSchDate() {
        return currSchDateMap;
    }

    /**
     * @Title: calcSchDateB
     * @Description: TODO(计算线路当前应该使用的排班日期)
     */
    public String calcSchDate(String lineCode) {
        Long t = System.currentTimeMillis();
        LineConfig conf = lineConfigData.get(lineCode);

        // 小于当天起始运营时间,则取前一天的排班
        String ct = fmtHHmm.print(t);
        if(ct.compareTo(conf.getStartOpt()) < 0)
            t -= 1000 * 60 * 60 * 24;

        String schDate = fmtyyyyMMdd.print(t);
        return schDate;
    }

    /**
     * @param @param lineCode 线路编码
     * @param @param schDate 班次日期 yyyy-MM-dd
     * @param @param forcePlan 强制从计划调度重新抓取
     * @Title: reloadSch
     * @Title: reloadSch
     * @Description: TODO(重新载入排班)
     */
    public int reloadSch(String lineCode, String schDate, boolean forcePlan) {
        try {
            List<ScheduleRealInfo> list;

            if (forcePlan)
                removeRealSch(lineCode, schDate);
            else
                clearRAMData(lineCode);

            if (existRealSch(lineCode, schDate))
                list = loadRealSch(lineCode, schDate);// 从实际排班表加载
            else {
                list = loadPlanSch(lineCode, schDate);// 从计划排班表加载
                // 写入数据库
                batchSave(list);
            }

            //更新线路和班次日期对照
            currSchDateMap.put(lineCode, schDate);
            //添加到缓存
            putAll(list);

            //标记首末班
            FirstAndLastHandler.marks(list);

            Set<String> lps = searchAllLP(list);
            for (String lp : lps) {
                //计算“起点站应到”时间
                schAttrCalculator.calcQdzTimePlan(lpScheduleMap.get(lineCode + "_" + lp));
            }
            Set<String> cars = searchAllCars(list);
            for (String nbbm : cars) {
                //车辆 ——> 要执行的班次对照
                reCalcExecPlan(nbbm);
            }

            //分组计划用车
            reCalcLineNbbms();
            // 页面 翻班通知
            //sendUtils.shiftSchedule(lineCode);
        } catch (Exception e) {
            logger.error("", e);
            return -1;
        }

        return 0;
    }

    public int reloadSch(String lineCode) {
        return reloadSch(lineCode, calcSchDate(lineCode), true);
    }

    /**
     * @Title: searchAllCars
     * @Description: TODO(搜索班次集合中的车辆)
     */
    private Set<String> searchAllCars(List<ScheduleRealInfo> list) {
        Set<String> cars = new HashSet<>();
        for (ScheduleRealInfo sch : list)
            cars.add(sch.getClZbh());

        return cars;
    }

    /**
     * @Title: searchAllCars
     * @Description: TODO(搜索班次集合中的路牌)
     */
    private Set<String> searchAllLP(List<ScheduleRealInfo> list) {
        Set<String> lps = new HashSet<>();
        for (ScheduleRealInfo sch : list)
            lps.add(sch.getLpName());

        return lps;
    }

    private void putAll(List<ScheduleRealInfo> list) {
        for (ScheduleRealInfo sch : list)
            put(sch);
    }

    /**
     * @param @param lineCode 线路编码
     * @param @param schDate 班次日期 yyyy-MM-dd
     * @Title: removeRealSch
     * @Description: TODO(清除实际排班，包括数据库和内存数据)
     */
    public void removeRealSch(String lineCode, String schDate) throws Exception {
        try {
            // 清理数据库数据
            schRepository.deleteByLineCodeAndDate(lineCode + "", schDate);

            // 清理内存数据
            clearRAMData(lineCode + "");
        } catch (Exception e) {
            logger.error("removeRealSch error, " + lineCode + " -" + schDate, e);
            throw e;
        }
    }

    /**
     * @Title: clearRAMData
     * @Description: TODO(清理内存数据)
     */
    public void clearRAMData(String lineCode) {
        int count = 0;
        List<ScheduleRealInfo> remList = new ArrayList<>();
        Collection<ScheduleRealInfo> all = nbbmScheduleMap.values();
        for (ScheduleRealInfo sch : all) {
            if (sch.getXlBm().equals(lineCode))
                remList.add(sch);
        }

        for (ScheduleRealInfo sch : remList) {
            if (null != sch) {
                nbbmScheduleMap.remove(sch.getClZbh(), sch);
                id2SchedulMap.remove(sch.getId());
                count++;

                //清理路牌对照
                lpScheduleMap.removeAll(sch.getXlBm() + "_" + sch.getLpName());

                //清除车辆 ——> 执行班次对照
                carExecutePlanMap.remove(sch.getClZbh());
            }
        }
        //清理计划排班
        schedulePlanMap.remove(lineCode);

        remList.clear();
        remList = null;
        logger.info(lineCode + "排班清理 " + count);
    }

    /**
     * @Title: existRealSch
     * @Description: TODO(实际排班是否已存在)
     */
    public boolean existRealSch(String lineCode, String schDate) {
        int count = schRepository.countByLineCodeAndDate(lineCode, schDate);
        return count > 0;
    }

    /**
     * @Title: loadRealSch
     * @Description: TODO(从实际排班表加载数据)
     */
    public List<ScheduleRealInfo> loadRealSch(String lineCode, String schDate) {
        return schRepository.findByLineCodeAndDate(lineCode, schDate);
    }

    /**
     * @Title: loadPlanSch
     * @Description: TODO(从计划排班表加载数据)
     */
    public List<ScheduleRealInfo> loadPlanSch(String lineCode, String schDate) {
        //logger.info("从计划排班表恢复排班，lineCode: " + lineCode + ", schDate: " + schDate);
        List<ScheduleRealInfo> realList = new ArrayList<>();

        try {
            Map<String, Object> data = new HashMap<>();

            data.put("scheduleDate_eq", fmtyyyyMMdd.parseDateTime(schDate).toDate());
            data.put("xlBm_eq", lineCode);

            // 查询计划排班
            List<SchedulePlanInfo> planItr = cleanSchPlanItr(schPlanService.list(data).iterator());
            //保存一份原始计划排班数据
            schedulePlanMap.put(lineCode, planItr);

            // 转换为实际排班
            realList = JSONArray.parseArray(JSON.toJSONString(planItr), ScheduleRealInfo.class);
            logger.info("从计划排班表恢复排班，lineCode: " + lineCode + ", schDate: " + schDate + ", size:" + realList.size());

            Date d = new Date();
            SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");
            String fcsj;
            for (ScheduleRealInfo sch : realList) {
                sch.setScheduleDateStr(fmtyyyyMMdd.print(sch.getScheduleDate().getTime()));
                sch.setRealExecDate(sch.getScheduleDateStr());
                sch.setCreateDate(d);

                if (StringUtils.isEmpty(sch.getFcsj()))
                    sch.setFcsj("00:00");

                if (sch.getFcsj().equals("24:00"))
                    sch.setFcsj("23:59");

                if (sch.getFcsj().substring(0, 2).equals("24")) {
                    sch.setFcsj("00" + sch.getFcsj().substring(2));
                }

                fcsj = sch.getFcsj().trim();
                //处理一下发车时间格式没有:号的问题
                if (fcsj.indexOf(":") == -1 && fcsj.length() >= 4) {
                    sch.setFcsj(fcsj.substring(0, 2) + ":" + fcsj.substring(2, 4));
                }

                try {
                    sdf.parse(sch.getFcsj());
                } catch (ParseException e) {
                    //发车时间仍然校验不过的，直接写成00:00
                    sch.setFcsj("00:00");
                }
                sch.setDfsj(sch.getFcsj());

                // 计划终点时间
                if (sch.getBcsj() != null) {
                    sch.setZdsj(fmtHHmm.print(fmtHHmm.parseMillis(sch.getFcsj()) + (sch.getBcsj() * 60 * 1000)));
                    sch.setLate(false);
                }

                //售票员为空设置为""字符串
                if (StringUtils.isEmpty(sch.getsGh())) {
                    sch.setsGh("");
                    sch.setsName("");
                }
                sch.setJhlcOrig(sch.getJhlc());
                //保留备注
                if (StringUtils.isNotEmpty(sch.getRemark()))
                    sch.setRemarks(sch.getRemark());
            }
        } catch (Exception e) {
            logger.error("", e);
        }

        return realList;
    }


    public synchronized long getId(){
        if(sch_max_id==-1){
            sch_max_id = schRepository.getMaxId();
            if(null == sch_max_id)
                sch_max_id = 3000L;//留一点空间补数据用
            sch_max_id += 5;
        }
        else
            sch_max_id ++;
        return sch_max_id;
    }

    /**
     * @Title: batchSave
     * @Description: TODO(批量入库)
     */
    private void batchSave(List<ScheduleRealInfo> list) {
        SimpleDateFormat sdfyyyyMMdd = new SimpleDateFormat("yyyy-MM-dd");
        for (ScheduleRealInfo item : list) {
            item.setSpId(item.getId());// 保留原始的计划ID
            item.setId(getId());// 设置ID
            item.setScheduleDateStr(sdfyyyyMMdd.format(item.getScheduleDate()));
        }

        //编程式事务
        DataSourceTransactionManager tran = new DataSourceTransactionManager(jdbcTemplate.getDataSource());
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
        TransactionStatus status = tran.getTransaction(def);

        try{
            final List<ScheduleRealInfo> pstList = list;
            //写入
            jdbcTemplate.batchUpdate("insert into bsth_c_s_sp_info_real(id,bc_type,bcs,bcsj,cl_zbh,create_date,dfsj,directive_state,fcno,fcsj,fcsj_actual,j_gh,j_name,jhlc,lp_name,qdz_code,qdz_name,real_exec_date,remarks,s_gh,s_name,schedule_date,schedule_date_str,sflj,sp_id,status,update_date,xl_bm,xl_dir,xl_name,zdsj,zdsj_actual,zdz_code,zdz_name,ccno,df_auto,fgs_bm,fgs_name,gs_bm,gs_name,online,adjust_exps,reissue,jhlc_orig,sigin_compate,drift_status,cc_service,major_station_name,rfid_state,first_rfid_state)" +
                    " VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", new BatchPreparedStatementSetter() {
                @Override
                public void setValues(PreparedStatement ps, int i) throws SQLException {
                    ScheduleRealInfo sch = pstList.get(i);
                    ps.setLong(1, sch.getId());
                    ps.setString(2, sch.getBcType());
                    ps.setInt(3, sch.getBcs()==null?0:sch.getBcs());
                    ps.setInt(4, sch.getBcsj()==null?0:sch.getBcsj());
                    ps.setString(5, sch.getClZbh());
                    ps.setTimestamp(6, new java.sql.Timestamp(sch.getCreateDate().getTime()));
                    ps.setString(7, sch.getDfsj());
                    ps.setInt(8, sch.getDirectiveState());
                    ps.setInt(9, sch.getFcno()==null?0:sch.getFcno());
                    ps.setString(10, sch.getFcsj());
                    ps.setString(11, sch.getFcsjActual());
                    ps.setString(12, sch.getjGh());
                    ps.setString(13, sch.getjName());
                    ps.setDouble(14, sch.getJhlc());
                    ps.setString(15, sch.getLpName());
                    ps.setString(16, sch.getQdzCode());
                    ps.setString(17, sch.getQdzName());
                    ps.setString(18, sch.getRealExecDate());
                    ps.setString(19, sch.getRemarks());
                    ps.setString(20, sch.getsGh());
                    ps.setString(21, sch.getsName());
                    ps.setTimestamp(22, new java.sql.Timestamp(sch.getScheduleDate().getTime()));
                    ps.setString(23, sch.getScheduleDateStr());
                    ps.setBoolean(24, sch.isSflj());
                    ps.setLong(25, sch.getSpId());
                    ps.setInt(26, sch.getStatus());
                    ps.setTimestamp(27, new java.sql.Timestamp(sch.getUpdateDate().getTime()));
                    ps.setString(28, sch.getXlBm());
                    ps.setString(29, sch.getXlDir());
                    ps.setString(30, sch.getXlName());
                    ps.setString(31, sch.getZdsj());
                    ps.setString(32, sch.getZdsjActual());
                    ps.setString(33, sch.getZdzCode());
                    ps.setString(34, sch.getZdzName());
                    ps.setInt(35, sch.getCcno()==null?0:sch.getCcno());
                    ps.setBoolean(36, sch.isDfAuto());
                    ps.setString(37, sch.getFgsBm());
                    ps.setString(38, sch.getFgsName());
                    ps.setString(39, sch.getGsBm());
                    ps.setString(40, sch.getGsName());
                    ps.setBoolean(41, sch.isOnline());
                    ps.setString(42, sch.getAdjustExps());
                    ps.setBoolean(43, sch.isReissue());
                    ps.setDouble(44, sch.getJhlcOrig());
                    ps.setInt(45, sch.getSiginCompate());
                    ps.setInt(46, sch.getDriftStatus());
                    ps.setBoolean(47, sch.isCcService());
                    ps.setString(48, sch.getMajorStationName());
                    ps.setInt(49, sch.getRfidState());
                    ps.setInt(50, sch.getFirstRfidState());
                }

                @Override
                public int getBatchSize() {
                    return pstList.size();
                }
            });

            tran.commit(status);
        }catch (Exception e){
            tran.rollback(status);
            logger.error("real schedule batchSave error...", e);
        }
        // 入库
        //new BatchSaveUtils<ScheduleRealInfo>().saveList(list, ScheduleRealInfo.class);
    }

    public List<SchedulePlanInfo> cleanSchPlanItr(Iterator<SchedulePlanInfo> itrab) {
        List<SchedulePlanInfo> list = new ArrayList<>();

        SchedulePlanInfo sp;
        while (itrab.hasNext()) {
            sp = itrab.next();
            sp.setSchedulePlan(null);
            sp.setCreateBy(null);
            sp.setUpdateBy(null);
            list.add(sp);
        }
        return list;
    }

    /**
     * @Title: findByLineCode
     * @Description: TODO(lineCode 获取班次)
     */
    public List<ScheduleRealInfo> findByLineCode(String lineCode) {
        List<ScheduleRealInfo> rs = new ArrayList<>();

        Collection<ScheduleRealInfo> schs = nbbmScheduleMap.values();
        for (ScheduleRealInfo sch : schs) {
            if (sch.getXlBm().equals(lineCode))
                rs.add(sch);
        }
        return rs;
    }

    /**
     * @Title: findByLineCode
     * @Description: TODO(lineList 获取班次)
     */
    public Map<String, Collection<ScheduleRealInfo>> findByLineCodes(List<String> lineList) {
        ArrayListMultimap<String, ScheduleRealInfo> mMap = ArrayListMultimap.create();

        Collection<ScheduleRealInfo> schs = nbbmScheduleMap.values();
        for (ScheduleRealInfo sch : schs) {
            if (lineList.contains(sch.getXlBm())) {
                mMap.put(sch.getXlBm(), sch);
            }
        }
        return mMap.asMap();
    }

    /**
     * @Title: findCarByLineCode
     * @Description: TODO(线路下运营的车辆)
     */
    public Set<String> findCarByLineCode(String lineCode) {
        /*Set<String> rs = new HashSet<>();

        Collection<ScheduleRealInfo> schs = nbbmScheduleMap.values();
        for (ScheduleRealInfo sch : schs) {
            if (sch.getXlBm().equals(lineCode))
                rs.add(sch.getClZbh());
        }
*/
        return lineNbbmsMap.get(lineCode);
    }

    public List<ScheduleRealInfo> findByNbbm(String nbbm) {
        return nbbmScheduleMap.get(nbbm);
    }

    /**
     * @Title: findByLineAndUpDown
     * @Description: TODO(lineCode 和走向获取班次)
     */
    public List<ScheduleRealInfo> findByLineAndUpDown(String lineCode, Integer upDown) {
        List<ScheduleRealInfo> list = findByLineCode(lineCode), rs = new ArrayList<>();

        for (ScheduleRealInfo sch : list) {
            if (sch.getXlDir().equals(upDown + ""))
                rs.add(sch);
        }
        return rs;
    }

    public ScheduleRealInfo get(long id) {
        return id2SchedulMap.get(id);
    }


    /**
     * @Title: next
     * @Description: TODO(下一个班次)
     */
    public ScheduleRealInfo next(ScheduleRealInfo sch) {
        List<ScheduleRealInfo> list = nbbmScheduleMap.get(sch.getClZbh());
        //排序
        Collections.sort(list, schDFSJComparator);
        return next(list, sch);
    }


    /**
     * 下一个班次
     *
     * @param list 班次集合
     * @param sch  当前班次
     * @return
     */
    private ScheduleRealInfo next(Collection<ScheduleRealInfo> list, ScheduleRealInfo sch) {
        int outConfig = -1;
        LineConfig config = lineConfigData.get(sch.getXlBm());
        if (config != null)
            outConfig = config.getOutConfig();

        //限定出站既出场的停车场
        List<String> parks = config.findTwinsParkList();
        boolean limitPark = null != parks && parks.size() > 0;
        boolean flag = false;
        ScheduleRealInfo next = null;
        for (ScheduleRealInfo temp : list) {
            if (temp.getId() == sch.getId()) {
                flag = true;
                continue;
            }
            //忽略烂班
            if (temp.isDestroy())
                continue;

            //出站既出场，忽略出场班次
            if (outConfig == 2 && temp.getBcType().equals("out") && isEmptyMileage(temp)
                    && (!limitPark || parks.contains(temp.getQdzCode())))
                continue;

            if (flag) {
                next = temp;
                break;
            }
        }
        return next;
    }

    private boolean isEmptyMileage(ScheduleRealInfo sch) {
        return sch.getBcsj() == 0 || sch.getJhlcOrig().intValue() == 0;
    }

    /**
     * 下一个班次
     *
     * @param list 班次集合
     * @param sch  当前班次
     * @return
     */
    private ScheduleRealInfo next2_lp(Collection<ScheduleRealInfo> list, ScheduleRealInfo sch) {
        int outConfig = -1;
        LineConfig config = lineConfigData.get(sch.getXlBm());
        if (config != null)
            outConfig = config.getOutConfig();

        boolean flag = false;
        ScheduleRealInfo next = null;
        for (ScheduleRealInfo temp : list) {
            if (temp.getId() == sch.getId()) {
                flag = true;
                continue;
            }

            if (flag) {
                next = temp;
                break;
            }
        }
        return next;
    }

    private ScheduleRealInfo next3_lp(Collection<ScheduleRealInfo> list, ScheduleRealInfo sch) {
        int outConfig = -1;
        LineConfig config = lineConfigData.get(sch.getXlBm());
        if (config != null)
            outConfig = config.getOutConfig();

        //限定出站既出场的停车场
        List<String> parks = config.findTwinsParkList();
        boolean limitPark = null != parks && parks.size() > 0;
        boolean flag = false;
        ScheduleRealInfo next = null;
        for (ScheduleRealInfo temp : list) {
            if (temp.getId() == sch.getId()) {
                flag = true;
                continue;
            }

            //出站既出场，忽略出场班次
            if (outConfig == 2 && temp.getBcType().equals("out") && isEmptyMileage(temp)
                    && (!limitPark || parks.contains(temp.getQdzCode())))
                continue;

            if (flag) {
                next = temp;
                break;
            }
        }
        return next;
    }

    /**
     * 上一个班次
     *
     * @param sch
     * @return
     */
    public ScheduleRealInfo prev(ScheduleRealInfo sch) {
        List<ScheduleRealInfo> list = nbbmScheduleMap.get(sch.getClZbh());

        //boolean flag = false;
        ScheduleRealInfo prev = null;
        int size = list.size();

        for (int i = 0; i < size; i++) {
            if (list.get(i).isDestroy())
                continue;

            if (list.get(i).getId().equals(sch.getId())) {
                return prev;
            }
            prev = list.get(i);
        }
        return prev;
    }

    /**
     * 是否是首班出场
     *
     * @param sch
     * @return
     */
    public boolean isFirstOut(ScheduleRealInfo sch) {
        List<ScheduleRealInfo> list = nbbmScheduleMap.get(sch.getClZbh());
        try {
            if (list.get(0) == sch && sch.getBcType().equals("out"))
                return true;
        } catch (IndexOutOfBoundsException e) {
            logger.error("小小的数组越界，无伤大雅！");
        }
        return false;
    }

    public void put(ScheduleRealInfo sch) {
        schAttrCalculator
                .calcRealDate(sch)
                .calcAllTimeByFcsj(sch);

        nbbmScheduleMap.put(sch.getClZbh(), sch);

        //主键索引
        id2SchedulMap.put(sch.getId(), sch);
        //路牌对照表
        addLPMapp(sch);

        //跨24点的，再save一次
        if (!sch.getRealExecDate().equals(sch.getScheduleDateStr()))
            save(sch);
    }

    public void addLPMapp(ScheduleRealInfo sch) {
        lpScheduleMap.put(sch.getXlBm() + "_" + sch.getLpName(), sch);
    }

    public void delete(ScheduleRealInfo sch) {
        if (!sch.isSflj())
            return;

        nbbmScheduleMap.remove(sch.getClZbh(), sch);
        id2SchedulMap.remove(sch.getId());
        lpScheduleMap.remove(sch.getXlBm() + "_" + sch.getLpName(), sch);

        //如果正在执行该班次
        if (carExecutePlanMap.get(sch.getClZbh()) == sch) {
            //重新计算车辆当前执行班次
            reCalcExecPlan(sch.getClZbh());
        }
    }

    public List<ScheduleRealInfo> updateQdzTimePlan(String lpName) {
        List<ScheduleRealInfo> list = lpScheduleMap.get(lpName);
        Collections.sort(list, schFCSJComparator);
        return schAttrCalculator.updateQdzTimePlan(list);
    }

    public List<ScheduleRealInfo> updateQdzTimePlan(ScheduleRealInfo sch) {
        return updateQdzTimePlan(sch.getXlBm() + "_" + sch.getLpName());
    }

    /**
     * @Title: doneSum
     * @Description: TODO(已完成班次总数)
     */
    public int doneSum(String clZbh) {
        List<ScheduleRealInfo> list = nbbmScheduleMap.get(clZbh);
        int rs = 0;

        for (ScheduleRealInfo sch : list) {
            if (sch.getStatus() == 2 && !sch.isDestroy())
                rs++;
        }
        return rs;
    }

    public void save(ScheduleRealInfo sch) {
        sch.setUpdateDate(new Date());
        pstBuffer.add(sch);
    }


    /**
     * @Title: nextByBcType
     * @Description: TODO(获取下一个指定班次类型的班次)
     */
    public ScheduleRealInfo nextByBcType(String nbbm, String bcType) {
        List<ScheduleRealInfo> list = findByBcType(nbbm, bcType);

        Collections.sort(list, schFCSJComparator);
        ScheduleRealInfo sch = null;
        for (ScheduleRealInfo temp : list) {
            if (temp.getFcsjActual() == null) {
                sch = temp;
                break;
            }
        }

        return sch;
    }


    /**
     * 搜索离当前时间最近的一个指定类型的班次
     *
     * @param nbbm
     * @param bcType
     * @return
     */
    public ScheduleRealInfo searchNearByBcType(String nbbm, String bcType) {
        List<ScheduleRealInfo> list = findByBcType(nbbm, bcType);
        Collections.sort(list, schFCSJComparator);

        long t = System.currentTimeMillis();
        int distance = -1, diff;

        ScheduleRealInfo sch = null;
        for (ScheduleRealInfo temp : list) {
            diff = (int) Math.abs(temp.getDfsjT() - t);
            if (diff < distance || distance == -1) {
                sch = temp;
                distance = diff;
            }
        }
        return sch;
    }

    public List<ScheduleRealInfo> findByBcType(String nbbm, String bcType) {
        List<ScheduleRealInfo> all = nbbmScheduleMap.get(nbbm), outList = new ArrayList<>();

        for (ScheduleRealInfo sch : all) {
            if (sch.getBcType().equals(bcType))
                outList.add(sch);
        }
        return outList;
    }

    public Collection<ScheduleRealInfo> findAll() {
        return nbbmScheduleMap.values();
    }

    public Collection<ScheduleRealInfo> findAllByLpContainer() {
        return lpScheduleMap.values();
    }

    public Collection<ScheduleRealInfo> findAllByIdContainer() {
        return id2SchedulMap.values();
    }

    public int getPstSize() {
        return pstBuffer.size();
    }

    public boolean addExecPlan(ScheduleRealInfo sch) {
        ScheduleRealInfo oldExec = executeCurr(sch.getClZbh());
        if (sch != null){
            if(sch.getStatus()==2)
                reCalcExecPlan(sch.getClZbh());
            else
                carExecutePlanMap.put(sch.getClZbh(), sch);
        }
        else
            carExecutePlanMap.remove(sch.getClZbh());

        return executeCurr(sch.getClZbh()) != oldExec;
    }

    public void removeExecPlan(String clzbh) {
        carExecutePlanMap.remove(clzbh);
    }

    public Map<String, ScheduleRealInfo> execPlanMap() {
        return carExecutePlanMap;
    }

    /**
     * 车辆当前执行的班次
     *
     * @param nbbm
     * @return
     */
    public ScheduleRealInfo executeCurr(String nbbm) {
        if(StringUtils.isEmpty(nbbm))
            return null;
        return carExecutePlanMap.get(nbbm);
    }

    /**
     * @param @param sch
     * @param @param newClZbh    新的车辆自编号
     * @Title: changeCar
     * @Description: TODO(班次换车) 返回有更新的班次
     */
    public List<ScheduleRealInfo> changeCar(ScheduleRealInfo sch, String newClZbh) {
        List<ScheduleRealInfo> ups = new ArrayList<>();

        String oldClZbh = sch.getClZbh();
        //变更相关映射信息
        nbbmScheduleMap.remove(sch.getClZbh(), sch);

        sch.setClZbh(newClZbh);
        if (!nbbmScheduleMap.containsEntry(newClZbh, sch)) {
            nbbmScheduleMap.put(newClZbh, sch);
        }

        //重新计算车辆当前执行班次
        reCalcExecPlan(newClZbh);
        reCalcExecPlan(oldClZbh);
        //重新分组计划用车
        reCalcLineNbbms();
        return ups;
    }

    public void removeNbbm2SchMapp(ScheduleRealInfo sch) {
        nbbmScheduleMap.remove(sch.getClZbh(), sch);
    }

    public void addNbbm2SchMapp(ScheduleRealInfo sch) {
        nbbmScheduleMap.put(sch.getClZbh(), sch);
    }

    public void reCalcExecPlan(String nbbm) {
        List<ScheduleRealInfo> list = nbbmScheduleMap.get(nbbm);
        Collections.sort(list, schDFSJComparator);

        ScheduleRealInfo sch = schAttrCalculator.calcCurrentExecSch(list);
        if(null != sch)
            carExecutePlanMap.put(nbbm, sch);
        else
            carExecutePlanMap.remove(nbbm);
    }

    /**
     * 空驶任务？
     * 出场、进场、直放、两点间空驶
     * @param sch
     * @return
     */
    public static boolean emptyService(ScheduleRealInfo sch){
        String type = sch.getBcType();
        return type.equals("out") || type.equals("in") || type.equals("venting") || type.equals("ldks");
    }

    @Autowired
    JdbcTemplate jdbcTemplate;

    /**
     * 删除实际排班
     *
     * @param lineCode
     * @return
     */
    public Map<String, Object> deleteRealSchedule(String lineCode) {
        Map<String, Object> rs = new HashMap<>();

        try {
            String rq = currSchDateMap.get(lineCode);
            if (StringUtils.isNotEmpty(rq)) {
                List<ScheduleRealInfo> all = findByLineCode(lineCode);

                if(null != all && all.size() > 0){
                    //解除gps 和班次之间的关联
                    List<ScheduleRealInfo> unions = calcUnion(all, carExecutePlanMap.values());
                    for (ScheduleRealInfo sch : unions) {
                        removeExecPlan(sch.getClZbh());
                    }
                    //解除调度指令和班次的外键约束
                    StringBuilder inStr = new StringBuilder("(");
                    for (ScheduleRealInfo sch : all) {
                        inStr.append(sch.getId() + ",");
                    }
                    inStr.deleteCharAt(inStr.length() - 1).append(")");
                    jdbcTemplate.update(Constants.MULTI_REMOVE_DIRECTIVE_SCH_FK + " " + inStr.toString());
                }

                //删除班次数据
                removeRealSch(lineCode, rq);

            }
            rs.put("status", ResponseCode.SUCCESS);
        } catch (Exception e) {
            logger.error("", e);
            rs.put("status", ResponseCode.ERROR);
            if (e instanceof DataIntegrityViolationException)
                rs.put("msg", "失败，违反数据约束！！");
            else
                rs.put("msg", e.getMessage());
        }

        return rs;
    }

    /**
     * 计算并集
     *
     * @param c1
     * @param c2
     * @return
     */
    public List<ScheduleRealInfo> calcUnion(Collection<ScheduleRealInfo> c1, Collection<ScheduleRealInfo> c2) {
        List<ScheduleRealInfo> rs = new ArrayList<>();

        for (ScheduleRealInfo sch : c1) {
            if (c2.contains(sch)) {
                rs.add(sch);
            }
        }
        return rs;
    }

    /**
     * 覆盖一辆车的所有班次
     *
     * @param nbbm
     * @param sets
     */
    public void replaceByNbbm(String nbbm, Collection<ScheduleRealInfo> sets) {
        nbbmScheduleMap.removeAll(nbbm);
        nbbmScheduleMap.putAll(nbbm, sets);
    }

    /**
     * 获取该班次所在路牌的下一个班次
     *
     * @param sch
     * @return
     */
    public ScheduleRealInfo nextByLp(ScheduleRealInfo sch) {
        List<ScheduleRealInfo> list = lpScheduleMap.get(sch.getXlBm() + "_" + sch.getLpName());
        Collections.sort(list, schFCSJComparator);
        return next3_lp(list, sch);
    }

    /**
     * 获取该班次所在路牌的下一个班次，不考虑场既是站
     *
     * @param sch
     * @return
     */
    public ScheduleRealInfo nextByLp2(ScheduleRealInfo sch) {
        List<ScheduleRealInfo> list = lpScheduleMap.get(sch.getXlBm() + "_" + sch.getLpName());
        Collections.sort(list, schFCSJComparator);
        return next2_lp(list, sch);
    }

    public ArrayListMultimap<String, ScheduleRealInfo> getLpScheduleMap() {
        return lpScheduleMap;
    }

    /**
     * 重新全量计算路牌下的班次关联性
     * 临时性的函数
     */
    public void _test_reCalcLpSch() {
        Map<String ,Collection<ScheduleRealInfo>> map = lpScheduleMap.asMap();
        Set<String> ks = map.keySet();
        for(String k : ks){
            schAttrCalculator.calcQdzTimePlan(new ArrayList<ScheduleRealInfo>(map.get(k)));
        }
    }

    public int dbCount(String lineCode, String currSchDate) {
        int count = -1;

        try{
            count = jdbcTemplate.queryForObject("select count(*) from bsth_c_s_sp_info_real where schedule_date='"+currSchDate+"' and xl_bm='"+lineCode+"'", java.lang.Integer.class);

        }catch (Exception e){
            logger.error("", e);
        }
        return count;
    }

    /**
     * 重新计算ID对照map
     */
    public int reCalcIdMaps(){
        Collection<ScheduleRealInfo> all = findAll();
        ConcurrentMap<Long, ScheduleRealInfo> id2SchedulMapCopy = new ConcurrentHashMap<>();

        for(ScheduleRealInfo sch : all){
            id2SchedulMapCopy.put(sch.getId(), sch);
        }

        id2SchedulMap = id2SchedulMapCopy;

        return id2SchedulMap.size();
    }

    /**
     * 重新计算线路计划用车
     */
    public void reCalcLineNbbms(){
        HashMultimap<String, String> multimap = HashMultimap.create();

        Collection<ScheduleRealInfo> schs = nbbmScheduleMap.values();
        for (ScheduleRealInfo sch : schs) {
            multimap.put(sch.getXlBm(), sch.getClZbh());
        }

        lineNbbmsMap = multimap;
    }

    public String sizeString(){
        return id2SchedulMap.size() + "/" + nbbmScheduleMap.size();
    }


    /**
     * 按公司编码分组数据
     */
    public void groupByGsbm(){
        Collection<ScheduleRealInfo> all = findAll();
        ListMultimap<String, ScheduleRealInfo> gsBmMaps = ArrayListMultimap.create();

        for(ScheduleRealInfo sch : all){
            gsBmMaps.put(sch.getGsBm(), sch);
        }

        if(gsBmMaps.size() > 0){
            gsBmScheduleMap = null;
            gsBmScheduleMap = gsBmMaps;
        }
    }

    public Collection<ScheduleRealInfo> findByGsbm(String gsbm){
        return gsBmScheduleMap.get(gsbm);
    }
    /**
     * 删除班次，删除内存中未清理掉的非当天的班次
     * @createDate 2019.05.13
     * @author zhangxianzhou
     * @param sch
     */
    public void deleteBC(ScheduleRealInfo sch) {
        nbbmScheduleMap.remove(sch.getClZbh(), sch);
        id2SchedulMap.remove(sch.getId());
        lpScheduleMap.remove(sch.getXlBm() + "_" + sch.getLpName(), sch);
        //如果正在执行该班次
        if (carExecutePlanMap.get(sch.getClZbh()) == sch) {
            //重新计算车辆当前执行班次
            reCalcExecPlan(sch.getClZbh());
        }
    }

    /**
     ** 用于重置维修上报计数，一般只应该在翻班的时候调用
     */
    public void resetRepairReport(String incode) {
        incode2report.remove(incode);
    }

    public RepairReport getLastestRepairReport(String incode) {
        return incode2report.get(incode);
    }

    public void setLastestRepairReport(RepairReport rr) {
        incode2report.put(rr.getIncode(), rr);
    }
}