package com.engine.kq.nbjh;

import com.engine.kq.biz.KQWorkTime;
import weaver.common.DateUtil;
import weaver.conn.RecordSet;
import weaver.general.TimeUtil;
import weaver.general.Util;

import java.text.ParseException;
import java.text.SimpleDateFormat;

/**
 * @Title
 * @Author wangchaofa
 * @CreateDate 2024/4/2
 * @Version 1.0
 * @Description
 */
public class KqUtil {

    /**
     * 判断日期是否在 哺乳假流程日期范围内
     * @param userid
     * @param date
     * @return
     */
    public static boolean checkIsBetweenRange(String userid,String date){
        boolean bool = false;
        RecordSet rs = new RecordSet();
        String breastfeedLeave_table = rs.getPropValue("nbjh_ygdjblc","breastfeedLeave_table");
        rs.executeQuery(" select a.mtgjxs as result,a.ksrq,a.jsrq  from "+ breastfeedLeave_table +" a,workflow_requestbase b " +
                " where a.requestid=b.requestid and b.currentnodetype=3 " +
                " and a.ksrq <= ? and a.jsrq >= ? and a.xm = ?",date,date,userid);
        if(rs.next()){
            bool = true;
        }
        return bool;
    }

    /**
     * 获取 哺乳假 数据
     * @param fromDate
     * @param toDate
     * @param userid
     * @return
     * 查询的     2024-03-01   2024-03-31
     * 流程里的   2024-03-12   2024-11-21
     *            2024-02-10  2024-04-10
     *            2024-02-10  2024-02-20
     */
    public static double getBreastfeedLeave(String fromDate,String toDate,String userid){
        double result = 0.00;
        int ycqdays = 0;
        double day = 0.00;
        RecordSet rs = new RecordSet();
        String lc_fromDate = "";
        String lc_toDate = "";
        rs.writeLog("==============  fromDate ===================  "+ fromDate);
        rs.writeLog("==============  toDate ===================  "+ toDate);
        String currentdate = TimeUtil.getCurrentDateString();

        String breastfeedLeave_table = rs.getPropValue("nbjh_ygdjblc","breastfeedLeave_table");
        rs.executeQuery(" select a.mtgjxs as result,a.ksrq,a.jsrq  from "+ breastfeedLeave_table +" a,workflow_requestbase b " +
                " where a.requestid=b.requestid and b.currentnodetype=3 " +
                " and a.xm = ?",userid);
        if(rs.next()){
            lc_fromDate = Util.null2String(rs.getString("ksrq"));
            lc_toDate = Util.null2String(rs.getString("jsrq"));
            day = Util.getDoubleValue(rs.getString("result"),0.00);

            // 流程里的开始日期 2024-03-12 >= 查询的开始日期 2024-03-01
            if(compareDate(lc_fromDate,fromDate)){
                //流程里的开始日期 2024-03-12 <= 查询的结束日期 2024-03-031
                if(compareDate(toDate,lc_fromDate)){
                    //流程里的结束日期 2024-03-20 <= 查询的结束日期 2024-03-31 。 此时 应该 计算  流程里的开始日期 到 流程里的结束日期，这个范围内的 应出勤天数
                    if(compareDate(toDate,lc_toDate)){
                        ycqdays = getWorkdays(lc_fromDate,lc_toDate,userid);
                    }
                    //流程里的结束日期 2024-04-10 > 查询的结束日期 2024-03-31 。此时 应该 计算  流程里的开始日期 到 查询的结束日期，这个范围内的 应出勤天数
                    else{
                        ycqdays = getWorkdays(lc_fromDate,toDate,userid);
                    }
                }
                //流程里的开始日期  2024-04-10 > 查询的结束日期 2024-03-31
                else{
                    ycqdays = 0;
                }
            }
            //流程里的开始日期 2024-02-10 < 查询的开始日期  2024-03-01
            else{
                //流程里的结束日期 2024-03-10 >= 查询的开始日期 2024-03-01
                if(compareDate(lc_toDate,fromDate)){
                    //流程里的结束日期 2024-03-10 <= 查询的结束日期 2024-03-31 。此时 应该 计算  查询的开始日期 到 流程里的结束日期，这个范围内的 应出勤天数
                    if(compareDate(toDate,lc_toDate)){
                        //流程里的结束日期 >= 当前日期
                        if(compareDate(lc_toDate,currentdate)){
                            ycqdays = getWorkdays(fromDate,currentdate,userid);
                        }else{
                            ycqdays = getWorkdays(fromDate,lc_toDate,userid);
                        }
                    }
                    // 流程里的结束日期 2024-04-10 > 查询的结束日期 2024-03-31 。此时 应该 计算  查询的开始日期 到 查询的结束日期，这个范围内的 应出勤天数
                    else{
                        //流程里的结束日期 >= 当前日期
                        if(compareDate(toDate,currentdate)){
                            ycqdays = getWorkdays(fromDate,currentdate,userid);
                        }else{
                            ycqdays = getWorkdays(fromDate,toDate,userid);
                        }
                    }
                }
                //查询的开始日期 2024-03-01 > 流程里的结束日期  2024-02-20
                else{
                    ycqdays = 0;
                }
            }
        }
        rs.writeLog("=============== ycqdays =================  "+ ycqdays);
        rs.writeLog("=============== day =================  "+ day);
        result = ycqdays * day;

        return result;
    }

    /**
     * 获取日期范围内某个人的应出勤天数
     * @param fromDate  开始日期
     * @param toDate  结束日期
     * @param resourceId  人员id
     * @return
     */
    public static int getWorkdays(String fromDate, String toDate, String resourceId) {
        int workDays = 0;
        /**统计应出勤天数*/
        KQWorkTime kqWorkTime = new KQWorkTime();
        boolean isEnd = false;
        for (String date = fromDate; !isEnd; ) {
            if (date.compareTo(toDate)>=0) {
                isEnd = true;
            }
            boolean isWorkDay = kqWorkTime.isWorkDay(resourceId, date);
            if (isWorkDay) {
                workDays += 1;
            }
            date = DateUtil.getDate(date, 1);
        }
        return workDays;
    }

    /**
     * 比较时间的大小
     * @param a
     * @param b
     * @return
     * @throws ParseException
     */
    public  static boolean compareDate(String a, String b){
        boolean bool = false;
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        try {
            long t1 = sdf.parse(a).getTime();
            long t2 = sdf.parse(b).getTime();
            if (t1 >= t2) {
                bool = true;
            }
            return bool;
        }catch (Exception e){
            e.printStackTrace();
        }
        return bool;
    }


}