package com.panzhihua.service_community.service.impl;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.lang.generator.SnowflakeGenerator;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.NumberUtil;
import cn.hutool.core.util.RandomUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.panzhihua.common.constants.Constants;
import com.panzhihua.common.constants.ReturnMsgConstants;
import com.panzhihua.common.enums.SanShuoEventStatusEnum;
import com.panzhihua.common.model.dtos.community.sanshuo.IndexDateDTO;
import com.panzhihua.common.model.vos.LoginUserInfoVO;
import com.panzhihua.common.model.vos.R;
import com.panzhihua.common.model.vos.SanShuoMessageVO;
import com.panzhihua.common.model.vos.community.switchs.CommunitySwitchAllAppletsVO;
import com.panzhihua.common.model.vos.sanshuo.*;
import com.panzhihua.common.service.user.UserService;
import com.panzhihua.common.utlis.CopyUtil;
import com.panzhihua.common.utlis.DateUtils;
import com.panzhihua.common.utlis.Snowflake;
import com.panzhihua.common.utlis.StringUtils;
import com.panzhihua.service_community.api.ComSanShuoEventTransferRecordController;
import com.panzhihua.service_community.dao.*;
import com.panzhihua.service_community.entity.*;
import com.panzhihua.service_community.model.dos.ComActDO;
import com.panzhihua.service_community.model.dos.ComStreetDO;
import com.panzhihua.service_community.service.*;
import com.panzhihua.service_community.util.WXMessageUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.RandomUtils;
import org.checkerframework.checker.units.qual.A;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RequestParam;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.*;

import static java.util.Objects.isNull;
import static java.util.Objects.nonNull;

/**
 * Description 三说会堂事件表业务层实现类
 * ClassName   ComEventServiceImpl
 *
 * @author manailin
 * @date 2022-09-07 11:23:51
 */
@Slf4j
@Service("comEventService")
public class ComEventServiceImpl extends ServiceImpl<ComEventMapper, ComEvent> implements IComEventService {

    @Resource
    private IComEventTransferRecordService comEventTransferRecordService;

    @Resource
    private ComSanShuoExpertService comSanShuoExpertService;

    @Resource
    private IComEventResourceService comEventResourceService;

    @Resource
    private ComActDAO comActDAO;

    @Resource
    private ComStreetDAO comStreetDAO;

    @Resource
    private ComSanShuoIndustryCenterService comSanShuoIndustryCenterService;

    @Resource
    private ComEventMapper comEventMapper;

    @Resource
    private UserService userService;

    @Resource
    private CommediateTypeService commediateTypeService;

    @Resource
    private ComSanshuoExpertDao comSanshuoExpertDao;

    @Resource
    private SysUserDao sysUserDao;


    @Override
    public R pageByComEvent(ComEvent comEvent, Page pagination,LoginUserInfoVO loginUserInfoVO) {
        log.info("当前登录信息"+loginUserInfoVO);
        Boolean isExpertCheck=false;
        Long expertId=null;
        Boolean isStretAccount = isStreetAccount(loginUserInfoVO);
        comEvent.setAppId(loginUserInfoVO.getAppId());
        if (nonNull(comEvent.getUserType())){
            if (comEvent.getUserType().equals(1)){
                //个人账号权限
                comEvent.setRequestUserId(loginUserInfoVO.getUserId());
            }else if (comEvent.getUserType().equals(2) || loginUserInfoVO.getType().equals(13) || loginUserInfoVO.getType().equals(11)){
                ComSanshuoExpert expert=new ComSanshuoExpert();
                //专家账号权限(小程序和后台)
                if (nonNull(loginUserInfoVO.getPhone())){
                    expert = comSanShuoExpertService.getOne(new QueryWrapper<ComSanshuoExpert>().lambda().eq(ComSanshuoExpert::getPhone, loginUserInfoVO.getPhone()));
                }else{
                    //账号获取
                    expert = comSanShuoExpertService.getOne(new QueryWrapper<ComSanshuoExpert>().lambda().eq(ComSanshuoExpert::getAccount, loginUserInfoVO.getAccount()));
                }
                comEvent.setUserType(2);
                if (nonNull(expert)){
                    comEvent.setSpecialistId(expert.getId());
                    isExpertCheck=true;
                    expertId=expert.getId();
                }
            }else if (loginUserInfoVO.getType().equals(12)){
                //行业分中心权限
                comEvent.setUserType(3);
                //获取行业分中心id
                ComSanshuoIndustryCenter center = comSanShuoIndustryCenterService.getOne(new QueryWrapper<ComSanshuoIndustryCenter>().lambda().eq(ComSanshuoIndustryCenter::getAccount, loginUserInfoVO.getAccount()));
                if (nonNull(center)){
                    comEvent.setCenterId(center.getId().toString());
                }
            }else if (loginUserInfoVO.getType().equals(3)){
                //社区后台权限
                comEvent.setUserType(4);
                comEvent.setCommunityId(loginUserInfoVO.getCommunityId());
            }else if (isStretAccount){
                //街道权限，查看街道范围下的所有社区事件
                //获取街道下属社区id
                List<Long> cids = comActDAO.selectCommunityByStreetId(loginUserInfoVO.getStreetId());
                comEvent.setUserType(5);
                comEvent.setCommunityIds(cids);
            }
        }
        if (nonNull(loginUserInfoVO.getAccount())){
            if (loginUserInfoVO.getAccount().equals("admin")){
                comEvent.setUserType(9);
            }
        }
        IPage<ComEvent> list=null;
        //是否为专家查看自己发布的事件
        if (isExpertCheck && comEvent.getUserType()!=1){
            List<Long> ids=comEventMapper.listEventIds(expertId);
            if (ids!=null && ids.size()>0 ){
                list = comEventMapper.pageByComEventExpert(ids, comEvent, pagination);
            }
            else
            {
                list = comEventMapper.pageByComEventExpert(null, comEvent, pagination);
            }
        }else{
            list = baseMapper.pageByComEvent(comEvent, pagination);
        }
        if (list==null || list.getRecords().size() < 1) {
            return R.ok(Collections.emptyList());
        }
        list.getRecords().forEach(comEvent1 -> {
            List<ComEventResource> resourceList = comEventResourceService.list(new QueryWrapper<ComEventResource>().lambda().eq(ComEventResource::getRefId, comEvent1.getId()));
            List<ComEventRequestImageVO> comEventRequestImageVO = CopyUtil.deepCopyListObject(resourceList, ComEventRequestImageVO.class);
            comEvent1.setImages(comEventRequestImageVO);
            if (nonNull(userService.getUserInfoByUserId(comEvent1.getRequestUserId().toString()).getData().getImageUrl())){
                comEvent1.setIcon(userService.getUserInfoByUserId(comEvent1.getRequestUserId().toString()).getData().getImageUrl());
            }
            ComMediateType category = commediateTypeService.getById(comEvent1.getEventCategory());
            comEvent1.setEventCategoryName(category.getName());
            comEvent1.setHasPerm(hasPermission(comEvent1,loginUserInfoVO ));
            this.accountMenu(comEvent1,comEvent.getUserType(),loginUserInfoVO,isStretAccount);
            });
        return R.ok(list);
    }

