package com.ruoyi.system.utils;


import com.ruoyi.common.constant.Constants;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.core.utils.HttpUtils;
import com.ruoyi.common.redis.service.RedisService;
import com.ruoyi.system.utils.wx.model.WeixinProperties;
import com.ruoyi.system.utils.wx.template.Template;
import com.ruoyi.system.utils.wx.template.wxTemplateAppealResult.WxTemplateAppealResultRequest;
import com.ruoyi.system.utils.wx.template.wxTemplateAppealResult.WxTemplateAppealResultRequestData;
import com.ruoyi.system.utils.wx.template.wxTemplateDayWork.WxTemplateDayWorkRequest;
import com.ruoyi.system.utils.wx.template.wxTemplateDayWork.WxTemplateDayWorkRequestData;
import com.ruoyi.system.utils.wx.template.wxTemplateMakeCopyRequest.WxTemplateMakeCopyRequest;
import com.ruoyi.system.utils.wx.template.wxTemplateMakeCopyRequest.WxTemplateMakeCopyRequestData;
import com.ruoyi.system.utils.wx.template.wxTemplatePendApproval.WxTemplatePendApprovalRequest;
import com.ruoyi.system.utils.wx.template.wxTemplatePendApproval.WxTemplatePendApprovalRequestData;
import com.ruoyi.system.utils.wx.template.wxTemplateProblemRectificationRequest.WxTemplateProblemRectificationRequest;
import com.ruoyi.system.utils.wx.template.wxTemplateProblemRectificationRequest.WxTemplateProblemRectificationRequestData;
import com.ruoyi.system.utils.wx.template.wxTemplateTaskReturn.WxTemplateTaskResultRequest;
import com.ruoyi.system.utils.wx.template.wxTemplateTaskReturn.WxTemplateTaskResultRequestData;
import com.ruoyi.system.utils.wx.tools.WxAppletTools;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.io.Serializable;

/**
 * 消息模板发送
 */
@Slf4j
@Component
public class TemplateMessageSendUtil implements Serializable {
    private final static String ACCESS_TOKEN_CACHE_KEY = "accessToken:";
    @Autowired
    private RedisCache redisCache;
    @Autowired
    private RestTemplate wxRestTemplate;
    @Autowired
    private WeixinProperties weixinProperties;
    @Resource
    private RedisService redisService;

    /**
     * 任务数据提交结果通知
     * @param openId 用户openId
     * @param taskName 任务名称
     * @param auditResult 审核结果
     * @param auditPerson 审核人
     */
    public String wxTemplateTaskResultRequest(String openId,String taskName,String auditResult,String auditPerson) {
        WxAppletTools appletTools = new WxAppletTools(wxRestTemplate, weixinProperties, redisService);
        // 1,获取access_token
        String accessToken = redisCache.getCacheObject(ACCESS_TOKEN_CACHE_KEY);
        if (!StringUtils.hasLength(accessToken)) {
            accessToken = appletTools.getAccessToken();
        }
        try {
            log.info("任务数据提交结果通知：------------------------");
            // 创建请求实体
            WxTemplateTaskResultRequest wxTemplateTaskResultRequest = new WxTemplateTaskResultRequest();
            wxTemplateTaskResultRequest.setTouser(openId);
            wxTemplateTaskResultRequest.setTemplate_id(weixinProperties.getTaskResultTemplateId());
            // 任务名称
            Template thing1 = new Template();
            thing1.setValue(taskName);
            // 审核结果
            Template phrase4 = new Template();
            phrase4.setValue(auditResult);
            // 审核人
            Template thing3 = new Template();
            thing3.setValue(auditPerson);
            // 发送模板消息参数实体封装
            WxTemplateTaskResultRequestData wxTemplateTaskResultRequestData = new WxTemplateTaskResultRequestData();
            wxTemplateTaskResultRequestData.setThing1(thing1);
            wxTemplateTaskResultRequestData.setPhrase4(phrase4);
            wxTemplateTaskResultRequestData.setThing3(thing3);
            wxTemplateTaskResultRequest.setData(wxTemplateTaskResultRequestData);
            // 4,发送消息给用户
            String url = Constants.TEMPLATE_URL.replace("ACCESS_TOKEN", accessToken);
            String result = HttpUtils.sendPost(url, JsonUtils.toJsonString(wxTemplateTaskResultRequest));
            log.info("任务数据提交结果通知模板消息返回数据:{}", result);
            return result;
        } catch (Exception e) {
            log.error("任务数据提交结果通知失败;");
        }
        return null;
    }

