package com.doumee.service.business.impl;

import cn.hutool.core.util.IdcardUtil;
import com.alibaba.fastjson.JSONObject;
import com.doumee.biz.system.SystemDictDataBiz;
import com.doumee.core.annotation.excel.ExcelImporter;
import com.doumee.core.constants.ResponseStatus;
import com.doumee.core.exception.BusinessException;
import com.doumee.service.business.third.model.LoginUserInfo;
import com.doumee.service.business.third.model.PageData;
import com.doumee.service.business.third.model.PageWrap;
import com.doumee.core.utils.Constants;
import com.doumee.core.utils.DESUtil;
import com.doumee.core.utils.DateUtil;
import com.doumee.dao.admin.request.TrainTimeImport;
import com.doumee.dao.business.EmpowerMapper;
import com.doumee.dao.business.MemberRoleMapper;
import com.doumee.dao.business.TrainTimeMapper;
import com.doumee.dao.business.join.MemberJoinMapper;
import com.doumee.dao.business.join.TrainTimeJoinMapper;
import com.doumee.dao.business.join.UserActionJoinMapper;
import com.doumee.dao.business.model.Company;
import com.doumee.dao.business.model.Member;
import com.doumee.dao.business.model.TrainTime;
import com.doumee.dao.system.model.SystemUser;
import com.doumee.service.business.TrainTimeService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.web.multipart.MultipartFile;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 人员培训有效期记录Service实现
 * @author 江蹄蹄
 * @date 2023/11/30 15:33
 */
@Service
public class TrainTimeServiceImpl implements TrainTimeService {

    @Value("${debug_model}")
    private Boolean isDebug;
    @Autowired
    private TrainTimeMapper trainTimeMapper;

    @Autowired
    private SystemDictDataBiz systemDictDataBiz;
    @Autowired
    private TrainTimeJoinMapper trainTimeJoinMapper;
    @Autowired
    private MemberJoinMapper memberJoinMapper;
    @Autowired
    private MemberRoleMapper memberRoleMapper;
    @Autowired
    private EmpowerMapper empowerMapper;

    @Autowired
    private UserActionJoinMapper userActionJoinMapper;
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;


    @Override
    public Integer create(TrainTime trainTime) {
        trainTimeMapper.insert(trainTime);
        return trainTime.getId();
    }

    @Override
    public void deleteById(Integer id) {
        trainTimeMapper.deleteById(id);
    }

    @Override
    public void delete(TrainTime trainTime) {
        UpdateWrapper<TrainTime> deleteWrapper = new UpdateWrapper<>(trainTime);
        trainTimeMapper.delete(deleteWrapper);
    }

