package com.panzhihua.service_community.service.impl;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import cn.hutool.core.date.DateUtil;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.panzhihua.common.model.dtos.community.reserve.*;
import com.panzhihua.common.model.vos.R;
import com.panzhihua.common.model.vos.community.reserve.*;
import com.panzhihua.common.model.vos.user.SysTemplateConfigVO;
import com.panzhihua.common.service.user.UserService;
import com.panzhihua.common.utlis.DateUtils;
import com.panzhihua.common.utlis.WxUtil;
import com.panzhihua.common.utlis.WxXCXTempSend;
import com.panzhihua.service_community.dao.*;
import com.panzhihua.common.model.dtos.community.CancelRecordDTO;
import com.panzhihua.common.model.vos.R;
import com.panzhihua.service_community.dao.ComActReserveOperationRecordMapper;
import com.panzhihua.service_community.model.dos.ComActReserveDO;
import com.panzhihua.service_community.model.dos.ComActReserveOperationRecordDO;
import com.panzhihua.service_community.model.dos.ComActReserveRecordDO;
import com.panzhihua.service_community.service.ComActReserveOperationRecordService;
import com.panzhihua.service_community.service.ComActReserveRecordService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;

/**
 * @auther lyq
 * @create 2021-08-23 10:33:53
 * @describe 预约登记记录表服务实现类
 */
@Slf4j
@Service
public class ComActReserveRecordServiceImpl extends ServiceImpl<ComActReserveRecordMapper, ComActReserveRecordDO> implements ComActReserveRecordService {
    @Resource
    private ComActReserveRecordMapper comActReserveRecordMapper;
    @Resource
    private ComActReserveMapper comActReserveMapper;
    @Resource
    private ComActReserveAnswerContentMapper comActReserveAnswerContentMapper;
    @Resource
    private ComActReserveOperationRecordMapper comActReserveOperationRecordMapper;
    @Resource
    private ComActReserveOperationRecordService comActReserveOperationRecordService;
    @Resource
    private ComActActSignDAO comActActSignDAO;
    @Resource
    private UserService userService;

    private final static String CANCEL="用户取消";
    @Override
    @Transactional
    public R cancel(CancelRecordDTO comActReserveRecord) {
        if(comActReserveRecord!=null&&comActReserveRecord.getId()!=null){
            //查询当前操作数据并判断取消状态
            ComActReserveRecordDO comActReserveRecordDO=comActReserveRecordMapper.selectById(comActReserveRecord.getId());
            if(comActReserveRecordDO!=null&&comActReserveRecordDO.getStatus()!=ComActReserveRecordDO.status.yqx){
                comActReserveRecordDO.setStatus(ComActReserveRecordDO.status.yqx);
                comActReserveRecordDO.setRemark(comActReserveRecord.getContent());
                comActReserveRecordDO.setReserveTime(DateUtil.date());
                int result =comActReserveRecordMapper.updateById(comActReserveRecordDO);
                //判断取消状态并添加操作记录
                if(result>0){
                    //更新回答用户数量
                    ComActReserveDO comActReserveDO=comActReserveMapper.selectById(comActReserveRecordDO.getReserveId());
                    Integer joinCount = comActReserveDO.getJoinCount();
                    comActReserveDO.setJoinCount(joinCount != null ? joinCount - 1 : 0);
                    comActReserveMapper.updateById(comActReserveDO);
                    ComActReserveOperationRecordDO comActReserveOperationRecordDO=new ComActReserveOperationRecordDO();
                    comActReserveOperationRecordDO.setRemark(comActReserveRecord.getContent());
                    comActReserveOperationRecordDO.setReserveId(comActReserveRecordDO.getReserveId());
                    comActReserveOperationRecordDO.setReserveRecordId(comActReserveRecordDO.getId());
                    comActReserveOperationRecordDO.setType(ComActReserveOperationRecordDO.type.br);
                    comActReserveOperationRecordDO.setCreateAt(DateUtil.date());
                    comActReserveOperationRecordDO.setReserveContent(CANCEL);
                    comActReserveOperationRecordDO.setPhone(comActReserveRecordDO.getPhone());
                    comActReserveOperationRecordDO.setStatus(ComActReserveOperationRecordDO.status.qx);
                    comActReserveOperationRecordDO.setUserId(comActReserveRecord.getUserId());
                    comActReserveOperationRecordDO.setReserveTime(DateUtil.date());
                    comActReserveOperationRecordMapper.insert(comActReserveOperationRecordDO);
                    return R.ok();
                }
            }
            return R.fail("无法重复取消");
        }

        return R.fail("参数异常");
    }