    /**
     * 当前账号对事件的操作权限
     * 1有权限 0无权限
     * 1、用户提交调解申请后，调解专家状态为待受理，可操作受理、查看，专家所在部门状态为待受理，可操作受理（帮专家进行受理处理）、查看、删除，
     * 所在部门上级部门状态为待受理，仅可查看、删除；ok
     * 2、专家拒绝受理后，专家看不到该调解申请，所在单位状态变为待分配，可操作分配、调解、查看、删除，所在单位的上级单位状态变为待分配，仅可查看、删除； ok
     * 3、专家受理后，专家状态变为调解中，可操作调解、查看，专家所在部门状态变为调解中，可操作调解、查看、删除，专家做在单位的上级单位状态变为调解中，仅可查看、删除；
     * 4、专家调解调解完成未上报上级，专家状态变为已完成、可操作归档、查看，专家所在部门状态变为已完成，可操作归档、查看，专家所在部门的上级单位状态变为已完成，
     * 可查看、删除；
     * 5、专家所在部门调解完成未上报上级，专家状态变为已完成、可操作归档、查看，专家所在部门状态变为已完成，可操作归档、查看，专家所在部门的上级单位状态变为已完成，
     * 可查看、删除；
     * 6、专家调解完成上报上级，专家状态变为已完成、可操作归档、查看，专家所在部门状态变为待分配，可操作分配专家、调解、查看、删除，专家所在部门的上级单位状态变为调解中，可查看、删除；
     * 7、专家所在部门调解完成上报上级，专家状态变为已完成、可操作归档、查看，专家所在部门状态变为已完成，可操作归档、查看、删除，专家所在部门的上级单位状态变为待分配，可分配专家、查看、删除，
     * 上上级单位状态变为调解中，可查看、删除；
     * 8、专家调解/专家所在部门调解未完成，专家状态变为调解中，可操作调解、查看，专家所在部门状态变为调解中，可操作更换专家、调解、查看、删除，专家所在部门的上级单位状态变为调解中，可查看、删除；
     * 9、专家所在部门分配给专家后，专家状态变为待受理，可操作受理、查看，专家所在部门状态变为待受理，可操作受理（帮专家进行受理处理）、查看、删除，专家所在部门的上级部门状态变为待受理，
     * 仅可查看、删除；
     * 10、专家所在部门更换专家，原专家状态已完成，专家所在部门状态不变，专家所在部门的上级单位状态不变；
     * */
    public void accountMenu(ComEvent comEvent,Integer userType,LoginUserInfoVO loginUserInfoVO,Boolean isStreet){
        //四个账号级别
        Boolean isAdmin=false;
        if (userType.equals(9)){
            isAdmin=true;
        }
        comEvent.setDelete(1);
        comEvent.setArchive(1);
        comEvent.setSolve(1);
        comEvent.setConciliation(1);
        comEvent.setDistribution(1);
        comEvent.setChangeExpert(1);
        if (userType.equals(2)){
            //专家后台权限，根据事件的流转信息决定专家对此事件的操作权限
            //细分到事件的每个状态和流转情况
            ComSanshuoExpert expert=new ComSanshuoExpert();
            comEvent.setDistribution(0);
            comEvent.setChangeExpert(0);
            comEvent.setDelete(0);
            if (nonNull(loginUserInfoVO.getPhone())){
                expert = comSanShuoExpertService.getOne(new QueryWrapper<ComSanshuoExpert>().lambda().eq(ComSanshuoExpert::getPhone, loginUserInfoVO.getPhone()));
            }else{
                //账号获取
                expert = comSanShuoExpertService.getOne(new QueryWrapper<ComSanshuoExpert>().lambda().eq(ComSanshuoExpert::getAccount, loginUserInfoVO.getAccount()));
            }
            if (!comEvent.getCurrentProcessType().equals(5)){
                if (comEvent.getSpecialistId().equals(expert.getId()) && comEvent.getEventProcessStatus().equals(3)){
                    //更高级别分配给该专家，可以受理
                    comEvent.setConciliation(0);
                    comEvent.setArchive(0);
                    //comEvent.setSolve(0);
                    return;
                }
                //已经上报或者重新分配专家,只能查看
                comEvent.setConciliation(0);
                //comEvent.setArchive(0);
                comEvent.setSolve(0);
                return;
            }//未上报,根据状态决定权限
            if (comEvent.getEventProcessStatus().equals(1)){
                //待受理和待验证状态，仅有查看和受理权限，可能为用户选择该专家或上级单位分配给该专家
                //关闭调解和归档
                comEvent.setArchive(0);
                comEvent.setConciliation(0);
            }
            else if (comEvent.getEventProcessStatus().equals(5)){
                //调解中，可以查看，调解
                comEvent.setArchive(0);
                comEvent.setSolve(0);
            }else if (comEvent.getEventProcessStatus().equals(3)){
                //重新分配给该专家的事件，可以进行受理
               // comEvent.setSolve(0);
                comEvent.setConciliation(0);
                comEvent.setArchive(0);
            } else if (comEvent.getEventProcessStatus().equals(6)){
                //调解完成，可以归档,查看
                comEvent.setSolve(0);
                comEvent.setConciliation(0);
            }
        }else if (userType.equals(4)){
            //社区后台权限
            //如果未上报到街道，当前事件权限和专家一样
            if (comEvent.getCurrentProcessType().equals(5)){
                //根据事件状态决定权限
                if (comEvent.getEventProcessStatus().equals(1) ){
                    //待受理和待验证状态，可以受理，分配专家
                    //关闭调解和归档
                    comEvent.setArchive(0);
                    comEvent.setConciliation(0);
                    comEvent.setChangeExpert(0);
                    comEvent.setDistribution(0);
                } else if(comEvent.getEventProcessStatus().equals(2)){
                    //待分配和待验证状态，可以受理，分配专家
                    //关闭调解和归档
                    comEvent.setArchive(0);
                    comEvent.setConciliation(0);
                    comEvent.setChangeExpert(0);
                    if (comEvent.getSpecialistName().equals("待分配")){
                        comEvent.setSolve(0);
                    }
                }
                else if (comEvent.getEventProcessStatus().equals(5)){
                    //调解中，可以查看，调解，更换专家,删除
                    comEvent.setDistribution(0);
                    comEvent.setSolve(0);
                    comEvent.setArchive(0);
                } else if (comEvent.getEventProcessStatus().equals(6) && comEvent.getEventSucceed().equals(2)){
                    //调解完成，可以归档,查看
                    comEvent.setSolve(0);
                    comEvent.setDistribution(0);
                    comEvent.setChangeExpert(0);
                    comEvent.setConciliation(0);
                }
            }else if (comEvent.getCurrentProcessType().equals(2)){
                //上报到社区后，增加分配专家权限
                if (comEvent.getEventProcessStatus().equals(1) || comEvent.getEventProcessStatus().equals(2)){
                    //待受理和待验证状态，可以受理，更换专家
                    //关闭调解和归档
                    comEvent.setArchive(0);
                    comEvent.setConciliation(0);
                    comEvent.setDistribution(0);
                }
                else if (comEvent.getEventProcessStatus().equals(3)){
                    //分配新专家后
                    comEvent.setDistribution(0);
                    comEvent.setArchive(0);
                    comEvent.setChangeExpert(0);
                    comEvent.setSolve(0);
                    comEvent.setEventResult(null);
                    comEvent.setEventProcessStatus(1);
                }else if (comEvent.getEventProcessStatus().equals(5)){
                    //调解中，可以查看，调解，更换专家,删除
                    comEvent.setSolve(0);
                    comEvent.setArchive(0);
                    comEvent.setDistribution(0);
                } else if (comEvent.getEventProcessStatus().equals(6) && comEvent.getEventResult().equals(1) && !comEvent.getIsEnd().equals(1)){
                    //上报并且调解失败，此时事件的状态为6，事件结果为调解失败
                    //comEvent.setDistribution(0);
                    comEvent.setEventResult(null);
                    comEvent.setEventProcessStatus(2);
                    comEvent.setChangeExpert(0);
                    comEvent.setSolve(0);
                    //comEvent.setConciliation(0);
                    comEvent.setArchive(0);
                }else if (comEvent.getEventProcessStatus().equals(6)  && comEvent.getEventResult().equals(2) && comEvent.getEventSucceed().equals(2)){
                    //调解完成，可以归档,查看
                    //关闭所有权限
                    comEvent.setDistribution(0);
                    comEvent.setChangeExpert(0);
                    comEvent.setSolve(0);
                    comEvent.setConciliation(0);
                    //comEvent.setArchive(0);
                }
                else if (comEvent.getEventProcessStatus().equals(6)  && comEvent.getEventSucceed().equals(2)){
                    //调解完成，可以归档,查看
                    //关闭所有权限
                    comEvent.setDistribution(0);
                    comEvent.setSolve(0);
                    //comEvent.setArchive(0);
                    comEvent.setChangeExpert(0);
                    comEvent.setConciliation(0);
                }

            }
            else{
                //已上报到街道或三说会堂，社区没有分配和受理权限权限
                comEvent.setDistribution(0);
                comEvent.setChangeExpert(0);
                //comEvent.setDelete(0);
                comEvent.setSolve(0);
                comEvent.setConciliation(0);
            }
        }else if (userType.equals(3)){
            //分配行业分中心操作权限
            //是否上报到行业分中心
            if (comEvent.getCurrentProcessType().equals(1)){
                //已经报到行业分中心
                if (comEvent.getEventProcessStatus().equals(1) ){
                    //待受理和待验证状态，可以受理，分配专家
                    //关闭调解和归档
                    comEvent.setArchive(0);
                    comEvent.setConciliation(0);
                }else if(comEvent.getEventProcessStatus().equals(2)){
                    //待分配和待验证状态，可以受理，分配专家
                    //关闭调解和归档
                    comEvent.setArchive(0);
                    comEvent.setConciliation(0);
                    comEvent.setChangeExpert(0);
                    if (comEvent.getSpecialistName().equals("待分配")){
                        comEvent.setSolve(0);
                    }
                }
                else if (comEvent.getEventProcessStatus().equals(3)){
                    //分配新专家后
                    comEvent.setDistribution(0);
                    comEvent.setArchive(0);
                    comEvent.setChangeExpert(0);
                    comEvent.setSolve(0);
                    comEvent.setEventResult(null);
                    comEvent.setEventProcessStatus(1);
                }else if (comEvent.getEventProcessStatus().equals(5)){
                    //调解中，可以查看，调解，更换专家,删除
                    comEvent.setDistribution(0);
                    comEvent.setArchive(0);
                    comEvent.setSolve(0);
                }else if (comEvent.getEventProcessStatus().equals(6) && comEvent.getEventResult().equals(1) && !comEvent.getIsEnd().equals(1)){
                    //调解完成，可以归档,查看
                    comEvent.setEventResult(null);
                    comEvent.setEventProcessStatus(2);
                    comEvent.setSolve(0);
                    comEvent.setDistribution(0);
                    //comEvent.setChangeExpert(0);
                    //comEvent.setArchive(0);
                    comEvent.setConciliation(0);
                }else if (comEvent.getEventProcessStatus().equals(6) && comEvent.getEventSucceed().equals(2)){
                    //调解完成，可以归档,查看
                    comEvent.setSolve(0);
                    comEvent.setDistribution(0);
                    comEvent.setChangeExpert(0);
                    comEvent.setConciliation(0);
                }
            }else if (comEvent.getCurrentProcessType().equals(5)){
                //根据事件状态决定权限
                if (comEvent.getEventProcessStatus().equals(1) ){
                    //待受理和待验证状态，可以受理，分配专家
                    //关闭调解和归档
                    comEvent.setArchive(0);
                    comEvent.setConciliation(0);
                    comEvent.setChangeExpert(0);
                } else if(comEvent.getEventProcessStatus().equals(2)){
                    //待分配和待验证状态，可以受理，分配专家
                    //关闭调解和归档
                    comEvent.setArchive(0);
                    //comEvent.setConciliation(0);
                    comEvent.setChangeExpert(0);
                    if (comEvent.getSpecialistName().equals("待分配")){
                        comEvent.setSolve(0);
                    }
                }
                else if (comEvent.getEventProcessStatus().equals(5)){
                    //调解中，可以查看，调解，更换专家,删除
                    comEvent.setDistribution(0);
                    comEvent.setSolve(0);
                    comEvent.setArchive(0);
                }else if (comEvent.getEventProcessStatus().equals(6) && comEvent.getEventResult().equals(2) && comEvent.getEventSucceed().equals(2)){
                    //调解完成并且成功，可以归档,查看
                    comEvent.setSolve(0);
                    comEvent.setDistribution(0);
                    comEvent.setChangeExpert(0);
                    comEvent.setConciliation(0);
                }
                else if (comEvent.getEventProcessStatus().equals(6) && comEvent.getEventSucceed().equals(2)){
                    //调解完成，可以归档,查看
                    comEvent.setSolve(0);
                    comEvent.setDistribution(0);
                    comEvent.setChangeExpert(0);
                    comEvent.setConciliation(0);
                }
            }
            else{
                //未上上报到行业分中心，或者已上报到区三说会堂，仅查看
                //comEvent.setArchive(0);
                comEvent.setSolve(0);
                comEvent.setDistribution(0);
                comEvent.setChangeExpert(0);
                comEvent.setConciliation(0);

            }
        }else if (userType.equals(5)  || isStreet){
            //街道权限，操作街道下属社区的所有事件
            //是否上报到街道
            if (comEvent.getCurrentProcessType().equals(3)){
                //已上报到街道
                if (comEvent.getEventProcessStatus().equals(1) ){
                    //待受理和待验证状态，可以受理，分配专家
                    //关闭调解和归档
                    comEvent.setArchive(0);
                    comEvent.setConciliation(0);
                    comEvent.setChangeExpert(0);
                    //comEvent.setDistribution(0);
                    comEvent.setSolve(0);
                } else if(comEvent.getEventProcessStatus().equals(2)){
                    //待分配和待验证状态，可以受理，分配专家
                    //关闭调解和归档
                    comEvent.setArchive(0);
                    comEvent.setConciliation(0);
                    comEvent.setChangeExpert(0);
                    if (comEvent.getSpecialistName().equals("待分配")){
                        comEvent.setSolve(0);
                    }
                }else if (comEvent.getEventProcessStatus().equals(5)){
                    //调解中，可以查看，调解，更换专家,删除
                    comEvent.setDistribution(0);
                    comEvent.setArchive(0);
                    comEvent.setSolve(0);
                }else if (comEvent.getEventProcessStatus().equals(3)){
                    //分配新专家后
                    comEvent.setDistribution(0);
                    comEvent.setArchive(0);
                    comEvent.setChangeExpert(0);
                    comEvent.setSolve(0);
                    comEvent.setEventResult(null);
                    comEvent.setEventProcessStatus(1);
                }
                else if (comEvent.getEventProcessStatus().equals(6) && comEvent.getEventResult().equals(1) && !comEvent.getIsEnd().equals(1)){
                    //设置为待受理
                    comEvent.setEventResult(null);
                    comEvent.setEventProcessStatus(2);
                    //上报到单位，并且调解失败，
                    //调解完成，可以归档,查看
                    comEvent.setSolve(0);
                    //comEvent.setDistribution(0);
                    comEvent.setChangeExpert(0);
                    //comEvent.setConciliation(0);
                    comEvent.setArchive(0);
                }
                else if (comEvent.getEventProcessStatus().equals(6) && comEvent.getEventSucceed().equals(2)){
                    //调解完成，可以归档,查看
                    comEvent.setSolve(0);
                    comEvent.setDistribution(0);
                    comEvent.setChangeExpert(0);
                    comEvent.setConciliation(0);
                }
            }else if (comEvent.getCurrentProcessType().equals(4)){
                //未上报到街道，仅查看
                comEvent.setSolve(0);
                comEvent.setDistribution(0);
                comEvent.setChangeExpert(0);
                comEvent.setConciliation(0);

            }else {
                comEvent.setArchive(0);
                comEvent.setSolve(0);
                comEvent.setDistribution(0);
                comEvent.setChangeExpert(0);
                comEvent.setConciliation(0);
            }
        }else if (isAdmin){
            //区三说会堂账号，最高权限全部开放
            // 是否上报到三说会堂
            if(comEvent.getCurrentProcessType()==null)
            {
                //未上报到三说会堂,仅查看
                comEvent.setArchive(0);
                comEvent.setSolve(0);
                comEvent.setDistribution(0);
                comEvent.setChangeExpert(0);
                comEvent.setConciliation(0);
            }
            else
            {
                if (comEvent.getCurrentProcessType().equals(4) || comEvent.getReportHall().equals(1)){
                    //已上报到三说会堂,可以操作
                    if (comEvent.getEventProcessStatus().equals(1)){
                        //待受理和待验证状态，可以受理，分配专家
                        //关闭调解和归档
                        comEvent.setArchive(0);
                        comEvent.setSolve(0);
                        comEvent.setConciliation(0);
                        comEvent.setChangeExpert(0);
                    }
                    else if(comEvent.getEventProcessStatus().equals(2)){
                        //待分配和待验证状态，可以受理，分配专家
                        //关闭调解和归档
                        comEvent.setArchive(0);
                        comEvent.setConciliation(0);
                        comEvent.setChangeExpert(0);
                        if (comEvent.getSpecialistName().equals("待分配")){
                            comEvent.setSolve(0);
                        }
                    }else if (comEvent.getEventProcessStatus().equals(3)){
                        //新分配给专家并且专家还未受理
                        comEvent.setDistribution(0);
                        comEvent.setArchive(0);
                        //comEvent.setConciliation(0);
                        comEvent.setChangeExpert(0);
                        comEvent.setSolve(0);
                    }
                    else if (comEvent.getEventProcessStatus().equals(5)){
                        //调解中，可以查看，调解，更换专家,删除
                        comEvent.setDistribution(0);
                        comEvent.setSolve(0);
                        comEvent.setArchive(0);
                    } else if (comEvent.getEventProcessStatus().equals(6) && comEvent.getEventResult().equals(1) && !comEvent.getIsEnd().equals(1)){
                        //失败后转交三说会堂
                        comEvent.setSolve(0);
                        comEvent.setDistribution(0);
                        //comEvent.setConciliation(0);
                        comEvent.setEventProcessStatus(2);
                        comEvent.setArchive(0);
                        //comEvent.setChangeExpert(0);
                    }
                    else if (comEvent.getEventProcessStatus().equals(6) && comEvent.getEventSucceed().equals(2)){
                        //调解完成，可以归档,查看
                        comEvent.setConciliation(0);
                        comEvent.setSolve(0);
                        comEvent.setDistribution(0);
                        comEvent.setChangeExpert(0);
                    }
                }else{
                    //未上报到三说会堂,仅查看
                    comEvent.setArchive(0);
                    comEvent.setSolve(0);
                    comEvent.setDistribution(0);
                    comEvent.setChangeExpert(0);
                    comEvent.setConciliation(0);
                }
            }

        }
    }

