时间段的拼接

package com.lihong.DDPush.pms;

import com.lihong.DDPush.mybatis.Parser;
import org.junit.Test;

import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * Created by lihong10 on 2017/9/30.
 */
public class SplitJoinTest {


    public static final String YYYY_MM_DD = "yyyy-MM-dd";
    public static final String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
    public static final long MIN_SECOND = 60 * 1000;
    public static final long DAY_OF_MILLISECOND = 24 * 60 * 60 * 1000;
    private static final Integer COMPLEMENT = 1;


    @Test
    public void test() {


        List<Integer[]> li01 = new ArrayList<Integer[]>() {{
            add(new Integer[]{420, 900});
            add(new Integer[]{900, 1140});
            add(new Integer[]{1140, 420});
        }};

        splitTime(stringToDate("2017-09-28 08:10:00", YYYY_MM_DD_HH_MM_SS).getTime(),
                stringToDate("2017-09-30 23:10:00", YYYY_MM_DD_HH_MM_SS).getTime(),
                li01);

    }


    /**
     * @param crossBeginTime
     * @param crossEndTime
     * @param timeList       一天中的离散时间段列表， 该列表中的元素， 只有最后一个元素有可能出现开始时间大于结束时间的情况，
     *                       比如： [07:00 - 15:00, 15:00 - 19:00, 19:00 - 07:00]
     * @Author: lihong10
     * @Description:
     * @Date: 2017/9/30  16:08
     */
    public static List<TimePair> splitTime(Long crossBeginTime, Long crossEndTime, List<Integer[]> timeList) {

        Date crossBeginDate = new Date(crossBeginTime);
        Date crossEndDate = new Date(crossEndTime);

        Integer[] first = timeList.get(0);
        if (first[0] > first[1]) {
            Collections.reverse(timeList);
            first = timeList.get(0);
        }
        Integer firstStart = first[0];

        List<String> dates = getDatesBetween(crossBeginDate, crossEndDate);
        List<TimePair> pairs = new ArrayList<TimePair>();

        for (int i = 0; i < dates.size(); i++) {

            String baseDateStr = dates.get(i);

            Date baseDate = stringToDate(baseDateStr + " 00:00:00", YYYY_MM_DD_HH_MM_SS);


            for (int j = 0; j < timeList.size(); j++) {

                Integer[] time = timeList.get(j);
                Integer start = time[0];
                Integer end = time[1];
                String startTimeStr = getTimeStr(start);
                String endTimeStr = getTimeStr(end);

                if (start < end) {

                    TimePair.Builder tb = new TimePair.Builder();
                    tb.startTime(baseDate.getTime() + start * MIN_SECOND)
                            .endTime(baseDate.getTime() + end * MIN_SECOND)
                            .startTimeStr(baseDateStr + " " + startTimeStr)
                            .endTimeStr(baseDateStr + " " + endTimeStr);
                    pairs.add(tb.build());

                }
                /*
                 * 事实上只有最后一项会进入该分支，开始时间如果大于结束时间，则属于跨天的情况，举例：如果timeList是{07:00 ~ 19:00, 19:00~07:00}, 日期（baseDateStr）是2017-04-08，
                       则 19:00~07:00 这个时间段会被拼接为2017-04-08 19:00 ~ 2017-04-09 07:00
                */
                else if (start > end) {


                    Integer fixedEndTime = 0;
                    if (end > firstStart) {//此处目的是为了保证时段不会重复
                        fixedEndTime = firstStart;
                    } else if (end < firstStart) {//这里有似乎无用的if else ， 目的是为了做成可以配置的

                        fixedEndTime = COMPLEMENT == 1 ? firstStart : end;
                    } else {
                        fixedEndTime = firstStart;//相等的情况，随意取其中一个的值
                    }

                    String nextDateStr = dateToString(new Date(baseDate.getTime() + DAY_OF_MILLISECOND), YYYY_MM_DD);

                    TimePair.Builder tb = new TimePair.Builder();
                    tb.startTime(baseDate.getTime() + firstStart * MIN_SECOND)
                            .endTime(baseDate.getTime() + DAY_OF_MILLISECOND + fixedEndTime * MIN_SECOND)
                            .startTimeStr(baseDateStr + " " + startTimeStr)
                            .endTimeStr(nextDateStr + " " + getTimeStr(fixedEndTime));

                    pairs.add(tb.build());
                }

            }
        }

        Integer[] last = timeList.get(timeList.size() - 1);
        /*
         * 最后一段如果跨天，举例，如果timeList是{07:00 ~ 19:00, 19:00~07:00}，入场出场日期都是2017-04-08，则最终拼接结果是
         * {
         *   2017-04-08 00:00 ~ 2017-04-08 07:00,
         *   2017-04-08 07:00 ~ 2017-04-08 19:00,
         *   2017-04-08 19:00 ~ 2017-04-09 07:00
         * },
         *
         * 这里if语句的目的是添加2017-04-08 00:00 ~ 2017-04-08 07:00这一段时间
         * */
        if (last[0] > last[1]) {

            String baseDateStr = dates.get(0);

            Date baseDate = stringToDate(baseDateStr + " 00:00:00", YYYY_MM_DD_HH_MM_SS);

            TimePair.Builder tb = new TimePair.Builder();
            tb.startTime(baseDate.getTime())
                    .endTime(baseDate.getTime() + firstStart * MIN_SECOND)
                    .startTimeStr(baseDateStr + " 00:00:00").endTimeStr(baseDateStr + " " + getTimeStr(firstStart));

            pairs.add(0, tb.build());

        }


        System.out.println("拼接得到的时间串是：\n" + pairs);
        return pairs;

    }