    /**
     * 每日工作未完成提醒
     * @param openId 用户openId
     * @param incompleteNum 未完成数
     * @param endTime 截止时间
     */
    public String wxTemplateDayWorkRequest(String openId,String incompleteNum,String endTime) {
        WxAppletTools appletTools = new WxAppletTools(wxRestTemplate, weixinProperties, redisService);
        // 1,获取access_token
        String accessToken = redisCache.getCacheObject(ACCESS_TOKEN_CACHE_KEY);
        if (!StringUtils.hasLength(accessToken)) {
            accessToken = appletTools.getAccessToken();
        }
        try {
            log.info("每日工作未完成提醒通知：------------------------");
            // 创建请求实体
            WxTemplateDayWorkRequest wxTemplateDayWorkRequest = new WxTemplateDayWorkRequest();
            wxTemplateDayWorkRequest.setTouser(openId);
            wxTemplateDayWorkRequest.setTemplate_id(weixinProperties.getDayWorkTemplateId());
            // 未完成数
            Template number3 = new Template();
            number3.setValue(incompleteNum);
            // 截止时间
            Template time4 = new Template();
            time4.setValue(endTime);
            // 发送模板消息参数实体封装
            WxTemplateDayWorkRequestData wxTemplateDayWorkRequestData = new WxTemplateDayWorkRequestData();
            wxTemplateDayWorkRequestData.setNumber3(number3);
            wxTemplateDayWorkRequestData.setTime4(time4);
            wxTemplateDayWorkRequest.setData(wxTemplateDayWorkRequestData);
            // 4,发送消息给用户
            String url = Constants.TEMPLATE_URL.replace("ACCESS_TOKEN", accessToken);
            String result = HttpUtils.sendPost(url, JsonUtils.toJsonString(wxTemplateDayWorkRequest));
            log.info("每日工作未完成提醒模板消息返回数据:{}", result);
            return result;
        } catch (Exception e) {
            log.error("每日工作未完成提醒通知失败;");
        }
        return null;
    }

    /**
     * 申诉结果通知
     * @param openId 用户openId
     * @param taskName 任务名称
     * @param appealResult 申诉结果
     * @param handleTime 处理时间
     * @param remark 备注
     */
    public String wxTemplateAppealResultRequest(String openId,String taskName,String appealResult,String handleTime,String remark) {
        WxAppletTools appletTools = new WxAppletTools(wxRestTemplate, weixinProperties, redisService);
        // 1,获取access_token
        String accessToken = redisCache.getCacheObject(ACCESS_TOKEN_CACHE_KEY);
        if (!StringUtils.hasLength(accessToken)) {
            accessToken = appletTools.getAccessToken();
        }
        try {
            log.info("申诉结果提醒通知：------------------------");
            // 创建请求实体
            WxTemplateAppealResultRequest wxTemplateAppealResultRequest = new WxTemplateAppealResultRequest();
            wxTemplateAppealResultRequest.setTouser(openId);
            wxTemplateAppealResultRequest.setTemplate_id(weixinProperties.getAppealResultTemplateId());
            // 任务名称
            Template thing4 = new Template();
            thing4.setValue(taskName);
            // 申诉结果
            Template phrase1 = new Template();
            phrase1.setValue(appealResult);
            // 处理时间
            Template time2 = new Template();
            time2.setValue(handleTime);
            // 备注
            Template thing3 = new Template();
            thing3.setValue(remark);
            // 发送模板消息参数实体封装
            WxTemplateAppealResultRequestData wxTemplateAppealResultRequestData = new WxTemplateAppealResultRequestData();
            wxTemplateAppealResultRequestData.setThing4(thing4);
            wxTemplateAppealResultRequestData.setPhrase1(phrase1);
            wxTemplateAppealResultRequestData.setTime2(time2);
            wxTemplateAppealResultRequestData.setThing3(thing3);
            wxTemplateAppealResultRequest.setData(wxTemplateAppealResultRequestData);
            // 4,发送消息给用户
            String url = Constants.TEMPLATE_URL.replace("ACCESS_TOKEN", accessToken);
            String result = HttpUtils.sendPost(url, JsonUtils.toJsonString(wxTemplateAppealResultRequest));
            log.info("申诉结果通知模板消息返回数据:{}", result);
            return result;
        } catch (Exception e) {
            log.error("申诉结果通知失败;");
        }
        return null;
    }