    /**
     * 当前账号是否有操作事件权限
     * */
    public Integer hasPermission(ComEvent comEvent,LoginUserInfoVO sysUser){
        String account="";
        Integer perm=1;

        if(comEvent==null || sysUser == null )
        {
            return perm;
        }

        if (nonNull(sysUser.getAccount())){
            account=sysUser.getAccount();
        }
        //上报级别是否匹配当前账号级别
        if (sysUser.getType().equals(12) ){
            if (comEvent.getCurrentProcessType()!=null && !comEvent.getCurrentProcessType().equals(1)){
                perm=0;
            }
        }else if (StringUtils.equals("admin",account)){
            if ( comEvent.getCurrentProcessType()!=null && comEvent.getCurrentProcessType()!=4){
                perm=0;
            }
        }else if (isStreetAccount(sysUser)){
            if (comEvent.getCurrentProcessType()!=null && comEvent.getCurrentProcessType()!=3){
                perm=0;
            }
        }
        return perm;
    }
    /**
     * 是否为综治后台街道账号
     * */
    public Boolean isStreetAccount(LoginUserInfoVO sysUser){
        Boolean flag=false;
        String[] account={"glpz","qxpjd","tjdjd","dbdjd","yqjd","bcg","hmkjd","dhjd","jsgyy","dzhljd"};
        if (nonNull(sysUser.getAccount())){
            if (ArrayUtil.contains(account,sysUser.getAccount() )){
                flag=true;
            }
        }
        return flag;
    }