    private static List<String> getDatesBetween(Date startDate, Date endDate) {
        String startDateStr = dateToString(startDate, YYYY_MM_DD);
        String endDateStr = dateToString(endDate, YYYY_MM_DD);
        startDate = stringToDate(startDateStr + " 00:00:00", YYYY_MM_DD_HH_MM_SS);
        endDate = stringToDate(endDateStr + " 00:00:00", YYYY_MM_DD_HH_MM_SS);
        List<String> dates = new ArrayList();
        Calendar startCalendar = Calendar.getInstance();
        startCalendar.clear();
        startCalendar.setTime(startDate);
        Calendar endCalendar = Calendar.getInstance();
        endCalendar.clear();
        endCalendar.setTime(endDate);
        while (startCalendar.compareTo(endCalendar) <= 0) {
            dates.add(dateToString(startCalendar.getTime(), YYYY_MM_DD));
            startCalendar.add(Calendar.DAY_OF_YEAR, 1);
        }

        System.out.println(Parser.parse1("开始日期{}到结束日期{}之间的所有日期是：{}", startDateStr, endDateStr, dates));
        return dates;
    }


    private static String getTimeStr(Integer time) {
        time = time == null ? 0 : time;
        String hour = time / 60 > 9 ? ("" + time / 60) : ("0" + time / 60);
        String minute = time % 60 > 9 ? ("" + time % 60) : ("0" + time % 60);
        return hour + ":" + minute + ":00";
    }


    public static Date stringToDate(String strValue, String strFormat) {
        Date date = null;
        try {
            date = new SimpleDateFormat(strFormat).parse(strValue);
        } catch (ParseException e) {
        }
        return date;
    }

    public static String dateToString(Date dateValue, String strFormat) {
        return new SimpleDateFormat(strFormat).format(dateValue);
    }
}


class TimePair {


    private Long startTime;

    private Long endTime;

    private String startTimeStr;

    private String endTimeStr;

    private Long freeTime;

    private Long thresholdTime;

    private BigDecimal inThresholdTimeFee;

    private BigDecimal overThresholdTimeFee;

    private BigDecimal feeBetween;

    public TimePair() {
        super();
    }


    public TimePair(Long startTime, Long endTime) {
        super();
        this.startTime = startTime;
        this.endTime = endTime;
    }


    public void setStartTimeStr(String startTimeStr) {
        this.startTimeStr = startTimeStr;
    }

    public void setEndTimeStr(String endTimeStr) {
        this.endTimeStr = endTimeStr;
    }


    public Long getStartTime() {
        return startTime;
    }


    public void setStartTime(Long startTime) {
        this.startTime = startTime;
    }


    public Long getEndTime() {
        return endTime;
    }


    public void setEndTime(Long endTime) {
        this.endTime = endTime;
    }


    public String getStartTimeStr() {
        return startTimeStr;
    }


    public String getEndTimeStr() {
        return endTimeStr;
    }

    public Long getFreeTime() {
        return freeTime;
    }


    public void setFreeTime(Long freeTime) {
        this.freeTime = freeTime;
    }


    public Long getThresholdTime() {
        return thresholdTime;
    }


