package com.doumee.service.business.impl;

import com.doumee.core.constants.ResponseStatus;
import com.doumee.core.exception.BusinessException;
import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.core.utils.Constants;
import com.doumee.core.utils.Utils;
import com.doumee.dao.business.YwTempConfigMapper;
import com.doumee.dao.business.dto.YwCallTempDataDTO;
import com.doumee.dao.business.model.YwTempConfig;
import com.doumee.dao.business.vo.YwCallTempDataVO;
import com.doumee.service.business.YwTempConfigService;
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 org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Collectors;

/**
 * 催缴信息配置Service实现
 * @author 江蹄蹄
 * @date 2025/01/10 09:43
 */
@Service
public class YwTempConfigServiceImpl implements YwTempConfigService {

    @Autowired
    private YwTempConfigMapper ywTempConfigMapper;

    @Override
    public Integer create(YwTempConfig ywTempConfig) {
        ywTempConfigMapper.insert(ywTempConfig);
        return ywTempConfig.getId();
    }

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

    @Override
    public void delete(YwTempConfig ywTempConfig) {
        UpdateWrapper<YwTempConfig> deleteWrapper = new UpdateWrapper<>(ywTempConfig);
        ywTempConfigMapper.delete(deleteWrapper);
    }

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

    @Override
    public void updateById(YwTempConfig ywTempConfig) {
        ywTempConfigMapper.updateById(ywTempConfig);
    }

    @Override
    public void updateByIdInBatch(List<YwTempConfig> ywTempConfigs) {
        if (CollectionUtils.isEmpty(ywTempConfigs)) {
            return;
        }
        for (YwTempConfig ywTempConfig: ywTempConfigs) {
            this.updateById(ywTempConfig);
        }
    }

    @Override
    public YwTempConfig findById(Integer id) {
        return ywTempConfigMapper.selectById(id);
    }

    @Override
    public YwTempConfig findOne(YwTempConfig ywTempConfig) {
        QueryWrapper<YwTempConfig> wrapper = new QueryWrapper<>(ywTempConfig);
        return ywTempConfigMapper.selectOne(wrapper);
    }

    @Override
    public List<YwTempConfig> findList(YwTempConfig ywTempConfig) {
        QueryWrapper<YwTempConfig> wrapper = new QueryWrapper<>(ywTempConfig);
        return ywTempConfigMapper.selectList(wrapper);
    }
  
    @Override
    public PageData<YwTempConfig> findPage(PageWrap<YwTempConfig> pageWrap) {
        IPage<YwTempConfig> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        QueryWrapper<YwTempConfig> queryWrapper = new QueryWrapper<>();
        Utils.MP.blankToNull(pageWrap.getModel());
        if (pageWrap.getModel().getId() != null) {
            queryWrapper.lambda().eq(YwTempConfig::getId, pageWrap.getModel().getId());
        }
        if (pageWrap.getModel().getCreator() != null) {
            queryWrapper.lambda().eq(YwTempConfig::getCreator, pageWrap.getModel().getCreator());
        }
        if (pageWrap.getModel().getCreateDate() != null) {
            queryWrapper.lambda().ge(YwTempConfig::getCreateDate, Utils.Date.getStart(pageWrap.getModel().getCreateDate()));
            queryWrapper.lambda().le(YwTempConfig::getCreateDate, Utils.Date.getEnd(pageWrap.getModel().getCreateDate()));
        }
        if (pageWrap.getModel().getEditor() != null) {
            queryWrapper.lambda().eq(YwTempConfig::getEditor, pageWrap.getModel().getEditor());
        }
        if (pageWrap.getModel().getEditDate() != null) {
            queryWrapper.lambda().ge(YwTempConfig::getEditDate, Utils.Date.getStart(pageWrap.getModel().getEditDate()));
            queryWrapper.lambda().le(YwTempConfig::getEditDate, Utils.Date.getEnd(pageWrap.getModel().getEditDate()));
        }
        if (pageWrap.getModel().getIsdeleted() != null) {
            queryWrapper.lambda().eq(YwTempConfig::getIsdeleted, pageWrap.getModel().getIsdeleted());
        }
        if (pageWrap.getModel().getRemark() != null) {
            queryWrapper.lambda().eq(YwTempConfig::getRemark, pageWrap.getModel().getRemark());
        }
        if (pageWrap.getModel().getType() != null) {
            queryWrapper.lambda().eq(YwTempConfig::getType, pageWrap.getModel().getType());
        }
        if (pageWrap.getModel().getTitle() != null) {
            queryWrapper.lambda().eq(YwTempConfig::getTitle, pageWrap.getModel().getTitle());
        }
        if (pageWrap.getModel().getUrl() != null) {
            queryWrapper.lambda().eq(YwTempConfig::getUrl, pageWrap.getModel().getUrl());
        }
        for(PageWrap.SortData sortData: pageWrap.getSorts()) {
            if (sortData.getDirection().equalsIgnoreCase(PageWrap.DESC)) {
                queryWrapper.orderByDesc(sortData.getProperty());
            } else {
                queryWrapper.orderByAsc(sortData.getProperty());
            }
        }
        return PageData.from(ywTempConfigMapper.selectPage(page, queryWrapper));
    }

