package cn.besteam.modules.system.biz;

import cn.besteam.common.constant.ErrorCode;
import cn.besteam.common.exception.BusinessException;
import cn.besteam.modules.system.vo.SysDictVO;
import cn.besteam.modules.system.dto.SysDictSaveDTO;
import cn.besteam.modules.system.entity.SysDict;
import cn.besteam.modules.system.entity.SysDictItem;
import cn.besteam.modules.system.service.ISysDictItemService;
import cn.besteam.modules.system.service.ISysDictService;
import cn.besteam.modules.system.vo.SysDictItemVO;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class SysDictBiz {

    @Autowired
    private ISysDictService sysDictService;
    @Autowired
    private ISysDictItemService sysDictItemService;

    /**
     * 获取字典定义数据列表
     *
     * @return
     */
    public List<SysDictVO> queryList(String keyword) {

        return sysDictService.getQueryList(keyword);
    }

    /**
     * 获取消毒方式和消毒模式
     * @return
     */
    public List<SysDictItem> queryListDisinfect(String ids) {
        List<SysDictItem> sysDictItemList = sysDictItemService.list(new QueryWrapper<SysDictItem>().lambda()
                .in(SysDictItem::getDictId, Arrays.asList(ids.split(","))));
        return sysDictItemList;
    }

    /**
     * 新增字典定义
     *
     * @param dto
     */
    @Transactional(rollbackFor = Exception.class)
    public void add(SysDictSaveDTO dto) {

        SysDict sysDict = sysDictService.getById(dto.getDictId());
        if (sysDict == null) {
            throw new BusinessException(ErrorCode.ERR_500, "字典类型不存在");
        }
        String[] itemTextArray = dto.getItemValue().split("\\n");
        int count = sysDictItemService.count(new QueryWrapper<SysDictItem>().lambda().eq(SysDictItem::getDictId, sysDict.getId()));
        for (String itemText : itemTextArray) {
            SysDictItem sysDictItem = sysDictItemService.getOne(new QueryWrapper<SysDictItem>().lambda().eq(SysDictItem::getDictId, sysDict).eq(SysDictItem::getItemText, itemText).eq(SysDictItem::getItemValue, itemText));
            if (sysDictItem != null) {
                continue;
            }
            SysDictItem dictItem = new SysDictItem();
            dictItem.setDictId(sysDict.getId());
            dictItem.setItemText(itemText);
            dictItem.setItemValue(itemText);
            dictItem.setDescription(dto.getDescription());
            dictItem.setSortOrder(count + 1);
            dictItem.setUpdateTime(new Date());
            dictItem.setColorValue(dto.getColorValue());
            sysDictItemService.save(dictItem);
        }
    }

    /**
     * 编辑
     *
     * @param dto
     */
    @Transactional(rollbackFor = Exception.class)
    public void edit(SysDictSaveDTO dto) {

        SysDictItem sysDictItem = sysDictItemService.getById(dto.getId());
        if (sysDictItem == null) {
            throw new BusinessException(ErrorCode.ERR_500, "字典类型不存在");
        }
        sysDictItem.setDictId(dto.getDictId());
        sysDictItem.setItemText(dto.getItemText());
        sysDictItem.setItemValue(dto.getItemValue());
        sysDictItem.setDescription(dto.getDescription());
        sysDictItem.setColorValue(dto.getColorValue());
        sysDictItemService.updateById(sysDictItem);
    }

    /**
     * 字典详情
     *
     * @param id
     * @return
     */
    public SysDictVO detailsById(Integer id) {

        SysDictVO sysDictDTO = new SysDictVO();
        SysDictItem sysDictItem = sysDictItemService.getById(id);
        if (sysDictItem == null) {
            throw new BusinessException(ErrorCode.ERR_500, "字典类型不存在");
        }
        BeanUtils.copyProperties(sysDictItem, sysDictDTO);
        SysDict sysDict = sysDictService.getById(sysDictItem.getDictId());
        if (sysDict == null) {
            throw new BusinessException(ErrorCode.ERR_500, "字典类型不存在");
        }
        sysDictDTO.setDictId(sysDict.getId());
        sysDictDTO.setDictName(sysDict.getDictName());
        return sysDictDTO;
    }

    /**
     * 根据字典id查找字典项列表
     *
     * @param dictId
     * @return
     */
    public List<SysDictItemVO> getSysDictListByDict(Integer dictId) {

        List<SysDictItem> sysDictItemList = sysDictItemService.list(new QueryWrapper<SysDictItem>().lambda().eq(SysDictItem::getDictId, dictId).eq(SysDictItem::getStatus, 1).orderByAsc(SysDictItem::getSortOrder));
        return sysDictItemList.stream().map(sysDictItem -> {
            SysDictItemVO vo = new SysDictItemVO();
            BeanUtils.copyProperties(sysDictItem, vo);
            return vo;
        }).collect(Collectors.toList());
    }

}