    public void setThresholdTime(Long thresholdTime) {
        this.thresholdTime = thresholdTime;
    }


    public BigDecimal getInThresholdTimeFee() {
        return inThresholdTimeFee;
    }


    public void setInThresholdTimeFee(BigDecimal inThresholdTimeFee) {
        this.inThresholdTimeFee = inThresholdTimeFee;
    }


    public BigDecimal getOverThresholdTimeFee() {
        return overThresholdTimeFee;
    }


    public void setOverThresholdTimeFee(BigDecimal overThresholdTimeFee) {
        this.overThresholdTimeFee = overThresholdTimeFee;
    }

    public BigDecimal getFeeBetween() {
        return feeBetween;
    }


    public void setFeeBetween(BigDecimal feeBetween) {
        this.feeBetween = feeBetween;
    }


    /**
     * 根据进场时间和出场时间，计算车辆在 startTime ~ endTime 之间的时段内停留了多久
     *
     * @param crossBeginTime
     * @param crossEndTime
     * @return
     */
    public Long getParkTime(Long crossBeginTime, Long crossEndTime) {

        if (crossBeginTime >= crossEndTime) { //入场时间大于出场时间，直接返回
            return 0L;
        }

        if (crossEndTime <= startTime || crossBeginTime >= endTime) {
            return 0L;
        }

        if (crossBeginTime <= startTime && crossEndTime >= startTime && crossEndTime <= endTime) {//
            return crossEndTime - startTime >= 0 ? crossEndTime - startTime : 0;
        } else if (crossBeginTime <= startTime && crossEndTime >= endTime) {//
            return endTime - startTime >= 0 ? endTime - startTime : 0;
        } else if (crossBeginTime >= startTime && crossEndTime <= endTime) {//
            return crossEndTime - crossBeginTime >= 0 ? crossEndTime - crossBeginTime : 0;
        } else if (crossBeginTime >= startTime && crossBeginTime <= endTime && crossEndTime >= endTime) {
            return endTime - crossBeginTime >= 0 ? endTime - crossBeginTime : 0;
        }

        return 0L;

    }


    /**
     * 覆盖父类方法，目的是为了打印详细日志信息
     */
    @Override
    public String toString() {
        return "(" + startTimeStr + " - " + endTimeStr + ")\n";
    }


    public static class Builder {

        private Long startTime;

        private Long endTime;

        private String startTimeStr;

        private String endTimeStr;

        private Long freeTime;

        private Long thresholdTime;

        private BigDecimal inThresholdTimeFee;

        private BigDecimal overThresholdTimeFee;

        private BigDecimal feeBetween;

        public Builder() {
            super();
        }

        // 构建的步骤
        public Builder(Long startTime, Long endTime) {
            this.startTime = startTime;
            this.endTime = endTime;
        }

        public Builder startTime(Long startTime) {
            this.startTime = startTime;
            return this;
        }

        public Builder endTime(Long endTime) {
            this.endTime = endTime;
            return this;
        }

        public Builder startTimeStr(String startTimeStr) {
            this.startTimeStr = startTimeStr;
            return this;
        }

        public Builder endTimeStr(String endTimeStr) {
            this.endTimeStr = endTimeStr;
            return this;
        }

        public Builder freeTime(Long freeTime) {
            this.freeTime = freeTime;
            return this;
        }

        public Builder thresholdTime(Long thresholdTime) {
            this.thresholdTime = thresholdTime;
            return this;
        }


        public Builder inThresholdTimeFee(BigDecimal inThresholdTimeFee) {
            this.inThresholdTimeFee = inThresholdTimeFee;
            return this;
        }

        public Builder overThresholdTimeFee(BigDecimal overThresholdTimeFee) {
            this.overThresholdTimeFee = overThresholdTimeFee;
            return this;
        }


        public Builder feeBetween(BigDecimal feeBetween) {
            this.feeBetween = feeBetween;
            return this;
        }

        public TimePair build() { // 构建，返回TimePair对象
            TimePair pair = new TimePair(startTime, endTime);
            pair.setStartTimeStr(startTimeStr);
            pair.setEndTimeStr(endTimeStr);
            pair.setFreeTime(freeTime);
            pair.setThresholdTime(thresholdTime);
            pair.setInThresholdTimeFee(inThresholdTimeFee);
            pair.setOverThresholdTimeFee(overThresholdTimeFee);
            pair.setFeeBetween(feeBetween);
            return pair;
        }
    }


}