    @Override
    public long count(YwTempConfig ywTempConfig) {
        QueryWrapper<YwTempConfig> wrapper = new QueryWrapper<>(ywTempConfig);
        return ywTempConfigMapper.selectCount(wrapper);
    }



    @Override
    public YwCallTempDataVO getCallTemp(){
        YwCallTempDataVO ywCallTempDataVO = new YwCallTempDataVO();
        List<YwTempConfig> ywTempConfigList = ywTempConfigMapper.selectList(new QueryWrapper<YwTempConfig>().lambda()
                .eq(YwTempConfig::getIsdeleted, Constants.ZERO));
        Optional<YwTempConfig> smsOptional = ywTempConfigList.stream().filter(i->Constants.equalsInteger(i.getType(),
                Constants.ZERO)).findAny();
        if (smsOptional.isPresent()) {
            ywCallTempDataVO.setSmsTemp(smsOptional.get());
        }
        Optional<YwTempConfig> emailOptional = ywTempConfigList.stream().filter(i->Constants.equalsInteger(i.getType(),
                Constants.ONE)).findAny();
        if (emailOptional.isPresent()) {
            ywCallTempDataVO.setEmailTemp(emailOptional.get());
        }
        Optional<YwTempConfig> leaseOptional = ywTempConfigList.stream().filter(i->Constants.equalsInteger(i.getType(),
                Constants.TWO)).findAny();
        if (leaseOptional.isPresent()) {
            ywCallTempDataVO.setLeaseTemp(leaseOptional.get());
        }
        Optional<YwTempConfig> otherOptional = ywTempConfigList.stream().filter(i->Constants.equalsInteger(i.getType(),
                Constants.THREE)).findAny();
        if (otherOptional.isPresent()) {
            ywCallTempDataVO.setOtherTemp(otherOptional.get());
        }
        ywCallTempDataVO.setContractTempList(
                ywTempConfigList.stream().filter(i->Constants.equalsInteger(i.getType(),Constants.FIVE)).collect(Collectors.toList())
        );
        ywCallTempDataVO.setBillTempList(
                ywTempConfigList.stream().filter(i->Constants.equalsInteger(i.getType(),Constants.FOUR)).collect(Collectors.toList())
        );
        ywCallTempDataVO.setOtherTempList(
                ywTempConfigList.stream().filter(i->Constants.equalsInteger(i.getType(),Constants.SIX)).collect(Collectors.toList())
        );
        return ywCallTempDataVO;
    }



    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public void updTempConfig(YwCallTempDataDTO ywCallTempDataDTO){
        if(Objects.isNull(ywCallTempDataDTO)
            || Objects.isNull(ywCallTempDataDTO.getSmsTemp())
            || Objects.isNull(ywCallTempDataDTO.getEmailTemp())
            || Objects.isNull(ywCallTempDataDTO.getLeaseTemp())
            || Objects.isNull(ywCallTempDataDTO.getOtherTemp())
        ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        YwTempConfig smsTemp = ywCallTempDataDTO.getSmsTemp();
        if(Objects.isNull(smsTemp.getId())
            || Objects.isNull(smsTemp.getTitle())){
            throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"短息模板参数错误");
        }
        ywTempConfigMapper.update(new UpdateWrapper<YwTempConfig>().lambda()
                .set(YwTempConfig::getTitle,smsTemp.getTitle())
                .eq(YwTempConfig::getId,smsTemp.getId())
        );


        YwTempConfig emailTemp = ywCallTempDataDTO.getEmailTemp();
        if(Objects.isNull(emailTemp.getId())
                || Objects.isNull(emailTemp.getTitle())){
            throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"邮件模板参数错误");
        }
        ywTempConfigMapper.update(new UpdateWrapper<YwTempConfig>().lambda()
                .set(YwTempConfig::getTitle,emailTemp.getTitle())
                .eq(YwTempConfig::getId,emailTemp.getId())
        );

        YwTempConfig leasesTemp = ywCallTempDataDTO.getLeaseTemp();
        if(Objects.isNull(leasesTemp.getId())
                || Objects.isNull(leasesTemp.getTitle())
                || StringUtils.isBlank(leasesTemp.getUrl())
        ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"租赁通知单模板参数错误");
        }
        ywTempConfigMapper.update(new UpdateWrapper<YwTempConfig>().lambda()
                .set(YwTempConfig::getTitle,leasesTemp.getTitle())
                .set(YwTempConfig::getUrl,leasesTemp.getUrl())
                .eq(YwTempConfig::getId,leasesTemp.getId())
        );
        YwTempConfig otherTemp = ywCallTempDataDTO.getOtherTemp();
        if(Objects.isNull(otherTemp.getId())
                || Objects.isNull(otherTemp.getTitle())
                || StringUtils.isBlank(otherTemp.getUrl())
        ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"其他通知单模板参数错误");
        }
        ywTempConfigMapper.update(new UpdateWrapper<YwTempConfig>().lambda()
                .set(YwTempConfig::getTitle,otherTemp.getTitle())
                .set(YwTempConfig::getUrl,otherTemp.getUrl())
                .eq(YwTempConfig::getId,otherTemp.getId())
        );

    }






}