    /**
     * 待审核提醒
     * @param openId 用户openId
     * @param applicant 申请人
     * @param applicantTime 申请时间
     * @param type  业务类型
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @return
     */
    public String wxTemplatePendApprovalRequest(String openId,String applicant,String applicantTime,String type,String startTime,String endTime) {
        WxAppletTools appletTools = new WxAppletTools(wxRestTemplate, weixinProperties, redisService);
        // 1,获取access_token
        String accessToken = redisCache.getCacheObject(ACCESS_TOKEN_CACHE_KEY);
        if (!StringUtils.hasLength(accessToken)) {
            accessToken = appletTools.getAccessToken();
        }
        try {
            log.info("待审核提醒通知：------------------------");
            // 创建请求实体
            WxTemplatePendApprovalRequest wxTemplatePendApprovalRequest = new WxTemplatePendApprovalRequest();
            wxTemplatePendApprovalRequest.setTouser(openId);
            wxTemplatePendApprovalRequest.setTemplate_id(weixinProperties.getPendApprovalTemplateId());
            // 申请人
            Template thing2 = new Template();
            thing2.setValue(applicant);
            // 申请时间
            Template time3 = new Template();
            time3.setValue(applicantTime);
            // 业务类型
            Template thing4 = new Template();
            thing4.setValue(type);
            // 开始时间
            Template time26 = new Template();
            time26.setValue(startTime);
            // 结束时间
            Template time27 = new Template();
            time27.setValue(endTime);
            // 发送模板消息参数实体封装
            WxTemplatePendApprovalRequestData wxTemplatePendApprovalRequestData = new WxTemplatePendApprovalRequestData();
            wxTemplatePendApprovalRequestData.setThing4(thing2);
            wxTemplatePendApprovalRequestData.setTime3(time3);
            wxTemplatePendApprovalRequestData.setThing4(thing4);
            wxTemplatePendApprovalRequestData.setTime26(time26);
            wxTemplatePendApprovalRequestData.setTime27(time27);
            wxTemplatePendApprovalRequest.setData(wxTemplatePendApprovalRequestData);
            // 4,发送消息给用户
            String url = Constants.TEMPLATE_URL.replace("ACCESS_TOKEN", accessToken);
            String result = HttpUtils.sendPost(url, JsonUtils.toJsonString(wxTemplatePendApprovalRequest));
            log.info("待审核提醒模板消息返回数据:{}", result);
            return result;
        } catch (Exception e) {
            log.error("待审核提醒通知失败;");
        }
        return null;
    }
    /**
     * 审核抄送通知
     * @param openId 用户openId
     * @param applicant 申请人
     * @param applicantTime 申请时间
     * @param type  申请类型
     * @return
     */
    public String wxTemplateMakeCopyRequest(String openId,String applicant,String applicantTime,String type) {
        WxAppletTools appletTools = new WxAppletTools(wxRestTemplate, weixinProperties, redisService);
        // 1,获取access_token
        String accessToken = redisCache.getCacheObject(ACCESS_TOKEN_CACHE_KEY);
        if (!StringUtils.hasLength(accessToken)) {
            accessToken = appletTools.getAccessToken();
        }
        try {
            log.info("审核抄送通知：------------------------");
            // 创建请求实体
            WxTemplateMakeCopyRequest wxTemplateMakeCopyRequest = new WxTemplateMakeCopyRequest();
            wxTemplateMakeCopyRequest.setTouser(openId);
            wxTemplateMakeCopyRequest.setTemplate_id(weixinProperties.getMakeCopyTemplateId());
            // 申请人
            Template thing1 = new Template();
            thing1.setValue(applicant);
            // 申请时间
            Template time2 = new Template();
            time2.setValue(applicantTime);
            // 申请类型
            Template thing3 = new Template();
            thing3.setValue(type);
            // 发送模板消息参数实体封装
            WxTemplateMakeCopyRequestData wxTemplateMakeCopyRequestData = new WxTemplateMakeCopyRequestData();
            wxTemplateMakeCopyRequestData.setThing1(thing1);
            wxTemplateMakeCopyRequestData.setTime2(time2);
            wxTemplateMakeCopyRequestData.setThing3(thing3);
            wxTemplateMakeCopyRequest.setData(wxTemplateMakeCopyRequestData);
            // 4,发送消息给用户
            String url = Constants.TEMPLATE_URL.replace("ACCESS_TOKEN", accessToken);
            String result = HttpUtils.sendPost(url, JsonUtils.toJsonString(wxTemplateMakeCopyRequest));
            log.info("审核抄送通知模板消息返回数据:{}", result);
            return result;
        } catch (Exception e) {
            log.error("审核抄送通知失败;");
        }
        return null;
    }

