package com.muzhi.dingtalk.test.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.dingtalk.api.DefaultDingTalkClient;
import com.dingtalk.api.DingTalkClient;
import com.dingtalk.api.request.*;
import com.dingtalk.api.response.*;
import com.muzhi.dingtalk.test.service.DingAccessTokenService;
import com.muzhi.dingtalk.test.service.DingdingLianJieQiService;
import com.taobao.api.ApiException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.*;


@Service
public class DingdingLianJieQiServiceImpl implements DingdingLianJieQiService {

    @Autowired
    private DingAccessTokenService dingAccessTokenService;

    //实例详情变量
    public static String shili = null;
    //修改假期变量
    public static String jiaqi = null;
    //假期余额变量
    public static String yue = null;
    //考勤结果变量
    public static String kaoqinJG = null;
    //排班班次变量
    public static String paiban = null;

    //抓取钉钉OA审批中通过连接器传输过来的创建审批单的时间
    @Override
    public String getOATime() {

        //获取当前时间并转换成指定的日期格式
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
        String date = simpleDateFormat.format(new Date());
        System.out.println("当前时间的日期格式为："+date);


        //获取当前时间的时间戳并转换为long型
        long time = new Date().getTime();
//        System.out.println("当前时间的时间戳为（long型）：" + time);

        String time1 = String.valueOf(time);
        System.out.println("当前时间的时间戳为（string型）：" + time1);

        return time1;
    }


    /**
     * 获取当年第一天日期
     * @param year 年份
     * @return Date
     */
    public static Date getYearFirst(int year){
        Calendar calendar = Calendar.getInstance();
        calendar.clear();
        calendar.set(Calendar.YEAR, year);
        Date currYearFirst = calendar.getTime();

        return currYearFirst;
    }

    /**
     * 获取当年最后一天日期
     * @param year 年份
     * @return Date
     */
    public static Date getYearLast(int year){
        Calendar calendar = Calendar.getInstance();
        calendar.clear();
        calendar.set(Calendar.YEAR, year);
        calendar.roll(Calendar.DAY_OF_YEAR, -1);
        Date currYearLast = calendar.getTime();

        return currYearLast;
    }


