package com.panzhihua.timejob.jobhandler;

import java.util.Date;
import java.util.List;

import javax.annotation.Resource;

import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.panzhihua.common.model.dtos.community.integral.admin.AddComActIntegralUserDTO;
import com.panzhihua.common.model.vos.R;
import com.panzhihua.common.model.vos.community.ActivitySignVO;
import com.panzhihua.common.model.vos.community.ComActActivityVO;
import com.panzhihua.common.model.vos.community.integral.admin.ComActActivityPeopleVO;
import com.panzhihua.common.model.vos.user.SysUserNoticeVO;
import com.panzhihua.common.service.community.CommunityService;
import com.panzhihua.common.service.user.UserService;
import com.xxl.job.core.biz.model.ReturnT;
import com.xxl.job.core.handler.annotation.XxlJob;

import lombok.extern.slf4j.Slf4j;

/**
 * @program: springcloud_k8s_panzhihuazhihuishequ
 * @description: 社区相关
 * @author: huang.hongfa weixin hhf9596 qq 959656820
 * @create: 2021-01-14 16:09
 **/
@Slf4j
@Component
public class CommunityJobHandler {
    @Resource
    private CommunityService communityService;
    @Resource
    private UserService userService;

    /**
     * 定时任务刷新社区动态置顶状态
     *
     * @return 刷新个数
     * @throws Exception
     *             出现的异常
     */
    @XxlJob("test")
    public ReturnT<String> test(String param) throws Exception {
        log.info("定时测试");
        log.info("执行结果1111【{}】", "sucess");
        return ReturnT.SUCCESS;
    }

    /**
     * 定时任务刷新社区动态置顶状态
     * 
     * @return 刷新个数
     * @throws Exception
     *             出现的异常
     */
    @XxlJob("timedTaskDynIstoppingJobHandler")
    public ReturnT<String> timedTaskDynIstoppingJobHandler(String param) throws Exception {
        log.info("定时任务刷新社区动态置顶状态");
        R r = communityService.timedTaskDynIstopping();
        log.info("执行结果【{}】", r.toString());
        return ReturnT.SUCCESS;
    }

    /**
     * 定时任务刷新社区动态发布状态
     * 
     * @return 刷新个数
     * @throws Exception
     *             出现的异常
     */
    @XxlJob("timedTaskDynStatusJobHandler")
    public ReturnT<String> timedTaskDynStatusJobHandler(String param) throws Exception {
        log.info("定时任务刷新社区动态发布状态");
        R r = communityService.timedTaskDynStatus();
        log.info("执行结果【{}】", r.toString());
        return ReturnT.SUCCESS;
    }

    /**
     * 定时任务取消社区活动
     * 
     * @return 刷新个数
     * @throws Exception
     *             出现的异常
     */
    @XxlJob("timedTaskActActivityJobHandler")
    public ReturnT<String> timedTaskActActivityJobHandler(String param) throws Exception {
        log.info("定时任务取消社区活动");
        R r = communityService.timedTaskActActivity();
        if (R.isOk(r)) {
            Object data = r.getData();
            if (!ObjectUtils.isEmpty(data)) {
                List<ComActActivityVO> comActActivityVOS =
                    JSONArray.parseArray(JSONArray.toJSONString(data), ComActActivityVO.class);
                if (!ObjectUtils.isEmpty(comActActivityVOS)) {
                    comActActivityVOS.forEach(comActActivityVO -> {
                        List<ActivitySignVO> activitySignVOList = comActActivityVO.getActivitySignVOList();
                        if (!ObjectUtils.isEmpty(activitySignVOList)) {
                            activitySignVOList.forEach(activitySignVO -> {
                                SysUserNoticeVO sysUserNoticeVO = new SysUserNoticeVO();
                                sysUserNoticeVO.setUserId(activitySignVO.getUserId());
                                sysUserNoticeVO.setType(1);
                                sysUserNoticeVO.setBusinessType(2);
                                sysUserNoticeVO.setBusinessTitle(comActActivityVO.getActivityName());
                                sysUserNoticeVO.setBusinessTime(new Date());
                                sysUserNoticeVO.setBusinessId(comActActivityVO.getId());
                                sysUserNoticeVO.setStatus(0);
                                sysUserNoticeVO.setTitle("活动因故取消");
                                sysUserNoticeVO.setBusinessContent("报名人数不足活动自动取消");
                                sysUserNoticeVO.setBusinessStatus(1);
                                sysUserNoticeVO
                                    .setActivityType(activitySignVO.getSignIdentity().intValue() == 1 ? 1 : 2);
                                R r2 = userService.addNotice(sysUserNoticeVO);
                                if (R.isOk(r2)) {
                                    log.info("新增社区活动取消通知成功【{}】", JSONObject.toJSONString(sysUserNoticeVO));
                                }
                            });
                        }
                    });
                }
            }
        }
        log.info("执行结果【{}】", r.toString());
        return ReturnT.SUCCESS;
    }