    @Override
    public void deleteByIdInBatch(List<Integer> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return;
        }
        trainTimeMapper.deleteBatchIds(ids);
    }

    @Override
    public void updateById(TrainTime trainTime) {
        trainTimeMapper.updateById(trainTime);
    }

    @Override
    public void updateByIdInBatch(List<TrainTime> trainTimes) {
        if (CollectionUtils.isEmpty(trainTimes)) {
            return;
        }
        for (TrainTime trainTime: trainTimes) {
            this.updateById(trainTime);
        }
    }

    @Override
    public TrainTime findById(Integer id) {
        return trainTimeMapper.selectById(id);
    }

    @Override
    public TrainTime findOne(TrainTime trainTime) {
        QueryWrapper<TrainTime> wrapper = new QueryWrapper<>(trainTime);
        return trainTimeMapper.selectOne(wrapper);
    }

    @Override
    public List<TrainTime> findList(TrainTime trainTime) {
        QueryWrapper<TrainTime> wrapper = new QueryWrapper<>(trainTime);
        return trainTimeMapper.selectList(wrapper);
    }

    @Override
    public PageData<TrainTime> findPage(PageWrap<TrainTime> pageWrap) {
        IPage<TrainTime> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        MPJLambdaWrapper<TrainTime> queryWrapper = new MPJLambdaWrapper<>();

        queryWrapper.leftJoin(Member.class,Member::getId,TrainTime::getMemberId);
        queryWrapper.leftJoin(Company.class,Company::getId,Member::getCompanyId);
        queryWrapper.leftJoin(SystemUser.class,SystemUser::getId,TrainTime::getCreator);

        queryWrapper.selectAll(TrainTime.class);
        queryWrapper.selectAs(Member::getName,TrainTime::getName);
        queryWrapper.selectAs(Member::getPhone,TrainTime::getPhone);
        queryWrapper.selectAs(Member::getFaceImg,TrainTime::getFaceImg);
        queryWrapper.selectAs(Member::getIdcardDecode,TrainTime::getIdcardNo);
        queryWrapper.selectAs(Company::getCompanyNamePath,TrainTime::getCompanyName);
        queryWrapper.selectAs(SystemUser::getRealname,TrainTime::getCreateName);
        queryWrapper.eq(TrainTime::getIsdeleted, Constants.ZERO);
        queryWrapper.ge(pageWrap.getModel().getStartTimeStart() != null, TrainTime::getStartTime,  pageWrap.getModel().getStartTimeStart());
        queryWrapper.le(pageWrap.getModel().getStartTimeEnd() != null, TrainTime::getStartTime, pageWrap.getModel().getStartTimeEnd());

        queryWrapper.and(StringUtils.isNotBlank(pageWrap.getModel().getName()), ms->ms.like(Member::getPhone,pageWrap.getModel().getName())
                .or().like(Member::getName,pageWrap.getModel().getName()));
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getCompanyName()),Company::getName,pageWrap.getModel().getCompanyName());
        queryWrapper.orderByDesc(TrainTime::getId);
        IPage<TrainTime> result = trainTimeJoinMapper.selectJoinPage(page, TrainTime.class,queryWrapper);
        if(result!=null && result.getRecords()!=null){
            String path =  systemDictDataBiz.queryByCode(Constants.FTP,Constants.FTP_RESOURCE_PATH).getCode() +
                    systemDictDataBiz.queryByCode(Constants.FTP,Constants.MEMBER_IMG).getCode();
            for(TrainTime model : result.getRecords()){
                if(StringUtils.isNotBlank(model.getFaceImg())){
                    model.setFaceImg(path +model.getFaceImg());
                }
            }
        }
        return PageData.from(result);
    }

    @Override
    public long count(TrainTime trainTime) {
        QueryWrapper<TrainTime> wrapper = new QueryWrapper<>(trainTime);
        return trainTimeMapper.selectCount(wrapper);
    }

    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public String importBatch(MultipartFile file,  LoginUserInfo loginUserInfo){
        Boolean importing = (Boolean) redisTemplate.opsForValue().get(com.doumee.core.utils.Constants.RedisKeys.IMPORTING_MEMBER);
        if(importing!=null && importing){
            throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"对不起，已存在员工导入任务正在执行中，请稍后再试！");
        }
        redisTemplate.opsForValue().set(com.doumee.core.utils.Constants.RedisKeys.IMPORTING_MEMBER,true);
        try {
            ExcelImporter ie = null;
            List<TrainTimeImport> dataList =null;
            try {
                ie = new ExcelImporter(file,1,0);
                dataList = ie.getDataList(TrainTimeImport.class,null);
            }  catch (Exception e) {
                e.printStackTrace();
            }
            if(dataList == null || dataList.size() ==0){
                throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"对不起，录入数据为空！");
            }
            //查询全部相关方人员信息
            List<Member> list =  memberJoinMapper.selectJoinList(Member.class,new MPJLambdaWrapper<Member>()
                    .selectAll(Member.class)
                    .leftJoin(Company.class,Company::getId,Member::getCompanyId)
                    .eq(Company::getType,Constants.ZERO)
//                    .in(Company::getId,loginUserInfo.getCompanyIdList() )
                    .eq(Member::getIsdeleted, com.doumee.core.utils.Constants.ZERO));
            List<TrainTime> newList = new ArrayList<>();
            for(int i=0;i<dataList.size();i++){
                TrainTimeImport model = dataList.get(i);
                if(StringUtils.isBlank(model.getName())
                        &&StringUtils.isBlank(model.getIdcardNo())
                        && StringUtils.isBlank(model.getStartTimeStr())
                        && StringUtils.isBlank(model.getEndTimeStr()) ){
                    continue;
                }

                model.setStartTime(DateUtil.getDateFromString2(model.getStartTimeStr()));
                model.setEndTime(DateUtil.getDateFromString2(model.getEndTimeStr()));
                TrainTime insert = checkModelParam(model,i,loginUserInfo,list);
                newList.add(insert);
                //更新用户下发状态为待下发
                memberJoinMapper. update(null,new UpdateWrapper<Member>().lambda()
                        .set(Member::getStartTime,null)
                        .set(Member::getEndTime,null)
                        .set(Member::getRoleId,null)
                        .set(Member::getEditDate,insert.getEditDate())
                        .set(Member::getEditor,insert.getCreator())
                         .set(Member::getAuthStatus, Constants.ZERO)
                        .eq(Member::getId,insert.getId()));
                Member member = new Member();
                member.setId(insert.getMemberId());
                member.setEditor(insert.getCreator());
                member.setEditDate(insert.getCreateDate());
                MemberServiceImpl.saveUserActionBiz(member,loginUserInfo,Constants.UserActionType.IMPORT_TRAIMETIME,userActionJoinMapper, JSONObject.toJSONString(insert));
                //取消授权
                MemberServiceImpl.cancelAllMemberEmpower(member,memberRoleMapper,empowerMapper);
            }
            if(newList == null || newList.size() ==0){
                throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"对不起，录入有效数据为空！");
            }
            trainTimeMapper.insert(newList);
            return "导入成功";
        }catch (BusinessException e){
            throw e;
        }catch (Exception e){
            e.printStackTrace();
            throw  new BusinessException(ResponseStatus.SERVER_ERROR.getCode(),"员工信息导入失败，请稍后重试");
        }finally {
            redisTemplate.delete( Constants.RedisKeys.IMPORTING_MEMBER);
        }
    }

    private TrainTime checkModelParam(TrainTimeImport model, int index, LoginUserInfo loginUserInfo, List<Member> list) {
        if(StringUtils.isBlank(model.getName())
                || StringUtils.isBlank(model.getIdcardNo())
                || model.getStartTime()==null
                ||  model.getEndTime()==null
                ||  model.getEndTime().getTime() < model.getStartTime().getTime() ){
            throw  new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"对不起，第"+(index+3)+"行人员信息不完整,或者有效期不合法，请检查表格内容！");
        }
        if (  !isDebug &&  !IdcardUtil.isValidCard(model.getIdcardNo())){
            throw  new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"对不起，第"+(index+3)+"行身份证号【"+model.getIdcardNo()+"】格式不正确，请检查表格内容！");
        }
        Member m = MemberServiceImpl.findMemberFromListByIdcard( DESUtil.encrypt(Constants.EDS_PWD, model.getIdcardNo()),list);
        if(m == null){
            throw  new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"对不起，第"+(index+3)+"行身份证号【"+model.getIdcardNo()+"】不存在，请检查表格内容！");
        }
        TrainTime trainTime = new TrainTime();
        trainTime.setIsdeleted(Constants.ZERO);
        trainTime.setCreator(loginUserInfo.getId());
        trainTime.setCreateDate(new Date());
        trainTime.setEdirot(loginUserInfo.getId());
        trainTime.setEditDate(trainTime.getCreateDate());
        trainTime.setStartTime(model.getStartTime());
        trainTime.setEndTime(model.getEndTime());
        trainTime.setMemberId(m.getId());
        trainTime.setImportStatus(Constants.ZERO);
        trainTime.setImportInfo("由【"+loginUserInfo.getRealname()+"】于"+DateUtil.getPlusTime2(trainTime.getCreateDate())+"导入");
        return trainTime;
    }


}