    //抓取钉钉OA审批中通过连接器传输过来的控件数据值，并根据审批单的加班时长进行计算并追加到假期余额中
    @Override
    public String getOA(String processid) {

        //通过钉钉OA高级审批连接器从前端传入的审批单的审批实例id
        String processid1 = processid;

        //调用获取审批实例详情接口
        try {
            DingTalkClient client = new DefaultDingTalkClient("https://oapi.dingtalk.com/topapi/processinstance/get");
            OapiProcessinstanceGetRequest request = new OapiProcessinstanceGetRequest();

            //审批单实例id
            request.setProcessInstanceId(processid1);
            System.out.println("当前审批实例详情id：" + processid1);

            //【测试】实例id
//            request.setProcessInstanceId("b28f8b30-6999-408c-b441-455273a8afc4");

            OapiProcessinstanceGetResponse response = client.execute(request, dingAccessTokenService.getMuZhiAccessToken());
            shili = response.getBody();
            System.out.println(response.getBody());
        } catch (ApiException e) {
            e.printStackTrace();
        }

        //通过fastjson工具转换成json对象,逐层解析
        JSONObject jsonObject = JSON.parseObject(shili);

//        String processInstance = jsonObject.getString("process_instance");
//        System.out.println("审批实例详情：" + processInstance);

        JSONObject processInstance = jsonObject.getJSONObject("process_instance");


        //审批人userid
//        String originatorUserid = processInstance.getString("originator_userid");
        JSONArray tasks = processInstance.getJSONArray("tasks");
        String userid = tasks.getJSONObject(0).getString("userid");
        System.out.println("审批人userid：" + userid);

        //加班审批单提交的内容
        JSONArray formComponentValues = processInstance.getJSONArray("form_component_values");

        //实际加班人员id
        JSONObject jsonObject1 = formComponentValues.getJSONObject(0);
        JSONArray extValue = jsonObject1.getJSONArray("ext_value");
        String emplId = extValue.getJSONObject(0).getString("emplId");
        String name = extValue.getJSONObject(0).getString("name");
        System.out.println("实际加班人员userid：" + emplId);
        System.out.println("实际加班人员姓名：" + name);

        //加班计算方式（option_0：按半小时计算；option_1：按小时计算；option_2：按审批时长计算）
        JSONObject jsonObject11 = formComponentValues.getJSONObject(1);
        JSONObject extValue1 = jsonObject11.getJSONObject("ext_value");
        String key = extValue1.getString("key");
        System.out.println("加班计算方式：" + key);

        //加班时长（小时）
//        JSONObject jsonObject111 = formComponentValues.getJSONObject(3);
//        String value = jsonObject111.getString("value");

        JSONObject jsonObject111 = formComponentValues.getJSONObject(3);
        JSONArray value = jsonObject111.getJSONArray("value");
        Object o = value.get(2);
        String shichangTime = o.toString();


        //审批单中的开始时间
        Object o1 = value.get(0);
        String stringTime1 = o1.toString();
        System.out.println("审批单中的开始时间" + stringTime1);
        //审批单中的结束时间
        Object o2 = value.get(1);
        String stringTime2 = o2.toString();
        System.out.println("审批单中的结束时间" + stringTime2);

        SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd");//设置日期格式
        SimpleDateFormat simpleDateFormat11 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式

        Date date11 = new Date();
        String date22 = null;

        try {
            date11 = simpleDateFormat1.parse(stringTime1);
        }catch (Exception e){
            e.printStackTrace();
        }

        try {
            date22 = simpleDateFormat11.format(date11);
        }catch (Exception e){
            e.printStackTrace();
        }

        //yyyy-MM-dd
        String dakaTime = date11.toString();
        System.out.println("取出审批单中的开始时间的年-月-日：" + dakaTime);
        //yyyy-MM-dd HH:mm:ss
        String dakaTime1 = date22;
        System.out.println("转换成指定格式的审批单中的时间：" + dakaTime1);

        Date shenpidate = new Date();

        SimpleDateFormat simpleDateFormatshenpi = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
        try {
            shenpidate = simpleDateFormatshenpi.parse(dakaTime1);
        }catch (Exception e){
            e.printStackTrace();
        }

        //审批单中的时间（毫秒级时间戳）
        long shenpiTime = shenpidate.getTime();
        System.out.println("审批单中的时间（毫秒级时间戳）：" + shenpiTime);



        /*
         *👇👇👇👇👇👇获取员工提交加班审批当天的排班是否休息👇👇👇👇👇👇
         */

        //查询员工提交加班审批当天的排班是否休息
        try {
            DingTalkClient client5 = new DefaultDingTalkClient("https://oapi.dingtalk.com/topapi/attendance/schedule/listbyday");
            OapiAttendanceScheduleListbydayRequest request5 = new OapiAttendanceScheduleListbydayRequest();

            //操作者userid
            request5.setOpUserId(userid);
            //员工userid
            request5.setUserId(emplId);
            //查询哪一天的排班情况（毫秒级时间戳）
            request5.setDateTime(shenpiTime);

            OapiAttendanceScheduleListbydayResponse response5 = client5.execute(request5, dingAccessTokenService.getMuZhiAccessToken());
            paiban = response5.getBody();
            System.out.println(response5.getBody());
        } catch (ApiException e) {
            e.printStackTrace();
        }

        //通过fastjson工具转换成json对象,逐层解析
        JSONObject jsonObject5 = JSON.parseObject(paiban);
        JSONArray result5 = jsonObject5.getJSONArray("result");
        System.out.println("排班信息结果（数组）：" + result5);

        JSONObject jsonObject6 = result5.getJSONObject(0);
        String is_rest = jsonObject6.getString("is_rest");
        System.out.println("是否为休息（Y：当天排休，N：不休息）：" + is_rest);

//        switch (is_rest){
//            //当天休息
//            case "Y":
//                System.out.println("休息！！！");
//                break;
//
//            //当天上班
//            case "N":
//                System.out.println("上班！！！");
//                break;
//        }


        /*
         *👆👆👆👆👆👆获取员工提交加班审批当天的排班是否休息👆👆👆👆👆👆
         */



        //TODO 定义一个时间变量，用于计算下班后多久开始计算加班时长
        String shichang = null;
        double shichangTime1 = Double.parseDouble(shichangTime) - 0.5;

        if (shichangTime1 < 0.0){
            shichang = "0";
        }else {
            shichang = String.valueOf(shichangTime1);
        }

        //将获取的审批单中的加班时长乘100，并转换成long型，因为修改假期余额接口的参数要求
        double shichang1 = Double.parseDouble(shichang) * 100;
        int i = (int)shichang1;
        long l = (long)i;
        System.out.println("审批单中申请的加班时长（小时）：" + l);

        //当加班计算方式为按小时计算，将使用下面的计算方法计算加班时长
        double d1 = Double.parseDouble(shichang);
        //取出审批时长中的整数值
        int i1 = (int)d1 * 100;
        System.out.println("【测试】审批单中申请的加班时长（int）：" + i1);

        //当加班计算方式为按半小时计算，将使用下面的计算方法计算加班时长
        double d2 = Double.parseDouble(shichang);
        //取出审批时长中的小数位的值
        double d3 = d2 - (int)d1;

        double d4 = 0;

        if (d3 > 0 && d3 < 0.5){
            d4 = d2 - d3;
        }else if (d3 >= 0.5 && d3 < 1){
            d4 = d2 - d3 + 0.5;
        }else {
            d4 = d2;
        }
        long l1 = (long)(d4 * 100);
        System.out.println("按半小时计算方式判断后，时长的值为：" + l1);

        long option_shichang = 0L;

        switch (key){
            //按半小时计算
            case "option_0":
                option_shichang = l1;
                break;

            //按小时计算
            case "option_1":
                option_shichang = (long)i1;
                break;

            //按审批时长计算
            case "option_2":
                option_shichang = l;
                break;
        }
        System.out.println("根据加班计算方式计算之后的加班时长（小时）：" + option_shichang);

        //TODO 自定义休息日加班时长比例
        switch (is_rest){
            //当天休息
            case "Y":
                option_shichang = option_shichang * 2;
                System.out.println("休息！！！");
                break;

            //当天上班
            case "N":
                option_shichang = option_shichang;
                System.out.println("上班！！！");
                break;
        }

        System.out.println("根据加班计算方式计算之后的加班时长（小时），如果是休息日加班则提高时长比例：" + option_shichang);

        //获取当前时间并转换成指定的日期格式（取当前年份）
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy");//设置日期格式
        String date = simpleDateFormat.format(new Date());
        int date1 = Integer.parseInt(date);
        System.out.println("当前时间的日期格式为："+date);

        //获取当前时间并转换成指定的日期格式（取当前年份的年月日）
        SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy-MM-dd");//设置日期格式


        //查询当前加班审批单中的实际加班人员的假期余额
        try {
            DingTalkClient client = new DefaultDingTalkClient("https://oapi.dingtalk.com/topapi/attendance/vacation/quota/list");
            OapiAttendanceVacationQuotaListRequest request1 = new OapiAttendanceVacationQuotaListRequest();

            //TODO 年假假期类型唯一标识（不能是系统自带的假期，必须是新建的其他假期，才可通过接口进行修改）【必填】
//            request1.setLeaveCode("be7cda3e-d3e6-457f-918e-7d5e157d165a");//牧之测试架构
            request1.setLeaveCode("963895d3-98e1-494e-836d-cc6ec44e1805");//牧之测试架构1

            //操作者id
            request1.setOpUserid(userid);
            //待查询员工id列表
            request1.setUserids(emplId);

            request1.setOffset(0L);
            request1.setSize(50L);
            OapiAttendanceVacationQuotaListResponse response1 = client.execute(request1, dingAccessTokenService.getMuZhiAccessToken());
            yue = response1.getBody();
            System.out.println(response1.getBody());
        } catch (ApiException e) {
            e.printStackTrace();
        }

        //通过fastjson工具转换成json对象,逐层解析
        JSONObject jsonObject2 = JSON.parseObject(yue);
        JSONObject result = jsonObject2.getJSONObject("result");

//        JSONArray leaveQuotas = result.getJSONArray("leave_quotas");
//        String quotaNumPerHour = leaveQuotas.getJSONObject(0).getString("quota_num_per_hour");

        long yue1 = 0L;

        if (result.getString("leave_quotas") != null){
            JSONArray leaveQuotas = result.getJSONArray("leave_quotas");
            String quotaNumPerHour = leaveQuotas.getJSONObject(0).getString("quota_num_per_hour");
            int yue = Integer.parseInt(quotaNumPerHour);
            yue1 = (long)yue;
        }else {
            yue1 = 0L;
        }

        System.out.println("当前加班人员的假期余额：" + yue1);


        //调用批量更新员工假期余额接口
        try {
            DingTalkClient client = new DefaultDingTalkClient("https://oapi.dingtalk.com/topapi/attendance/vacation/quota/update");
            OapiAttendanceVacationQuotaUpdateRequest request2 = new OapiAttendanceVacationQuotaUpdateRequest();
            List<OapiAttendanceVacationQuotaUpdateRequest.LeaveQuotas> list2 = new ArrayList<>();
            OapiAttendanceVacationQuotaUpdateRequest.LeaveQuotas obj3 = new OapiAttendanceVacationQuotaUpdateRequest.LeaveQuotas();
            list2.add(obj3);

            //实际加班人员userid【必填】
            obj3.setUserid(emplId);

            //取出当年第一天
            Date yearFirst = getYearFirst(date1);
            String dateFirst = simpleDateFormat2.format(yearFirst);
            long dateFirst2 = 0L;
            try {
                String dateFirst1 = String.valueOf(simpleDateFormat2.parse(dateFirst).getTime());
                dateFirst2 = Long.parseLong(dateFirst1);
            }catch (Exception e){
                e.printStackTrace();
            }
            System.out.println("当年第一天（时间型）：" + dateFirst);
            System.out.println("当年第一天（毫秒级时间戳）：" + dateFirst2);

            //取出当年最后一天
            Date yearLast = getYearLast(date1);
            String dateLast = simpleDateFormat2.format(yearLast);
            long dateLast2 = 0L;
            try {
                String dateLast1 = String.valueOf(simpleDateFormat2.parse(dateLast).getTime());
                dateLast2 = Long.parseLong(dateLast1);
            }catch (Exception e){
                e.printStackTrace();
            }
            System.out.println("当年最后一天（时间型）：" + dateLast);
            System.out.println("当年最后一天（毫秒级时间戳）：" + dateLast2);


            //额度有效期开始时间（毫秒级时间戳）：当年的1月1日
            obj3.setStartTime(dateFirst2);
            //额度有效期结束时间（毫秒级时间戳）：当年的12月31日
            obj3.setEndTime(dateLast2);

            //TODO 年假假期类型唯一标识（不能是系统自带的假期，必须是新建的其他假期，才可通过接口进行修改）【必填】
//            obj3.setLeaveCode("be7cda3e-d3e6-457f-918e-7d5e157d165a");//牧之测试架构
            obj3.setLeaveCode("963895d3-98e1-494e-836d-cc6ec44e1805");//牧之测试架构1

            //操作原因
            obj3.setReason("加班审批追加");

            //假期类型按小时，计算该值不为空且按百分之一小时折算。例如：1000=10小时。【如需修改假期余额，必填】
            obj3.setQuotaNumPerHour(option_shichang + yue1);

            //额度所对应的周期，除了假期类型为调休的时候可以为空之外，其他情况均不能为空且格式必须满足“yyyy”。【假期类型除了调休以外，都为普通假期类型，必填】
            obj3.setQuotaCycle(date);

            request2.setLeaveQuotas(list2);
            //审批人userid【必填】
            request2.setOpUserid(userid);

            OapiAttendanceVacationQuotaUpdateResponse response2 = client.execute(request2, dingAccessTokenService.getMuZhiAccessToken());
            jiaqi = response2.getBody();
            System.out.println(response2.getBody());
        } catch (ApiException e) {
            e.printStackTrace();
        }

        String s1 = String.valueOf(option_shichang);

        double shichangNow = Double.parseDouble(s1) / 100;

        System.out.println("已成功追加员工【" + name + "】假期余额：" + shichangNow + "小时！");

        return "已成功追加员工【" + name + "】假期余额：" + shichangNow + "小时！";
    }