    /**
     * 定时任务刷新社区活动的各个状态 除取消外
     * 
     * @return 刷新个数
     * @throws Exception
     *             出现的异常
     */
    @XxlJob("timedTaskActActivityAllJobHandler")
    public ReturnT<String> timedTaskActActivityAllJobHandler(String param) throws Exception {
        log.info("定时任务刷新社区活动的各个状态 除取消外");
        R r = communityService.timedTaskActActivityAll();
        if (R.isOk(r)) {
            // 获取待结束的活动列表
            List<Long> activityList = JSONArray.parseArray(JSONArray.toJSONString(r.getData()), Long.class);
            if (!activityList.isEmpty()) {
                log.info("社区活动结束时扣减未参与用户积分");
                activityList.forEach(activityId -> {
                    R r1 = communityService.getTaskActivityPeopleList(activityId);
                    if (R.isOk(r1)) {
                        List<ComActActivityPeopleVO> peopleList =
                            JSONArray.parseArray(JSONArray.toJSONString(r1.getData()), ComActActivityPeopleVO.class);
                        if (!peopleList.isEmpty()) {
                            peopleList.forEach(people -> {
                                AddComActIntegralUserDTO addComActIntegralUserDTO = new AddComActIntegralUserDTO();
                                addComActIntegralUserDTO.setUserId(people.getUserId());
                                addComActIntegralUserDTO.setIntegralType(AddComActIntegralUserDTO.integralType.qxhd);
                                addComActIntegralUserDTO.setSignIdentity(people.getSignIdentity());
                                addComActIntegralUserDTO.setCommunityId(people.getCommunityId());
                                addComActIntegralUserDTO.setServiceId(activityId);
                                communityService.addIntegralTradeAdmin(addComActIntegralUserDTO);
                            });
                        }
                    }
                });
            }
        }
        log.info("执行结果【{}】", r.toString());
        return ReturnT.SUCCESS;
    }

    /**
     * 定时任务刷新社区活动的各个状态 除取消外
     * 
     * @return 刷新个数
     * @throws Exception
     *             出现的异常
     */
    @XxlJob("timedTaskActMicroWishAllJobHandler")
    public ReturnT<String> timedTaskActMicroWishAllJobHandler(String param) throws Exception {
        log.info("定时任务刷新微心愿 待自动确认的状态");
        R r = communityService.timedTaskActMicroWishAll();
        log.info("执行结果【{}】", r.toString());
        return ReturnT.SUCCESS;
    }

    /**
     * 定时任务检测即将开始的社区活动，并使用订阅消息通知用户
     */
    @XxlJob("timedTaskActivityNoticeJobHandler")
    public ReturnT<String> timedTaskActivityNoticeJobHandler(String param) {
        log.info("定时任务检测即将开始的社区活动，并使用订阅消息通知用户");
        R r = communityService.timedTaskActivityNotice();
        log.info("执行结果【{}】", r.toString());
        return ReturnT.SUCCESS;
    }

    /**
     * 定时任务检测待发布，调研中的问卷调查状态
     */
    @XxlJob("timedTaskQuestionnaireJobHandler")
    public ReturnT<String> timedTaskQuestionnaireJobHandler(String param) {
        log.info("定时任务检测待发布，调研中的问卷调查状态");
        R r = communityService.timedTaskQuestionnaire();
        log.info("执行结果【{}】", r.toString());
        return ReturnT.SUCCESS;
    }

    /**
     * 定时任务针对活动结束后7天还未评价的用户默认好评
     */
    @XxlJob("timedTaskActivityDefaultPraiseJobHandler")
    public ReturnT<String> timedTaskActivityDefaultPraiseJobHandler(String param) throws Exception {
        log.info("定时任务针对活动结束后7天还未评价的用户默认好评");
        R r = communityService.timedTaskActivityDefaultPraise();
        log.info("执行结果【{}】", r.toString());
        return ReturnT.SUCCESS;
    }

    /**
     * 定时任务每半小时执行一次将一起议浏览量写入到表中
     */
    @XxlJob("timedTaskWriteDiscussViewNumToTableJobHandler")
    public ReturnT<String> timedTaskWriteDiscussViewNumToTableJobHandler(String param) throws Exception {
        log.info("定时任务每半小时执行一次将一起议浏览量写入到表中");
        R r = communityService.timedTaskWriteDiscussViewNumToTable();
        log.info("执行结果【{}】", r.toString());
        return ReturnT.SUCCESS;
    }

