package com.doumee.service.business.impl;

import com.doumee.biz.system.SystemDictDataBiz;
import com.doumee.core.constants.Constants;
import com.doumee.core.constants.ResponseStatus;
import com.doumee.core.exception.BusinessException;
import com.doumee.core.model.LoginUserInfo;
import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.dao.business.MultifileMapper;
import com.doumee.dao.business.model.Cases;
import com.doumee.core.utils.Utils;
import com.doumee.dao.business.CasesMapper;
import com.doumee.dao.business.model.Category;
import com.doumee.dao.business.model.Member;
import com.doumee.dao.business.model.Multifile;
import com.doumee.dao.system.model.SystemUser;
import com.doumee.service.business.CasesService;
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.apache.shiro.SecurityUtils;
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.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Objects;

/**
 * 分类信息表Service实现
 * @author doumee
 * @date 2026-01-27 16:02:37
 */
@Service
public class CasesServiceImpl implements CasesService {

    @Autowired
    private SystemDictDataBiz systemDictDataBiz;
    @Autowired
    private CasesMapper casesMapper;
    @Autowired
    private MultifileMapper multifileMapper;

    @Override
    @Transactional
    public Integer create(Cases cases) {
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(StringUtils.isBlank(cases.getName())
                ||StringUtils.isBlank(cases.getDetail())
                ||cases.getStartDate()==null
                ||cases.getEndDate()==null  ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        cases.setDeleted(Constants.ZERO);
        cases.setCreateTime(new Date());
        cases.setCreateUser(loginUserInfo.getId());
        cases.setUpdateTime(new Date());
        cases.setUpdateUser(loginUserInfo.getId());
        casesMapper.insert(cases);
        dealBatchMultiFiles(cases, cases.getFileList(), loginUserInfo,true);
        return cases.getId();
    }
    public void dealBatchMultiFiles(Cases category, List<Multifile> fileList, LoginUserInfo user,boolean update) {
        Date today = new Date();
        //清空原有的
        if(update){
            multifileMapper.delete(new UpdateWrapper<Multifile>().lambda()
                    .eq(Multifile::getIsdeleted,Constants.ZERO)
                    .eq(Multifile::getObjType,Constants.ONE)
                    .eq(Multifile::getObjId,category.getId()));
        }
        if(fileList!=null && fileList.size()>0){
            List<Multifile> multifileList = new ArrayList<>();
            fileList.stream().forEach(s -> {
                if(StringUtils.isNotBlank(s.getFileurl())){
                    s.setIsdeleted(Constants.ZERO);
                    s.setCreator(user.getId());
                    s.setCreateDate(today);
                    s.setObjId(category.getId());
                    s.setType(Constants.ZERO);
                    s.setObjType(Constants.ONE);
                    multifileList.add(s);
                }
            });
            if(multifileList.size()>0){
                multifileMapper.insert(multifileList);
            }
        }
    }
    @Override
    public void deleteById(Integer id) {
        Cases cases =new Cases();
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        cases.setUpdateTime(new Date());
        cases.setId(id);
        cases.setUpdateUser(loginUserInfo.getId());
        cases.setDeleted(Constants.ONE);
        casesMapper.updateById(cases);
    }
    @Override
    public void updateStatus(Cases cases) {
        if(Objects.isNull(cases) || Objects.isNull(cases.getId())){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        cases.setUpdateTime(new Date());
        cases.setUpdateUser(loginUserInfo.getId());
        casesMapper.updateById(cases);
    }
    @Override
    public void delete(Cases cases) {
        UpdateWrapper<Cases> deleteWrapper = new UpdateWrapper<>(cases);
        casesMapper.delete(deleteWrapper);
    }

    @Override
    public void deleteByIdInBatch(List<Integer> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return;
        }
        for(Integer id : ids){
            this.deleteById(id);
        }
    }

    @Override
    public void updateById(Cases cases) {
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(StringUtils.isBlank(cases.getName())
                ||StringUtils.isBlank(cases.getDetail())
                ||cases.getStartDate()==null
                ||cases.getEndDate()==null  ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        cases.setDeleted(Constants.ZERO);
        cases.setUpdateTime(new Date());
        cases.setUpdateUser(loginUserInfo.getId());
        casesMapper.updateById(cases);
        dealBatchMultiFiles(cases, cases.getFileList(), loginUserInfo,true);
    }

    @Override
    public void updateByIdInBatch(List<Cases> casess) {
        if (CollectionUtils.isEmpty(casess)) {
            return;
        }
        for (Cases cases: casess) {
            this.updateById(cases);
        }
    }

    @Override
    public Cases findById(Integer id) {
        return casesMapper.selectById(id);
    }

    @Override
    public Cases findOne(Cases cases) {
        QueryWrapper<Cases> wrapper = new QueryWrapper<>(cases).last("limit 1");
        return casesMapper.selectOne(wrapper);
    }

    @Override
    public List<Cases> findList(Cases cases) {
        QueryWrapper<Cases> wrapper = new QueryWrapper<>(cases);
        return casesMapper.selectList(wrapper);
    }

    @Override
    public PageData<Cases> findPage(PageWrap<Cases> pageWrap) {
        IPage<Cases> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        MPJLambdaWrapper<Cases> queryWrapper = new MPJLambdaWrapper<>();
        pageWrap.getModel().setDeleted(Constants.ZERO);
        queryWrapper.selectAll(Cases.class)
                .selectAs(Member::getName,Cases::getMemberName)
                .selectAs(Member::getCode,Cases::getMemberCode)
                .selectAs(SystemUser::getRealname, Member::getUpdateUserName)
                .leftJoin(SystemUser.class,SystemUser::getId,Cases::getUpdateUser)
                 .leftJoin(Member.class,Member::getId,Cases::getMemberId);
        Utils.MP.blankToNull(pageWrap.getModel());
        queryWrapper.eq(pageWrap.getModel().getId() != null,Cases::getId, pageWrap.getModel().getId());
        queryWrapper.eq(pageWrap.getModel().getDeleted() != null,Cases::getDeleted, pageWrap.getModel().getDeleted());
        queryWrapper.eq(pageWrap.getModel().getCreateUser() != null,Cases::getCreateUser, pageWrap.getModel().getCreateUser());
        queryWrapper.eq(pageWrap.getModel().getUpdateUser() != null,Cases::getUpdateUser, pageWrap.getModel().getUpdateUser());
        queryWrapper.eq(pageWrap.getModel().getRemark() != null,Cases::getRemark, pageWrap.getModel().getRemark());
        queryWrapper.eq(pageWrap.getModel().getStatus() != null,Cases::getStatus, pageWrap.getModel().getStatus());
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getName() ),Cases::getName, pageWrap.getModel().getName());
        queryWrapper.eq(pageWrap.getModel().getMemberId() != null,Cases::getMemberId, pageWrap.getModel().getMemberId());
        queryWrapper.eq(pageWrap.getModel().getDetail() != null,Cases::getDetail, pageWrap.getModel().getDetail());
        queryWrapper.eq(pageWrap.getModel().getImgurl() != null,Cases::getImgurl, pageWrap.getModel().getImgurl());
        queryWrapper.eq(pageWrap.getModel().getSortnum() != null,Cases::getSortnum, pageWrap.getModel().getSortnum());
        queryWrapper.eq(pageWrap.getModel().getAddType() != null,Cases::getAddType, pageWrap.getModel().getAddType());
        queryWrapper.eq(pageWrap.getModel().getImportId() != null,Cases::getImportId, pageWrap.getModel().getImportId());
        queryWrapper.orderByDesc(Cases::getId);
        PageData<Cases> result =PageData.from(casesMapper.selectJoinPage(page, Cases.class,queryWrapper));
        if(result!=null && result.getRecords()!=null){
            String path  = systemDictDataBiz.queryByCode(Constants.OBJCET_STORAGE,Constants.RESOURCE_PATH).getCode()
                    +systemDictDataBiz.queryByCode(Constants.OBJCET_STORAGE,Constants.CASES_FILES).getCode();
            for(Cases cate : result.getRecords()){
                initMultifileList(cate);
            }
        }
        return result;
    }
    private void initMultifileList(Cases cate) {
        String path = systemDictDataBiz.queryByCode(Constants.OBJCET_STORAGE, Constants.RESOURCE_PATH).getCode()
                + systemDictDataBiz.queryByCode(Constants.OBJCET_STORAGE, Constants.CASES_FILES).getCode();

        Multifile find = new Multifile();
        find.setObjId(cate.getId());
        find.setObjType(Constants.ONE);
        find.setIsdeleted(Constants.ZERO);
        List<Multifile> fileList=  multifileMapper.selectList(new QueryWrapper<>(find));
        if(fileList!=null){
            for(Multifile f : fileList){
                if(StringUtils.isNotBlank(f.getFileurl())){
                    f.setUrl(path+f.getFileurl());
                }

            }
        }
        cate.setFileList(fileList);
    }

    @Override
    public long count(Cases cases) {
        QueryWrapper<Cases> wrapper = new QueryWrapper<>(cases);
        return casesMapper.selectCount(wrapper);
    }
}