    //抓取钉钉OA审批中通过连接器传输过来的控件数据值，并根据实际打卡时间进行计算加班时长并追加到假期余额中
    @Override
    public String getOA2(String processid) {

        //通过钉钉OA高级审批连接器从前端传入的审批单的审批实例id
        String processid1 = processid;

        //调用获取审批实例详情接口
        try {
            DingTalkClient client = new DefaultDingTalkClient("https://oapi.dingtalk.com/topapi/processinstance/get");
            OapiProcessinstanceGetRequest request = new OapiProcessinstanceGetRequest();

            //审批单实例id
            request.setProcessInstanceId(processid1);
            System.out.println("当前审批实例详情id：" + processid1);

            //【测试】实例id
//            request.setProcessInstanceId("8c39a756-0b35-461a-b3b1-aca35b5c1ad6");

            OapiProcessinstanceGetResponse response = client.execute(request, dingAccessTokenService.getMuZhiAccessToken());
            shili = response.getBody();
            System.out.println(response.getBody());
        } catch (ApiException e) {
            e.printStackTrace();
        }

        //通过fastjson工具转换成json对象,逐层解析
        JSONObject jsonObject = JSON.parseObject(shili);

//        String processInstance = jsonObject.getString("process_instance");
//        System.out.println("审批实例详情：" + processInstance);

        JSONObject processInstance = jsonObject.getJSONObject("process_instance");


        //审批人userid
        String originatorUserid = processInstance.getString("originator_userid");
        System.out.println("审批人userid：" + originatorUserid);

        //加班审批单提交的内容
        JSONArray formComponentValues = processInstance.getJSONArray("form_component_values");

        //实际加班人员id
        JSONObject jsonObject1 = formComponentValues.getJSONObject(0);
        JSONArray extValue = jsonObject1.getJSONArray("ext_value");
        String emplId = extValue.getJSONObject(0).getString("emplId");
        String name = extValue.getJSONObject(0).getString("name");
        System.out.println("实际加班人员userid：" + emplId);
        System.out.println("实际加班人员姓名：" + name);

        //加班计算方式（option_0：按半小时计算；option_1：按小时计算；option_2：按审批时长计算）
        JSONObject jsonObject11 = formComponentValues.getJSONObject(1);
        JSONObject extValue1 = jsonObject11.getJSONObject("ext_value");
        String key = extValue1.getString("key");
        System.out.println("加班计算方式：" + key);

        //加班时长（小时）
        JSONObject jsonObject111 = formComponentValues.getJSONObject(3);
        JSONArray value = jsonObject111.getJSONArray("value");
        Object o = value.get(2);
        //注意：根据考勤打卡时间计算加班时长，所以该时长值未启用！！！
        String shichangTime = o.toString();

        //审批单中的开始时间
        Object o1 = value.get(0);
        String stringTime1 = o1.toString();
        System.out.println("审批单中的开始时间" + stringTime1);
        //审批单中的结束时间
        Object o2 = value.get(1);
        String stringTime2 = o2.toString();
        System.out.println("审批单中的结束时间" + stringTime2);

        SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd");//设置日期格式
        SimpleDateFormat simpleDateFormat11 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式

        Date date11 = new Date();
        String date22 = null;

        try {
            date11 = simpleDateFormat1.parse(stringTime1);
        }catch (Exception e){
            e.printStackTrace();
        }

        try {
            date22 = simpleDateFormat11.format(date11);
        }catch (Exception e){
            e.printStackTrace();
        }

        //yyyy-MM-dd
        String dakaTime = date11.toString();
        System.out.println("取出审批单中的开始时间的年-月-日：" + dakaTime);
        //yyyy-MM-dd HH:mm:ss
        String dakaTime1 = date22;
        System.out.println("转换成指定格式的审批单中的时间：" + dakaTime1);

        Date shenpidate = new Date();

        SimpleDateFormat simpleDateFormatshenpi = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
        try {
            shenpidate = simpleDateFormatshenpi.parse(dakaTime1);
        }catch (Exception e){
            e.printStackTrace();
        }

        //审批单中的时间（毫秒级时间戳）
        long shenpiTime = shenpidate.getTime();
        System.out.println("审批单中的时间（毫秒级时间戳）：" + shenpiTime);


        /*
         *👇👇👇👇👇👇获取考勤结果并计算出实际加班时间👇👇👇👇👇👇
         */
        DingTalkClient client3 = new DefaultDingTalkClient("https://oapi.dingtalk.com/attendance/list");
        OapiAttendanceListRequest request3 = new OapiAttendanceListRequest();
        try {

            //打卡记录起始工作日时间
            request3.setWorkDateFrom(dakaTime1);
            //打卡记录结束工作日时间
            request3.setWorkDateTo(dakaTime1);

//            request.setUserIdList(Arrays.asList(employeeService.getEmployeeId()));
//            request.setUserIdList(employeeService.getEmployeeIdAll());

            //员工userid
            request3.setUserIdList(Arrays.asList(emplId));

            //分页值
            request3.setOffset(0L);
            //最大条数
            request3.setLimit(50L);

            OapiAttendanceListResponse response3 = client3.execute(request3,dingAccessTokenService.getMuZhiAccessToken());
            kaoqinJG = response3.getBody();
            System.out.println(response3.getBody());
        } catch (ApiException e) {
            e.printStackTrace();
        }

        //通过fastjson工具转换成json对象,逐层解析
        JSONObject jsonObject3 = JSON.parseObject(kaoqinJG);
        JSONArray recordresult = jsonObject3.getJSONArray("recordresult");

        String recordresult1 = jsonObject3.getString("recordresult");
        System.out.println("打卡结果：" + recordresult1);

        int resultSize = recordresult.size();
        System.out.println("打卡结果数据总数：" + resultSize);

        //上班前加班时间
        double onjiaban = 0;
        //下班前加班时间
        double offjiaban = 0;

        for (int a = 0; a < recordresult.size(); a++){
            String checkType = recordresult.getJSONObject(a).getString("checkType");
            System.out.println("上下班类型：" + checkType);

            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式

            switch (checkType){
                case "OnDuty":
                    //上班标准时间
                    String baseCheckTime1 = recordresult.getJSONObject(a).getString("baseCheckTime");
                    System.out.println("上班标准时间（毫秒级时间戳）：" + baseCheckTime1);

                    String shangbanbiaozhunTime = simpleDateFormat.format(new Date(Long.parseLong(String.valueOf(baseCheckTime1))));
                    System.out.println("上班标准时间（日期格式）：" + shangbanbiaozhunTime);

                    //用户实际上班打卡时间（毫秒级时间戳）
                    String userCheckTime1 = recordresult.getJSONObject(a).getString("userCheckTime");
                    //将用户实际上班打卡时间转换成日期格式
                    String shijidakaTime1 = simpleDateFormat.format(new Date(Long.parseLong(String.valueOf(userCheckTime1))));
                    System.out.println("实际上班打卡时间（日期格式）：" + shijidakaTime1);

                    try {
                        Date date = simpleDateFormat.parse(shangbanbiaozhunTime);
                        System.out.println("上班标准时间（时间格式）：" + date);
                        Date date1 = simpleDateFormat.parse(shijidakaTime1);
                        System.out.println("实际上班打卡时间（时间格式）" + date1);

                        //上班标准时间 - 实际上班打卡时间（时间戳相减）
                        long time = date.getTime() - date1.getTime();
                        //分钟
                        long time1 = (time / 1000) / 60;
                        System.out.println("上班标准时间（毫秒级）：" + time);
                        System.out.println("计算后的实际上班前加班时间（分钟）：" + time1);

                        //计算后的实际上班前加班时间（小时）
                        onjiaban = (double)time1 / 60;

                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    break;

                case "OffDuty":
                    //下班标准时间
                    String baseCheckTime = recordresult.getJSONObject(a).getString("baseCheckTime");
                    System.out.println("下班标准时间（毫秒级时间戳）：" + baseCheckTime);

//                    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
                    String xiabanbiaozhunTime = simpleDateFormat.format(new Date(Long.parseLong(String.valueOf(baseCheckTime))));
                    System.out.println("下班标准时间（日期格式）：" + xiabanbiaozhunTime);

                    //用户实际下班打卡时间（毫秒级时间戳）
                    String userCheckTime = recordresult.getJSONObject(a).getString("userCheckTime");
                    String shijidakaTime = simpleDateFormat.format(new Date(Long.parseLong(String.valueOf(userCheckTime))));
                    System.out.println("实际下班打卡时间（日期格式）：" + shijidakaTime);


                    //实际下班打卡时间（测试）
//                    String shijidakaTime = "2021-03-25 17:44:00";

                    try {
                        Date date = simpleDateFormat.parse(xiabanbiaozhunTime);
                        System.out.println("下班标准时间（时间格式）：" + date);
                        Date date1 = simpleDateFormat.parse(shijidakaTime);
                        System.out.println("实际下班打卡时间（时间格式）" + date1);

                        //实际下班打卡时间 - 下班标准时间（时间戳相减）
                        long time = date1.getTime() - date.getTime();
                        //分钟
                        long time1 = (time / 1000) / 60;
                        System.out.println("下班标准时间（毫秒级）：" + time);
                        System.out.println("计算后的实际下班后加班时间（分钟）：" + time1);

                        //计算后的实际下班后加班时间（小时）
                        offjiaban = (double)time1 / 60;

                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    break;
            }

        }

        DecimalFormat df = new DecimalFormat("0.0");
        //计算后的实际上班前加班时间
        String jisuan1 = df.format(onjiaban);
        System.out.println("计算后的实际上班前的加班时间（string型）（小时）：" + jisuan1);
        //计算后的实际下班后加班时间
        String jisuan = df.format(offjiaban);
        System.out.println("计算后的实际下班后的加班时间（string型）（小时）：" + jisuan);

        //TODO 定义一个时间变量，用于计算下班后多久开始计算加班时长
        String jisuanTime = null;
        //计算后的实际上班前加班时间
        double onshichangTime = Double.parseDouble(jisuan1);
        //计算后的实际下班后加班时间
        double offshichangTime = Double.parseDouble(jisuan) - 0.5 + onshichangTime;

        if (offshichangTime < 0.0){
            jisuanTime = "0";
        }else {
            jisuanTime = String.valueOf(offshichangTime);
        }

        /*
         *👆👆👆👆👆👆获取考勤结果并计算出实际加班时间👆👆👆👆👆👆
         */



        /*
         *👇👇👇👇👇👇获取员工提交加班审批当天的排班是否休息👇👇👇👇👇👇
         */

        //查询员工提交加班审批当天的排班是否休息
        try {
            DingTalkClient client5 = new DefaultDingTalkClient("https://oapi.dingtalk.com/topapi/attendance/schedule/listbyday");
            OapiAttendanceScheduleListbydayRequest request5 = new OapiAttendanceScheduleListbydayRequest();

            //操作者userid
            request5.setOpUserId(originatorUserid);
            //员工userid
            request5.setUserId(emplId);
            //查询哪一天的排班情况（毫秒级时间戳）
            request5.setDateTime(shenpiTime);

            OapiAttendanceScheduleListbydayResponse response5 = client5.execute(request5, dingAccessTokenService.getMuZhiAccessToken());
            paiban = response5.getBody();
            System.out.println(response5.getBody());
        } catch (ApiException e) {
            e.printStackTrace();
        }

        //通过fastjson工具转换成json对象,逐层解析
        JSONObject jsonObject5 = JSON.parseObject(paiban);
        JSONArray result5 = jsonObject5.getJSONArray("result");
        System.out.println("排班信息结果（数组）：" + result5);

        JSONObject jsonObject6 = result5.getJSONObject(0);
        String is_rest = jsonObject6.getString("is_rest");
        System.out.println("是否为休息（Y：当天排休，N：不休息）：" + is_rest);

//        switch (is_rest){
//            //当天休息
//            case "Y":
//                System.out.println("休息！！！");
//                break;
//
//            //当天上班
//            case "N":
//                System.out.println("上班！！！");
//                break;
//        }


        /*
         *👆👆👆👆👆👆获取员工提交加班审批当天的排班是否休息👆👆👆👆👆👆
         */



        //将获取的审批单中的加班时长乘100，并转换成long型，因为修改假期余额接口的参数要求
        double jisuanTime1 = Double.parseDouble(jisuanTime) * 100;
        int i = (int)jisuanTime1;
        long l = (long)i;
        System.out.println("审批单中实际的打卡加班时长（小时）：" + l);

        //当加班计算方式为按小时计算，将使用下面的计算方法计算加班时长
        double d1 = Double.parseDouble(jisuanTime);
        //取出审批时长中的整数值
        int i1 = (int)d1 * 100;
        System.out.println("审批单中申请的加班时长（int）：" + i1);

        //当加班计算方式为按半小时计算，将使用下面的计算方法计算加班时长
        double d2 = Double.parseDouble(jisuanTime);
        //取出审批时长中的小数位的值
        double d3 = d2 - (int)d1;

        double d4 = 0;

        if (d3 > 0 && d3 < 0.5){
            d4 = d2 - d3;
        }else if (d3 >= 0.5 && d3 < 1){
            d4 = d2 - d3 + 0.5;
        }else {
            d4 = d2;
        }
        long l1 = (long)(d4 * 100);
        System.out.println("按半小时计算方式判断后，时长的值为：" + l1);

        long option_shichang = 0L;

        switch (key){
            //按半小时计算
            case "option_0":
                option_shichang = l1;
                break;

            //按小时计算
            case "option_1":
                option_shichang = (long)i1;
                break;

            //按审批时长计算
            case "option_2":
                option_shichang = l;
                break;
        }
        System.out.println("根据加班计算方式计算之后的加班时长（小时）：" + option_shichang);

        //TODO 自定义休息日加班时长比例
        switch (is_rest){
            //当天休息
            case "Y":
                option_shichang = option_shichang * 2;
                System.out.println("休息！！！");
                break;

            //当天上班
            case "N":
                option_shichang = option_shichang;
                System.out.println("上班！！！");
                break;
        }

        System.out.println("根据加班计算方式计算之后的加班时长（小时），如果是休息日加班则提高时长比例：" + option_shichang);

        //获取当前时间并转换成指定的日期格式（取当前年份）
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy");//设置日期格式
        String date = simpleDateFormat.format(new Date());
        int date1 = Integer.parseInt(date);
        System.out.println("当前时间的日期格式为："+date);

        //获取当前时间并转换成指定的日期格式（取当前年份的年月日）
        SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy-MM-dd");//设置日期格式


        //查询当前加班审批单中的实际加班人员的假期余额
        try {
            DingTalkClient client2 = new DefaultDingTalkClient("https://oapi.dingtalk.com/topapi/attendance/vacation/quota/list");
            OapiAttendanceVacationQuotaListRequest request2 = new OapiAttendanceVacationQuotaListRequest();

            //TODO 年假假期类型唯一标识（不能是系统自带的假期，必须是新建的其他假期，才可通过接口进行修改）【必填】
//            request2.setLeaveCode("be7cda3e-d3e6-457f-918e-7d5e157d165a");//牧之测试架构
            request2.setLeaveCode("963895d3-98e1-494e-836d-cc6ec44e1805");//牧之测试架构1

            //操作者id
            request2.setOpUserid(originatorUserid);
            //待查询员工id列表
            request2.setUserids(emplId);

            request2.setOffset(0L);
            request2.setSize(50L);
            OapiAttendanceVacationQuotaListResponse response2 = client2.execute(request2, dingAccessTokenService.getMuZhiAccessToken());
            yue = response2.getBody();
            System.out.println(response2.getBody());
        } catch (ApiException e) {
            e.printStackTrace();
        }

        //通过fastjson工具转换成json对象,逐层解析
        JSONObject jsonObject2 = JSON.parseObject(yue);
        JSONObject result = jsonObject2.getJSONObject("result");

//        JSONArray leaveQuotas = result.getJSONArray("leave_quotas");
//        String quotaNumPerHour = leaveQuotas.getJSONObject(0).getString("quota_num_per_hour");

        long yue1 = 0L;

        if (result.getString("leave_quotas") != null){
            JSONArray leaveQuotas = result.getJSONArray("leave_quotas");
            String quotaNumPerHour = leaveQuotas.getJSONObject(0).getString("quota_num_per_hour");
            int yue = Integer.parseInt(quotaNumPerHour);
            yue1 = (long)yue;
        }else {
            yue1 = 0L;
        }

        System.out.println("当前加班人员的假期余额：" + yue1);


        //调用批量更新员工假期余额接口
        try {
            DingTalkClient client4 = new DefaultDingTalkClient("https://oapi.dingtalk.com/topapi/attendance/vacation/quota/update");
            OapiAttendanceVacationQuotaUpdateRequest request4 = new OapiAttendanceVacationQuotaUpdateRequest();
            List<OapiAttendanceVacationQuotaUpdateRequest.LeaveQuotas> list2 = new ArrayList<>();
            OapiAttendanceVacationQuotaUpdateRequest.LeaveQuotas obj3 = new OapiAttendanceVacationQuotaUpdateRequest.LeaveQuotas();
            list2.add(obj3);

            //实际加班人员userid【必填】
            obj3.setUserid(emplId);

            //取出当年第一天
            Date yearFirst = getYearFirst(date1);
            String dateFirst = simpleDateFormat2.format(yearFirst);
            long dateFirst2 = 0L;
            try {
                String dateFirst1 = String.valueOf(simpleDateFormat2.parse(dateFirst).getTime());
                dateFirst2 = Long.parseLong(dateFirst1);
            }catch (Exception e){
                e.printStackTrace();
            }
            System.out.println("当年第一天（时间型）：" + dateFirst);
            System.out.println("当年第一天（毫秒级时间戳）：" + dateFirst2);

            //取出当年最后一天
            Date yearLast = getYearLast(date1);
            String dateLast = simpleDateFormat2.format(yearLast);
            long dateLast2 = 0L;
            try {
                String dateLast1 = String.valueOf(simpleDateFormat2.parse(dateLast).getTime());
                dateLast2 = Long.parseLong(dateLast1);
            }catch (Exception e){
                e.printStackTrace();
            }
            System.out.println("当年最后一天（时间型）：" + dateLast);
            System.out.println("当年最后一天（毫秒级时间戳）：" + dateLast2);


            //额度有效期开始时间（毫秒级时间戳）：当年的1月1日
            obj3.setStartTime(dateFirst2);
            //额度有效期结束时间（毫秒级时间戳）：当年的12月31日
            obj3.setEndTime(dateLast2);

            //TODO 年假假期类型唯一标识（不能是系统自带的假期，必须是新建的其他假期，才可通过接口进行修改）【必填】
//            obj3.setLeaveCode("be7cda3e-d3e6-457f-918e-7d5e157d165a");//牧之测试架构
            obj3.setLeaveCode("963895d3-98e1-494e-836d-cc6ec44e1805");//牧之测试架构1

            //操作原因
            obj3.setReason("加班审批追加");

            //假期类型按小时，计算该值不为空且按百分之一小时折算。例如：1000=10小时。【如需修改假期余额，必填】
            obj3.setQuotaNumPerHour(option_shichang + yue1);

            //额度所对应的周期，除了假期类型为调休的时候可以为空之外，其他情况均不能为空且格式必须满足“yyyy”。【假期类型除了调休以外，都为普通假期类型，必填】
            obj3.setQuotaCycle(date);

            request4.setLeaveQuotas(list2);
            //审批人userid【必填】
            request4.setOpUserid(originatorUserid);

            OapiAttendanceVacationQuotaUpdateResponse response4 = client4.execute(request4, dingAccessTokenService.getMuZhiAccessToken());
            jiaqi = response4.getBody();
            System.out.println(response4.getBody());
        } catch (ApiException e) {
            e.printStackTrace();
        }

        String s1 = String.valueOf(option_shichang);

        double shichangNow = Double.parseDouble(s1) / 100;

        System.out.println("已成功追加员工【" + name + "】假期余额：" + shichangNow + "小时！");

        return "已成功追加员工【" + name + "】假期余额：" + shichangNow + "小时！";
    }
}