    @XxlJob("timedTaskEldersAuthJobHandler")
    public ReturnT<String> timedTaskEldersAuthJobHandler(String param) throws Exception {
        log.info("定时任务扫描老人库的老人是否已加入到统计表中");
        R r = communityService.timedTaskEldersAuthRecordJobHandler();
        log.info("执行结果【{}】", r.toString());
        log.info("定时任务扫描老人认证成功记录加入到统计表中");
        R r1 = communityService.timedTaskElderAuthStatisticsJobHandler();
        log.info("执行结果【{}】", r1.toString());
        return ReturnT.SUCCESS;
    }

    @XxlJob("timedTaskEldersAuthJobMonthHandler")
    public ReturnT<String> timedTaskEldersAuthJobMonthHandler(String param) throws Exception {
        log.info("定时任务扫描高龄认证记录重置任务");
        R r1 = communityService.timedTaskEldersAuthJobHandler();
        log.info("执行结果【{}】", r1.toString());
        return ReturnT.SUCCESS;
    }

    /**
     * 定时任务每月1号0点统计高龄老人本期应该认证总人数
     */
    @XxlJob("timedTaskElderAuthStatisticsJobHandler")
    public ReturnT<String> timedTaskElderAuthStatisticsJobHandler(String param) {
        log.info("定时任务每月1号0点统计高龄老人本期应该认证总人数");
        R r = communityService.timedTaskElderAuthStatisticsJobHandler();
        log.info("执行结果【{}】", r.toString());
        return ReturnT.SUCCESS;
    }

    /**
     * 定时任务每年3月1号0点统计养老认证本期应该认证总人数
     */
    @XxlJob("timedTaskPensionAuthStatisticsJobHandler")
    public ReturnT<String> timedTaskPensionAuthStatisticsJobHandler(String param) {
        log.info("定时任务每年3月1号0点统计养老认证本期应该认证总人数");
        R r = communityService.timedTaskPensionAuthStatisticsJobHandler();
        log.info("执行结果【{}】", r.toString());
        return ReturnT.SUCCESS;
    }

    /**
     * 定时任务每隔半小时将商家浏览量和咨询量总值计入指定商家数据中
     */
    @XxlJob("timedTaskWriteDataToMerchantJobHandler")
    public ReturnT<String> timedTaskWriteDataToMerchantJobHandler(String param) {
        log.info("定时任务每隔半小时将商家浏览量和咨询量总值计入指定商家数据中");
        R r = communityService.timedTaskWriteDataToMerchantJobHandler();
        log.info("执行结果【{}】", r.toString());
        return ReturnT.SUCCESS;
    }

    @XxlJob("timedTaskHouseJobHandler")
    public ReturnT<String> timedTaskHouseJobHandler(String param) {
        log.info("实有房屋定时任务修复数据");
        R r = communityService.timedTaskHouseJobHandler();
        log.info("执行结果【{}】", r.toString());
        return ReturnT.SUCCESS;
    }

    /**
     * 定时任务-每隔5分钟执行一次，将已到期的微商业街商家旗下所有的游戏/资讯全部下架
     * @param param
     * @return
     */
    @XxlJob("offResourceForMcsMerchantJobHandler")
    public ReturnT<String> offResourceForMcsMerchantJobHandler(String param) {
        log.info("定时任务将已到期的微商业街商家旗下所有的游戏/资讯全部下架");
        R r = communityService.offResourceForMcsMerchant();
        log.info("执行结果【{}】", r.toString());
        return ReturnT.SUCCESS;
    }

    /**
     * 定时任务-每隔5分钟执行一次，将已到期的微商业街游戏结束
     * @param param
     * @return
     */
    @XxlJob("endStatusForMcsGameJobHandler")
    public ReturnT<String> endStatusForMcsGameJobHandler(String param) {
        log.info("定时任务，将已到期的微商业街游戏结束");
        R r = communityService.endStatusForMcsGame();
        log.info("执行结果【{}】", r.toString());
        return ReturnT.SUCCESS;
    }

    /**
     * 定时任务针对服务结束后3天还未评价的用户默认好评
     */
    @XxlJob("timedTaskFmsServiceDefaultPraiseJobHandler")
    public ReturnT<String> timedTaskFmsServiceDefaultPraiseJobHandler(String param) throws Exception {
        log.info("定时任务针对服务结束后3天还未评价的用户默认好评");
        R r = communityService.timedTaskFmsServiceDefaultPraise();
        log.info("执行结果【{}】", r.toString());
        return ReturnT.SUCCESS;
    }
}