    /**
     * 社区后台-根据预约id查询预约明细
     * @param pageMakeDTO   请求参数
     * @return  预约明细
     */
    @Override
    public R pageMakeAdmin(PageReserveMakeAdminDTO pageMakeDTO){
        return R.ok(this.baseMapper.pageMakeAdmin(new Page(pageMakeDTO.getPageNum(),pageMakeDTO.getPageSize()),pageMakeDTO));
    }

    /**
     * 根据预约记录id查询预约明细操作记录
     * @param reserveRecordId   预约记录id
     * @return  预约明细操作记录
     */
    @Override
    public R detailMakeAdmin(Long reserveRecordId){
        ComActReserveMakeDetailAdminVO makeDetailAdminVO = this.baseMapper.getMakeDetailAdmin(reserveRecordId);
        if(makeDetailAdminVO != null){
            //查询预约明细操作记录
            List<ComActReserveMakeOperationAdminVO> makeOperationList = comActReserveOperationRecordMapper.getMakeOperationList(reserveRecordId);
            makeDetailAdminVO.setOperationList(makeOperationList);
        }
        return R.ok(makeDetailAdminVO);
    }

    /**
     * 批量取消预约记录
     * @param reserveRecordDTO   请求参数
     * @return  取消结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R makeCancelAdmin(CancelReserveRecordDTO reserveRecordDTO){
        Integer count = this.baseMapper.getReserveStatusById(reserveRecordDTO.getIds());
        if(count > 0){
            return R.fail("仅预约成功的可以进行取消操作");
        }
        if(this.baseMapper.editReserveStatusById(reserveRecordDTO.getIds()) > 0){
            Long userId = reserveRecordDTO.getUserId();
            reserveRecordDTO.getIds().forEach(id -> {
                ComActReserveRecordDO reserveRecordDO = comActReserveRecordMapper.selectById(id);
                if(reserveRecordDO != null){
                    //更新预约记录社区备注字段
                    reserveRecordDO.setActRemark(reserveRecordDTO.getRemark());
                    reserveRecordDO.setHandleId(userId);
                    comActReserveRecordMapper.updateById(reserveRecordDO);
                    //取消预约返还可参加名额
                    comActReserveMapper.addReserveCountById(reserveRecordDO.getReserveId());
                    //添加操作记录
                    comActReserveOperationRecordService.addReserveOperationRecord(reserveRecordDO.getReserveId()
                            ,reserveRecordDO.getId(),reserveRecordDO.getUserId(),ComActReserveOperationRecordDO.type.sq,null
                            ,"社区管理员取消预约",reserveRecordDTO.getRemark(),ComActReserveOperationRecordDO.status.qx,userId,new Date());
                }
            });
            return R.ok();
        }else{
            return R.fail();
        }
    }

    /**
     * 预约明细导出数据查询
     * @param pageMakeDTO   请求参数
     * @return  预约明细数据
     */
    @Override
    public R exportMakeAdmin(PageReserveMakeAdminDTO pageMakeDTO){
        return R.ok(this.baseMapper.exportMakeAdmin(pageMakeDTO));
    }