    /**
     * 问题整改通知
     * @param openId 用户openId
     * @param locationName 点位名称
     * @param remark 备注
     * @return
     */
    public String wxTemplateProblemRectificationRequest(String openId,String locationName,String remark) {
        WxAppletTools appletTools = new WxAppletTools(wxRestTemplate, weixinProperties, redisService);
        // 1,获取access_token
        String accessToken = redisCache.getCacheObject(ACCESS_TOKEN_CACHE_KEY);
        if (!StringUtils.hasLength(accessToken)) {
            accessToken = appletTools.getAccessToken();
        }
        try {
            log.info("问题整改通知：------------------------");
            // 创建请求实体
            WxTemplateProblemRectificationRequest wxTemplateProblemRectificationRequest = new WxTemplateProblemRectificationRequest();
            wxTemplateProblemRectificationRequest.setTouser(openId);
            wxTemplateProblemRectificationRequest.setTemplate_id(weixinProperties.getProblemRectificationTemplateId());
            // 点位名称
            Template thing3 = new Template();
            thing3.setValue(locationName);
            // 备注
            Template thing2 = new Template();
            thing2.setValue(remark);
            // 发送模板消息参数实体封装
            WxTemplateProblemRectificationRequestData wxTemplateProblemRectificationRequestData = new WxTemplateProblemRectificationRequestData();
            wxTemplateProblemRectificationRequestData.setThing3(thing3);
            wxTemplateProblemRectificationRequestData.setThing2(thing2);
            wxTemplateProblemRectificationRequest.setData(wxTemplateProblemRectificationRequestData);
            // 4,发送消息给用户
            String url = Constants.TEMPLATE_URL.replace("ACCESS_TOKEN", accessToken);
            String result = HttpUtils.sendPost(url, JsonUtils.toJsonString(wxTemplateProblemRectificationRequest));
            log.info("问题整改通知模板消息返回数据:{}", result);
            return result;
        } catch (Exception e) {
            log.error("问题整改通知失败;");
        }
        return null;
    }

}