    @Override
    public List<ComEvent> listByComEvent(ComEvent comEvent,LoginUserInfoVO loginUserInfoVO) {
        List<ComEvent> list = baseMapper.listByComEvent(comEvent,null);
        if (list.size() < 1) {
            return Collections.emptyList();
        }
        return list;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public R insertComEvent(ComEvent comEvent) {
        ComSanshuoExpert expert = comSanShuoExpertService.getById(comEvent.getSpecialistId());
        if (comEvent.getRequestUserCommunity() != null) {
            //创建时处理级别都是专家
            ComActDO community = comActDAO.selectById(comEvent.getRequestUserCommunity());
            comEvent.setCurrentOrgName(community.getName());
            comEvent.setCurrentOrgId(community.getCommunityId().toString());
            comEvent.setCurrentProcessType(5);
        }
        if (!StringUtils.isEmpty(comEvent.getCenterId()))   {
            //创建时处理级别都是专家
            ComSanshuoIndustryCenter center = comSanShuoIndustryCenterService.getById(comEvent.getCenterId());
            comEvent.setCurrentOrgName(center.getName());
            comEvent.setCurrentOrgId(center.getId().toString());
            comEvent.setCurrentProcessType(5);
        }
        if (StringUtils.isNotEmpty(comEvent.getCenterId())){
            comEvent.setRequestUserCommunity(null);
        }
        comEvent.setUserEventStatus(2);
        //设置为未上报
        comEvent.setReportLevel(0);
        comEvent.setEventProcessStatus(SanShuoEventStatusEnum.UNDO.getCode());
        comEvent.setSpecialistName(expert.getName());
        comEvent.setOrderSn(DateUtils.getDateFormatString(new Date(), "yyyyMMddHHmmss") + RandomUtils.nextLong(1, 10000));
        comEvent.setInvalid(true);
        comEvent.setId(Snowflake.getId());
        comEvent.setSubmitDate(new Date());
        comEvent.setCreateAt(new Date());
        comEvent.setCreateBy(comEvent.getRequestUserId());
        comEvent.setUpdateBy(comEvent.getRequestUserId());
        comEvent.setUpdateAt(new Date());
        boolean flag = save(comEvent);
        //推送消息到专家微信
        sendMessage(comEvent.getSpecialistId(),comEvent);
        //添加一条对应记录
        comEventMapper.insertEventAndExpertRecord(comEvent.getId(),expert.getId(),0);
        if (!flag) {
            return R.fail(ReturnMsgConstants.DATA_EXIST);
        }
        //提交不视为一次流转记录，不保存图片
        saveEventImageList(comEvent.getImages(), comEvent.getId(),null,1);
        return R.ok(ReturnMsgConstants.SAVE_SUCCESS);
    }

    public void sendMessage(Long expertId,ComEvent comEvent){
        if (nonNull(comEvent.getRequestUserCommunity()) && comEvent.getRequestUserCommunity().equals(10172)){
            return;
        }
        //获取专家的openId
        ComSanshuoExpert expert = comSanShuoExpertService.getById(expertId);
        SysUser sysUser = sysUserDao.selectOne(new QueryWrapper<SysUser>().lambda().eq(SysUser::getPhone, expert.getPhone()).eq(SysUser::getType, 1).eq(SysUser::getAppId,"wx0cef797390444b75" ));
        SanShuoMessageVO vo=new SanShuoMessageVO();
        if (isNull(sysUser)){
            return;
        }
        if (isNull(sysUser.getOpenid())){
           log.info("专家未登陆APP，无法推送");
           return;
        }
        vo.setTouser(sysUser.getOpenid());
        vo.setThing1(commediateTypeService.getById(comEvent.getEventCategory()).getName());
        vo.setThing5("您有一个新的调解事件需处理");
        vo.setThing2(comEvent.getRequestUserName());
        vo.setTime3(DateUtil.now());
        WXMessageUtil.sendStatusMessage(vo);
    }

    @Transactional(rollbackFor = Exception.class)
    public Boolean saveEventImageList(List<ComEventRequestImageVO> images, Long id,Long transferId,Integer status) {
        List<ComEventResource> comEventResourceList = new ArrayList<>();
        if (!StringUtils.isEmpty(images)) {
            List<ComEventRequestImageVO> imagesList = images;
            imagesList.forEach(comEventRequestImageVO -> {
                ComEventResource comEventResource = new ComEventResource();
                comEventResource.setId(Snowflake.getId());
                comEventResource.setRefId(id);
                comEventResource.setTransferId(transferId);
                comEventResource.setStatus(status);
                comEventResource.setType(1);
                comEventResource.setResourceName(comEventRequestImageVO.getName());
                comEventResource.setResourceSize(comEventRequestImageVO.getSize());
                comEventResource.setUrl(comEventRequestImageVO.getUrl());
                comEventResource.setDeleteFlag(false);
                comEventResourceList.add(comEventResource);
            });
        }
        return comEventResourceService.saveBatch(comEventResourceList);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public R updateComEvent(ComEvent comEvent) {
/*        if (checkExist(comEvent.getOrderSn(), comEvent.getId())) {
            return R.fail(ReturnMsgConstants.DATA_EXIST);
        }*/
        //清除专家信息
        comEvent.setSpecialistId(null);
        comEvent.setSpecialistName(null);
        int flag = baseMapper.updateById(comEvent);
        return flag > 0 ? R.ok(comEvent, ReturnMsgConstants.UPDATE_SUCCESS) : R.fail(ReturnMsgConstants.UPDATE_FALSE);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public R updateEnabled(Long id, Boolean enabled) {
        ComEvent comEvent = baseMapper.selectById(id);
        if (comEvent == null) {
            return R.fail(ReturnMsgConstants.DATA_NOT_EXIST);
        }
        comEvent.setInvalid(enabled);
        Boolean flag = updateById(comEvent);
        return flag ? R.ok(comEvent, ReturnMsgConstants.UPDATE_SUCCESS) : R.fail(ReturnMsgConstants.UPDATE_FALSE);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public R conciliationEvent(ComEventConciliationVO comEventConciliationVO, LoginUserInfoVO loginUserInfo) {
        ComEvent comEvent = baseMapper.selectById(comEventConciliationVO.getId());
        comEvent.setEventSucceed(comEventConciliationVO.getEventSucceed());
        comEvent.setEventResult(comEventConciliationVO.getEventResult());
        comEvent.setReportSuperior(comEventConciliationVO.getReportSuperior());
        ComEventTransferRecord comEventTransferRecord = new ComEventTransferRecord();
        if(comEventConciliationVO.getEventSucceed().equals(2)){
            comEvent.setEventProcessStatus(6);
        }
        comEvent.setCurrentEventProcessResult(comEventConciliationVO.getCurrentEventProcessResult());
        //如果当前请求，需要上报上级进行处理
        if (comEventConciliationVO.getReportSuperior()) {
            //判断当前的处理级别
            if (comEvent.getCurrentProcessType() == 5) {
                //获取专家账号级别决定上报的级别
                ComSanshuoExpert expert = comSanShuoExpertService.getById(comEvent.getSpecialistId());
                if (expert.getLevel().equals(4)){
                    //上报到社区
                    //查询社区账号，由专家转交到社区
                    comEvent.setCurrentProcessType(2);
                    comEvent.setSpecialistName("待分配");
                    comEvent.setSpecialistId(99999L);
                    comEvent.setReportCommunity(1);
                    ComActDO comActDO = comActDAO.selectById(expert.getCommunityId());
                    comEvent.setCurrentOrgId(comActDO.getStreetId().toString());
                    //生成一次流转记录
                    comEvent.setCurrentEventProcessResult("(专家上报到"+comActDO.getName()+")"+comEventConciliationVO.getCurrentEventProcessResult());
                    //更改当前处理部门
                    comEvent.setCurrentOrgName(comActDO.getName()+"调解站");
                    comEventTransferRecord.setFromId(comEvent.getSpecialistId());
                    comEventTransferRecord.setToId(Long.parseLong(comEvent.getCurrentOrgId()));
                    comEventTransferRecord.setReportLevel(4);
                    comEvent.setReportLevel(4);
                }else if (expert.getLevel().equals(2)){
                    //上报到行业分中心
                    comEvent.setReportCenter(1);
                    comEvent.setCurrentProcessType(1);
                    comEvent.setCurrentOrgId(expert.getIndustryCenterId().toString());
                    comEvent.setSpecialistName("待分配");
                    comEvent.setSpecialistId(99999L);
                    //生成一次流转记录
                    ComSanshuoIndustryCenter center = comSanShuoIndustryCenterService.getById(comEvent.getCurrentOrgId());
                    comEvent.setCurrentEventProcessResult("(专家上报到"+center.getName()+")"+comEventConciliationVO.getCurrentEventProcessResult());
                    comEvent.setCurrentOrgName(expert.getUnit());
                    comEventTransferRecord.setFromId(comEvent.getSpecialistId());
                    comEventTransferRecord.setToId(expert.getIndustryCenterId());
                    comEventTransferRecord.setReportLevel(3);
                    comEvent.setReportLevel(3);
                }
            }else if (comEvent.getCurrentProcessType() == 1){
                //行业分中心上报到区三说会堂
                comEvent.setCurrentProcessType(4);
                comEvent.setCurrentOrgId("99999");
                //生成一次流转记录
                comEvent.setReportHall(1);
                comEvent.setCurrentEventProcessResult("(行业分中心上报到区三说会堂中心)"+comEventConciliationVO.getCurrentEventProcessResult());
                comEvent.setCurrentOrgName("区三说会堂");
                comEventTransferRecord.setFromId(comEvent.getSpecialistId());
                comEventTransferRecord.setToId(99999L);
                comEventTransferRecord.setReportLevel(5);
                comEvent.setReportLevel(5);
            }else if(comEvent.getCurrentProcessType() == 2){
                //社区上报到街道
                comEvent.setCurrentProcessType(3);
                //获取街道id
                comEvent.setReportStreet(1);
                ComActDO comActDO = comActDAO.selectOne(new QueryWrapper<ComActDO>().lambda().eq(ComActDO::getCommunityId, comEvent.getRequestUserCommunity()).eq(ComActDO::getAppId, "wx0cef797390444b75"));
                comEvent.setCurrentOrgId(comActDO.getStreetId().toString());
                //生成一次流转记录
                comEvent.setCurrentEventProcessResult("(社区上报到"+comStreetDAO.selectById(comActDO.getStreetId()).getName()+")"+comEventConciliationVO.getCurrentEventProcessResult());
                comEvent.setCurrentOrgName(comStreetDAO.selectById(comActDO.getStreetId()).getName()+"调解站");
                comEventTransferRecord.setFromId(comEvent.getRequestUserCommunity());
                comEventTransferRecord.setToId(comActDO.getStreetId());
                comEventTransferRecord.setReportLevel(2);
                comEvent.setReportLevel(2);
            }else if(comEvent.getCurrentProcessType() == 3){
                //街道上报到区三说会堂
                comEvent.setCurrentProcessType(4);
                comEvent.setReportHall(1);
                comEvent.setCurrentOrgId("99999");
                comEvent.setCurrentOrgName("区三说会堂");
                //生成一次流转记录
                comEvent.setCurrentEventProcessResult("(街道上报到区三说会堂中心)"+comEventConciliationVO.getCurrentEventProcessResult());
                comEventTransferRecord.setFromId(Long.parseLong(comEvent.getCurrentOrgId()));
                comEventTransferRecord.setReportLevel(1);
                comEvent.setReportLevel(1);
            }else {
                //已是最高上报级别，无法上报
            }
        }

        //是否为已完成并且不上报
        if (!comEventConciliationVO.getReportSuperior() && comEventConciliationVO.getEventSucceed().equals(2)){
            comEvent.setIsEnd(1);
        }
        int flag = baseMapper.updateById(comEvent);
        comEventTransferRecord.setEventId(comEvent.getId());
        comEventTransferRecord.setSave(true);
        comEventTransferRecord.setProcessResult(comEvent.getCurrentEventProcessResult());
        comEventTransferRecord.setProcessResultData(new Date().toString());
        comEventTransferRecord.setProcessDate(new Date());
        comEventTransferRecord.setProcessBy(loginUserInfo.getUserId());
        comEventTransferRecord.setProcessByName(loginUserInfo.getName());
        comEventTransferRecord.setProcessType(1);
        comEventTransferRecord.setCreateAt(new Date());
        comEventTransferRecord.setSpecialistId(comEvent.getSpecialistId());
        comEventTransferRecord.setSpecialistOrg(comEvent.getCurrentOrgId());
        comEventTransferRecord.setSpecialistLevel(comEvent.getSpecialistLevel());
        comEventTransferRecord.setSpecialistName(comEvent.getSpecialistName());
        comEventTransferRecord.setEventResult(comEvent.getEventSucceed());
        comEventTransferRecord.setEventStatus(comEvent.getEventProcessStatus());
        //雪花id失效，使用eventId随机生成
        comEventTransferRecord.setId(Snowflake.getId());
        //saveEventImageList(comEvent.getImages(),comEvent.getId(),comEventTransferRecord.getId(),4);
        saveEventImageList(comEventConciliationVO.getImages(), comEventConciliationVO.getId(),comEventTransferRecord.getId(),4);
        comEventTransferRecordService.insertComEventTransferRecord(comEventTransferRecord);
        return flag > 0 ? R.ok() : R.fail(ReturnMsgConstants.UPDATE_FALSE);
    }

    /**
     * 创建上报记录
     * */
    public  void createTransferLog(ComEventTransferRecord record) {
        record.setId(Snowflake.getId());
        comEventTransferRecordService.insertComEventTransferRecord(record);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public R cancelRequest(Long id) {
        ComEvent comEvent = baseMapper.selectById(id);
        if (comEvent.getEventProcessStatus() == SanShuoEventStatusEnum.UNDO.getCode().intValue()
                || comEvent.getEventProcessStatus() == SanShuoEventStatusEnum.VALID.getCode().intValue()) {
            comEvent.setId(id);
            comEvent.setUserEventStatus(4);
            comEvent.setEventProcessStatus(9);
            comEvent.setRevokeDes("用户手动取消");
            comEvent.setRevokeDate(new Date());
            int flag = baseMapper.updateById(comEvent);
            return flag > 0 ? R.ok() : R.fail(ReturnMsgConstants.UPDATE_FALSE);
        } else {
            return R.fail("当前申请已经受理，不能取消！");
        }
    }

    @Override
    public HashMap detail(String id) {
        HashMap map = new HashMap(3);
        ComEventDetailVO comEventDetailVO = new ComEventDetailVO();
        ComEvent comEvent = baseMapper.selectById(id);
        ComSanshuoExpert specter = comSanShuoExpertService.getById(comEvent.getSpecialistId());
        CopyUtil.copyProperties(comEvent, comEventDetailVO);
        comEventDetailVO.setCategoryName(commediateTypeService.getById(comEventDetailVO.getEventCategory()).getName());
        List<ComEventResource> resourceList = comEventResourceService.list(new QueryWrapper<ComEventResource>().lambda().eq(ComEventResource::getRefId, id)
                .eq(ComEventResource::getStatus,1));
        List<ComEventRequestImageVO> comEventRequestImageVO = CopyUtil.deepCopyListObject(resourceList, ComEventRequestImageVO.class);
        comEventDetailVO.setImages(comEventRequestImageVO);
        map.put("specter", specter);
        map.put("eventDetail", comEventDetailVO);
        List<ComEventTransferRecord> archiveLog=new ArrayList<>();
        List<ComEventTransferRecord> transferRecord = comEventTransferRecordService.list(new QueryWrapper<ComEventTransferRecord>().lambda().eq(ComEventTransferRecord::getEventId, id).orderByDesc(ComEventTransferRecord::getCreateAt));
        transferRecord.forEach(comEventTransferRecord -> {
            List<ComEventResource> list = comEventResourceService.list(new QueryWrapper<ComEventResource>().lambda().eq(ComEventResource::getRefId, comEvent.getId()).notIn(ComEventResource::getStatus,(1)).eq(ComEventResource::getTransferId, comEventTransferRecord.getId()));
            List<ComEventRequestImageVO> ImageVO = CopyUtil.deepCopyListObject(list, ComEventRequestImageVO.class);
            comEventTransferRecord.setImages(ImageVO);
            if (comEventTransferRecord.getEventStatus().equals(7)){
                archiveLog.add(comEventTransferRecord);
            }
        });
        map.put("archiveLog", archiveLog);
        //迭代器迭代删除归档记录
        Iterator<ComEventTransferRecord> iterator = transferRecord.iterator();
        while (iterator.hasNext()){
            ComEventTransferRecord comEventTransferRecord = iterator.next();
            if (comEventTransferRecord.getEventStatus().equals(7)){
                iterator.remove();
            }
        }
        map.put("transferLog", transferRecord);
        List<ComEventResource> resource = comEventResourceService.list(new QueryWrapper<ComEventResource>().lambda().eq(ComEventResource::getRefId, id)
                .eq(ComEventResource::getStatus, 5));
        map.put("archiveImage", resource);
        map.put("contact", getPhone(comEvent));
        return map;
    }

    public String getPhone(ComEvent comEvent)
    {
        if(comEvent==null)
        {
            return  "";
        }
        if (isNull(comEvent.getRequestUserCommunity())){
            ComSanshuoIndustryCenter sanshuoIndustryCenter=comSanShuoIndustryCenterService.getById(comEvent.getCenterId());
            if(sanshuoIndustryCenter==null)
            {
                return "";
            }
            else
            {
                return sanshuoIndustryCenter.getPhone();
            }

        }else {
            ComActDO comActDO=comActDAO.selectById(comEvent.getRequestUserCommunity());
            if(comActDO!=null)
            {
                String contactsPhone = comActDO.getContactsPhone();
                if (isNull(contactsPhone)){
                    return "";
                }
                else
                {
                    return contactsPhone;
                }
            }
            return "";
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public R acceptRequest(Long id, Long specterId) {
        ComEvent comEvent = new ComEvent();
        comEvent.setId(id);
        comEvent.setSpecialistId(specterId);
        ComSanshuoExpert specter = comSanShuoExpertService.getById(specterId);
        comEvent.setSpecialistAcceptTime(new Date());
        comEvent.setSpecialistName(specter.getName());
        comEvent.setEventProcessStatus(SanShuoEventStatusEnum.conciliation.getCode());
        int flag = baseMapper.updateById(comEvent);
        return flag > 0 ? R.ok() : R.fail(ReturnMsgConstants.UPDATE_FALSE);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public R reappoint(Long id, Long specialistId) {
        ComEvent comEvent = new ComEvent();
        comEvent.setId(id);
        comEvent.setSpecialistId(specialistId);
        ComSanshuoExpert specter = comSanShuoExpertService.getById(specialistId);
        comEvent.setSpecialistAcceptTime(new Date());
        comEvent.setSpecialistName(specter.getName());
        comEvent.setEventProcessStatus(SanShuoEventStatusEnum.VALID.getCode());
        int flag = baseMapper.updateById(comEvent);
        ComEvent comEvent1 = comEventMapper.selectById(id);
        sendMessage(specialistId,comEvent1 );
        //添加一条对应记录
        comEventMapper.insertEventAndExpertRecord(id, specialistId,1);
        return flag > 0 ? R.ok() : R.fail(ReturnMsgConstants.UPDATE_FALSE);
    }

    @Override
    public R calculate(LoginUserInfoVO loginUserInfoVO,Integer level,Long id) {
        ComEvent comEvent=new ComEvent();
        Boolean isExpertCheck=false;
        Long expertId=null;
        Boolean isStretAccount = isStreetAccount(loginUserInfoVO);
        if (loginUserInfoVO.getType().equals(13) || loginUserInfoVO.getType().equals(11)){
                ComSanshuoExpert expert=new ComSanshuoExpert();
                //专家后台账号
            if (nonNull(loginUserInfoVO.getPhone())){
                    expert = comSanShuoExpertService.getOne(new QueryWrapper<ComSanshuoExpert>().lambda().eq(ComSanshuoExpert::getPhone, loginUserInfoVO.getPhone()));
            }else{
                    //账号获取
                    expert = comSanShuoExpertService.getOne(new QueryWrapper<ComSanshuoExpert>().lambda().eq(ComSanshuoExpert::getAccount, loginUserInfoVO.getAccount()));
            }
            comEvent.setUserType(2);
            if (nonNull(expert)){
                    comEvent.setSpecialistId(expert.getId());
                    isExpertCheck=true;
                    expertId=expert.getId();
//                    level=expert.getLevel();
//                    id=expert.getCommunityId();
                    comEvent.setCommunityId(expert.getCommunityId());
            }


            }else if (loginUserInfoVO.getType().equals(12)){
                //行业分中心权限
                comEvent.setUserType(3);
                //获取行业分中心id
                ComSanshuoIndustryCenter center = comSanShuoIndustryCenterService.getOne(new QueryWrapper<ComSanshuoIndustryCenter>().lambda().eq(ComSanshuoIndustryCenter::getAccount, loginUserInfoVO.getAccount()));
                if (nonNull(center)){
                    comEvent.setCenterId(center.getId().toString());
                }
            }else if (loginUserInfoVO.getType().equals(3)){
                //社区后台权限
                comEvent.setUserType(4);
                comEvent.setCommunityId(loginUserInfoVO.getCommunityId());
            }else if (isStretAccount){
                //街道权限，查看街道范围下的所有社区事件
                //获取街道下属社区id
                List<Long> cids = comActDAO.selectCommunityByStreetId(loginUserInfoVO.getStreetId());
                comEvent.setUserType(5);
                comEvent.setCommunityIds(cids);
        }
        if (isExpertCheck){
            List<Long> eventIds = comEventMapper.listEventIds(expertId);
            if(eventIds!=null && eventIds.size()>0){

                //获取该专家的所有事件
                comEvent.setEventIds(eventIds);
            }
        }
        if (nonNull(loginUserInfoVO.getAccount())){
            if (loginUserInfoVO.getAccount().equals("admin")){
                comEvent.setUserType(9);
            }
        }
        log.info("当前userType===="+comEvent.getUserType());
        //comEvent.setAppId(loginUserInfoVO.getAppId());
//        R<LoginUserInfoVO> r = userService.detailUser(loginUserInfoVO.getUserId());
//        LoginUserInfoVO user = r.getData();
        LoginUserInfoVO user = loginUserInfoVO;
        if (nonNull(user.getAppId())){
            comEvent.setAppId(user.getAppId());
        }
        if (nonNull(level) && nonNull(id)){
            comEvent.setLevel(level);
            comEvent.setSearchId(id);
            comEvent.setUserType(null);
        }
        List<ComEventCalculateVO> calculateList = baseMapper.calculate(comEvent);
        ComEventCalculateVO comEventCalculateVO =new ComEventCalculateVO();
        comEventCalculateVO.setStatus("0");
        comEventCalculateVO.setSum(baseMapper.caculateSum(comEvent)+"");
        calculateList.add(comEventCalculateVO);
        return R.ok(calculateList);
    }


    @Override
    @Transactional(rollbackFor = Exception.class)
    public R archiveRequest(ComEventArchiveVO comEventArchiveVO, LoginUserInfoVO sysUser) {
        ComEvent comEvent = baseMapper.selectById(comEventArchiveVO.getId());
        //不再设置已归档状态
//        if (comEvent.getEventSucceed() == 2) {
//            comEvent.setEventProcessStatus(7);
//        } else {
//            comEvent.setEventProcessStatus(6);
//        }
        comEvent.setResult(comEventArchiveVO.getResult());
        baseMapper.updateById(comEvent);
        ComEventTransferRecord comEventTransferRecord = new ComEventTransferRecord();
        comEventTransferRecord.setEventId(comEvent.getId());
        comEventTransferRecord.setSave(true);
        comEventTransferRecord.setProcessResult(comEventArchiveVO.getResult());
        comEventTransferRecord.setProcessResultData(new Date().toString());
        comEventTransferRecord.setProcessDate(new Date());
        comEventTransferRecord.setProcessBy(sysUser.getUserId());
        comEventTransferRecord.setProcessByName(sysUser.getName());
        comEventTransferRecord.setProcessType(1);
        comEventTransferRecord.setCreateAt(new Date());
        comEventTransferRecord.setSpecialistId(comEvent.getSpecialistId());
        comEventTransferRecord.setSpecialistOrg(comEvent.getCurrentOrgId());
        comEventTransferRecord.setSpecialistLevel(comEvent.getSpecialistLevel());
        comEventTransferRecord.setSpecialistName(comEvent.getSpecialistName());
        comEventTransferRecord.setEventResult(comEvent.getEventSucceed());
        comEventTransferRecord.setFromUserId(sysUser.getUserId());
        //归档操作统一设置为7
        comEventTransferRecord.setEventStatus(7);
        comEventTransferRecord.setId(Snowflake.getId());
        saveEventImageList(comEventArchiveVO.getImages(), comEvent.getId(), comEventTransferRecord.getId(), 5);
        return comEventTransferRecordService.insertComEventTransferRecord(comEventTransferRecord);
    }


    /**
     * 大屏事件统计
     * @param indexDataDTO  查询入参
     * */
    @Override
    public R indexData(IndexDateDTO indexDataDTO) {
        IndexDateVO vo = comEventMapper.dateAnalysis(indexDataDTO,DateUtil.beginOfMonth(new Date()),DateUtil.endOfMonth(new Date()));
        //计算率
        if (nonNull(vo.getSuccess()) && !vo.getSuccess().equals(0)){
            if (nonNull(vo.getAccepted()) && !vo.getAccepted().equals(0)){
                //计算成功率
                try {
                    vo.setSuccessRate(NumberUtil.div(vo.getSuccess(),vo.getAccepted(),2));
                }catch (NullPointerException e){
                    vo.setSuccessRate(new BigDecimal(0));
                }

            }
        }
        vo.setExpert(comSanshuoExpertDao.selectExpertCount(indexDataDTO));
        //查询当前级别下的专家
        //折线图X轴
        List<Date> dates = pastTwelveMoth();
        vo.setX(getYAndM(dates));
        //新增
        List<Integer> Y1=new ArrayList<>();
        List<Integer> Y2=new ArrayList<>();
        for (Date date : dates) {
            Y1.add(comEventMapper.dateAnalysisY(date,DateUtil.endOfMonth(date),indexDataDTO));
            Y2.add(comEventMapper.dateAnalysisYTwo(date,DateUtil.endOfMonth(date),indexDataDTO));
        }
        vo.setY1(Y1);
        vo.setY2(Y2);
        return R.ok(vo);
    }


    @Override
    public R eventIndexData(Integer type) {
        //获取事件总数
        Integer eventCount = comEventMapper.selectCount(new QueryWrapper<ComEvent>().notIn("event_process_status",(9)));
        if (type.equals(1)){
            //受理级别占比
            List<EventRateVO> eventRateVOS = comEventMapper.eventRate();
            //获取专家受理的数量
            Integer expertCount=comEventMapper.expertSolveCountCommunity();
            //获取行业分中心受理数量
            Integer centerCount=comEventMapper.expertSolveCountCenter();
            for (EventRateVO eventRateVO : eventRateVOS) {
                if (nonNull(eventRateVO)){
                    eventRateVO.setName(typeToName(eventRateVO.getType()));
//                    if (eventRateVO.getCurrentProcessType().equals(2)){
//                        eventRateVO.setCount(eventRateVO.getCount()+expertCount);
//                    }
//                    if (eventRateVO.getCurrentProcessType().equals(1)){
//                        eventRateVO.setCount(eventRateVO.getCount()+centerCount);
//                    }
                    if (nonNull(eventCount) && !eventCount.equals(0)){
                        //计算占比
                        eventRateVO.setRate(NumberUtil.div(eventRateVO.getCount(),eventCount,2));
                    }
                }
            }
            return R.ok(eventRateVOS);
        }else if (type.equals(2)){
            //专家级别
            List<EventRateVO> eventRateVOS = comEventMapper.expertRate();
            for (EventRateVO eventRateVO : eventRateVOS) {
                if (nonNull(eventRateVO)){
                    eventRateVO.setName(typeToNameExpert(eventRateVO.getType()));
                    if (nonNull(eventCount) && !eventCount.equals(0)){
                        //计算占比
                        eventRateVO.setRate(NumberUtil.div(eventRateVO.getCount(),eventCount,2));
                    }
                }
            }
            return R.ok(eventRateVOS);
        }else{
            //事件类型占比
            List<EventRateVO> eventRateVOS = comEventMapper.mediateTypeRate();
            for (EventRateVO eventRateVO : eventRateVOS) {
                if (nonNull(eventRateVO)){
                    if (nonNull(eventCount) && !eventCount.equals(0)){
                        //计算占比
                        eventRateVO.setRate(NumberUtil.div(eventRateVO.getCount(),eventCount,2));
                    }
                }
            }
            return R.ok(eventRateVOS);
        }
    }

    @Override
    public void updateEventStransferRecord(Long id) {
        ComEvent comEvent = comEventMapper.selectById(id);
        comEventMapper.updateLog(id,comEvent.getSpecialistId());
    }

    @Override
    public R listStreetScreen() {
        return R.ok(comStreetDAO.selectList(new QueryWrapper<ComStreetDO>().eq("app_id", "wx0cef797390444b75").in("name",("大宝鼎街道"),("格里坪镇"),("河门口街道"),("清香坪街道"),("陶家渡街道"),("玉泉街道"))));
    }

    @Override
    public R listCommunityScreen() {
        return R.ok(comActDAO.selectList(new QueryWrapper<ComActDO>().lambda().eq(ComActDO::getAppId, "wx0cef797390444b75").in(ComActDO::getStreetId,("1552661139563876352"),("1552661132500668416"),("1552661143879815168"),("1552661138704044032"),("1552661135428292608"),("1552661136451702784"))));
    }

    public String typeToName(Integer type){
        switch (type){
            case 1:
                return "行业分中心受理";
            case 3:
                return "镇/街道受理案件";
            case 2:
                return "村/社区受理案件";
            case 4:
                return "区三说会堂中心受理";
        }
        return null;
    }

    public String typeToNameExpert(Integer type){
        switch (type){
            case 1:
                return "区三说会堂中心专家";
            case 2:
                return "行业分中心专家";
            case 3:
                return "镇/街道调解专家";
            case 4:
                return "村/社区调解专家";
        }
        return null;
    }

    /**
     * 过去12个月的月份
     * */
    private List<Date> pastTwelveMoth(){
        List<Date> list=new ArrayList<>();
        Date now = new Date();
        for (int i = 0; i < 12; i++) {
            //本月
            DateTime dateTime = DateUtil.beginOfMonth(now);
            DateUtil.format(dateTime,"yyyy-MM-dd");
            list.add(dateTime);
            //减一天进入下一个月
            now=DateUtil.offsetDay(dateTime,-1);
        }
        return list;
    }

    /**
     * 截取年，月
     * */
    private List<String> getYAndM(List<Date> dateList){
        List<String> list=new ArrayList<>();
        for (Date date : dateList) {
            list.add(DateUtil.format(date,"yyyy-MM").toString());
        }
        return list;
    }


    private Boolean checkExist(String sn, Long id) {
        ComEvent comEvent = new ComEvent();
        comEvent.setOrderSn(sn);
        QueryWrapper<ComEvent> queryWrapper = new QueryWrapper<>(comEvent);
        if (id != null) {
            queryWrapper.ne("id", id);
        }
        Integer count = baseMapper.selectCount(queryWrapper);
        return count > 0;
    }
}