    /**
     * 分页查询登记统计汇总
     * @param registerStatisticsDTO 请求参数
     * @return  登记统计汇总
     */
    @Override
    public R registerStatisticsAdmin(ComActReserveRegisterStatisticsDTO registerStatisticsDTO){
        IPage<ComActReserveRegisterStatisticsAdminVO> registerStatisticsList = this.baseMapper.registerStatisticsAdmin(new Page(registerStatisticsDTO.getPageNum()
                ,registerStatisticsDTO.getPageSize()),registerStatisticsDTO);
        registerStatisticsList.getRecords().forEach(registerStatistics -> {
            BigDecimal tag = BigDecimal.ZERO;
            if(registerStatistics.getAllCount() > 0){
                tag = BigDecimal.valueOf(registerStatistics.getCount()).divide(BigDecimal.valueOf(registerStatistics.getAllCount()),4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
            }
            registerStatistics.setTag(tag);
        });
        return R.ok(registerStatisticsList.getRecords());
    }

    /**
     * 导出登记统计汇总
     * @param registerStatisticsDTO 请求参数
     * @return  登记统计汇总
     */
    @Override
    public R registerStatisticsExportAdmin(ComActReserveRegisterStatisticsDTO registerStatisticsDTO){
        List<ComActReserveRegisterStatisticsAdminVO> registerStatisticsList = this.baseMapper.registerStatisticsExportAdmin(registerStatisticsDTO);
        registerStatisticsList.forEach(registerStatistics -> {
            BigDecimal tag = BigDecimal.ZERO;
            if(registerStatistics.getAllCount() > 0){
                tag = BigDecimal.valueOf(registerStatistics.getCount()).divide(BigDecimal.valueOf(registerStatistics.getAllCount()),4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
            }
            registerStatistics.setTag(tag);
        });
        return R.ok(registerStatisticsList);
    }

    /**
     * 分页查询预约处理列表
     * @param pageMakeHandleDTO 请求参数
     * @return  预约处理列表
     */
    @Override
    public R pageMakeHandleAdmin(PageReserveMakeHandleAdminDTO pageMakeHandleDTO){
        return R.ok(this.baseMapper.pageMakeHandleAdmin(new Page(pageMakeHandleDTO.getPageNum(),pageMakeHandleDTO.getPageSize()),pageMakeHandleDTO));
    }

    /**
     * 批量处理预约记录
     * @param makeHandleDTO 请求参数
     * @return  处理结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R makeHandleAdmin(MakeHandleAdminDTO makeHandleDTO){
        if(makeHandleDTO.getIds() == null || makeHandleDTO.getIds().isEmpty()){
            return R.fail("请勾选预约记录");
        }
        //判断选中的所有记录是否都是待处理记录
        if(this.baseMapper.getReserveListCountByIds(makeHandleDTO.getIds()) > 0){
            return R.fail("您勾选的记录中存在不是待处理状态的记录，请核对后再进行处理");
        }
        Date nowDate = new Date();
        Long userId = makeHandleDTO.getUserId();
        String remark = makeHandleDTO.getRemark();
        WxXCXTempSend util = new WxXCXTempSend();
        List<ComActReserveRecordDO> updateList = new ArrayList<>();
        makeHandleDTO.getIds().forEach(id -> {
            ComActReserveRecordDO reserveRecordDO = this.baseMapper.selectById(id);
            if(reserveRecordDO != null){
                Date reserveTime = DateUtils.stringToDate(makeHandleDTO.getMakeTime(),DateUtils.ymdhms_format);

                //查询预约登记信息
                ComActReserveDO reserveDO = comActReserveMapper.selectById(reserveRecordDO.getReserveId());
                // 预约以后给用户推送消息
                Map<String, String> map = comActActSignDAO.getUserOpenId(reserveRecordDO.getUserId());
                R<SysTemplateConfigVO> sysTemplateConfigVO=userService.selectTemplate(makeHandleDTO.getAreaCode(),10);
                //判断处理是否通过
                if(makeHandleDTO.getIsOk().equals(MakeHandleAdminDTO.isOk.yes)){
                    reserveRecordDO.setStatus(ComActReserveRecordDO.status.cg);
                    comActReserveOperationRecordService.addReserveOperationRecord(reserveRecordDO.getReserveId()
                            ,id,reserveRecordDO.getUserId(),ComActReserveOperationRecordDO.type.sq,null
                            ,"社区管理员处理预约成功",remark,ComActReserveOperationRecordDO.status.cg,userId,reserveTime);
                    if (map != null) {
                        String openid = map.get("openid");
                        try {
                            WxUtil.sendSubscribeYYTX(openid, util.getAccessToken(), "预约成功",
                                    reserveDO.getTitle(), reserveRecordDO.getName(), makeHandleDTO.getMakeTime(),sysTemplateConfigVO.getData().getTemplateId());
                        } catch (Exception e) {
                            log.error("消息推送失败，失败原因：" + e.getMessage());
                        }
                    }
                }else if(makeHandleDTO.getIsOk().equals(MakeHandleAdminDTO.isOk.no)){
                    reserveRecordDO.setStatus(ComActReserveRecordDO.status.sb);
                    comActReserveOperationRecordService.addReserveOperationRecord(reserveRecordDO.getReserveId()
                            ,id,reserveRecordDO.getUserId(),ComActReserveOperationRecordDO.type.sq,null
                            ,"社区管理员处理预约失败",remark,ComActReserveOperationRecordDO.status.sb,userId,null);

                    if (map != null) {
                        String openid = map.get("openid");
                        try {
                            WxUtil.sendSubscribeYYTX(openid, util.getAccessToken(), "预约失败",
                                    reserveDO.getTitle(), reserveRecordDO.getName(), DateUtils.format(reserveRecordDO.getReserveTime(),DateUtils.ymdhms_format),sysTemplateConfigVO.getData().getTemplateId());
                        } catch (Exception e) {
                            log.error("消息推送失败，失败原因：" + e.getMessage());
                        }
                    }
                    //预约失败时需要更新预约登记参与人数
                    comActReserveMapper.addReserveCountById(reserveRecordDO.getReserveId());
                }
                reserveRecordDO.setActRemark(remark);
                reserveRecordDO.setReserveTime(reserveTime);
                reserveRecordDO.setUpdateAt(nowDate);
                reserveRecordDO.setUpdateBy(userId);
                reserveRecordDO.setHandleId(userId);
                updateList.add(reserveRecordDO);
            }
        });

        if(!updateList.isEmpty()){
            this.updateBatchById(updateList);
        }
        return R.ok();
    }

    /**
     * 导出预约处理列表数据查询
     * @param pageMakeHandleDTO 请求参数
     * @return  预约处理列表
     */
    @Override
    public R exportMakeHandleAdmin(PageReserveMakeHandleAdminDTO pageMakeHandleDTO){
        return R.ok(this.baseMapper.exportMakeHandleAdmin(pageMakeHandleDTO));
    }

    @Override
    public R registerDetailedDetailAdmin(Long reserveRecordId){
        //查询用户信息
        ComActReserveRegisterDetailedVO registerDetailedVO = this.baseMapper.getRegisterDetailedByRecordId(reserveRecordId);
        if(registerDetailedVO != null){
            //组装用户身份信息
            StringBuilder sb = new StringBuilder();
            if(registerDetailedVO.getIsPartymember().equals(1)){
                sb.append("党员/");
            }
            if(registerDetailedVO.getIsVolunteer().equals(1)){
                sb.append("志愿者/");
            }
            if(sb.length() == 0){
                sb.append("居民/");
            }
            String identity = sb.toString();
            registerDetailedVO.setIdentity(identity.substring(0,identity.length()-1));
            //查询答题数据
            List<ComActReserveRegisterDetailedAnswerVO> answerList = comActReserveAnswerContentMapper.getRegisterDetailedAnswerList(reserveRecordId);
            answerList.forEach(answer ->{
                if(answer.getType()==4){
                    answer.setAnswerContent(answer.getAnswerContent().replaceAll("(?<=\\w{3})\\w(?=\\w{4})", "*"));
                }
            });
            registerDetailedVO.setAnswerList(answerList);
        }
        return R.ok(registerDetailedVO);
    }

    @Override
    public R fiveCount(Long reserveId) {
        return R.ok(comActReserveAnswerContentMapper.fiveCount(reserveId));
    }

}