package cn.iocoder.yudao.module.base.service.impl;

import cn.iocoder.yudao.module.base.entity.RepairRecordsItem;
import cn.iocoder.yudao.module.base.mapper.RepairRecordsItemMapper;
import cn.iocoder.yudao.module.base.service.RepairRecordsItemService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

import static cn.iocoder.yudao.common.BaseConstants.*;

/**
 * 维修记录 Service 实现类
 *
 * @author pqz
 */
@Service
@Validated
public class RepairRecordsItemServiceImpl extends ServiceImpl<RepairRecordsItemMapper, RepairRecordsItem> implements RepairRecordsItemService {

    @Resource
    private RepairRecordsItemMapper itemMapper;


    /**
     * 根据主表id删除附件
     *
     * @param mainType ticket：工单；repairItem：工单附属项目；record：维修记录
     * @param mainId   主表id
     * @author PQZ
     * @date 11:43 2024/10/11
     **/
    @Override
    public void removeByMainId(String mainType, String mainId) {
        //根据不同类型初始化不通过查询条件
        LambdaQueryWrapper<RepairRecordsItem> lambdaQueryWrapper = queryType(mainType, mainId);
        remove(lambdaQueryWrapper);
    }

    /**
     * 通过主表id查询图片
     *
     * @param mainType ticket：工单；repairItem：工单附属项目；record：维修记录
     * @param mainId   主表id
     * @param isOpen   是否开放给用户（默认查询全部，如不为null则根据条件查询）
     * @return 记录图片集合
     * @author PQZ
     * @date 14:30 2024/10/11
     **/
    @Override
    public List<RepairRecordsItem> getByMainId(String mainType, String mainId, String isOpen) {
        //根据不同类型初始化不通过查询条件
        LambdaQueryWrapper<RepairRecordsItem> lambdaQueryWrapper = queryType(mainType, mainId);
        //默认查询全部，如不为null则根据条件查询
        if (StringUtils.isNotEmpty(isOpen)) {
            lambdaQueryWrapper.eq(RepairRecordsItem::getIsOpen, isOpen);
        }
        return list(lambdaQueryWrapper);
    }


    /**
     * 保存维修记录相关的图片
     *
     * @param recordId     记录id
     * @param ticketId     工单id
     * @param repairItemId 工单子表id
     * @param image        上传附件相对路径（多个用“，”分隔）
     * @author PQZ
     * @date 14:09 2024/10/11
     **/
    @Override
    public void saveItem(String recordId, String ticketId, String repairItemId, String image) {
        //根据记录id删除改记录中原有的图片
        removeByMainId(REPAIR_RECORD_TYPE_RECORD, recordId);
        //组装维修记录图片集合
        List<RepairRecordsItem> saveList = new ArrayList<>();
        if (StringUtils.isNotEmpty(image)) {
            //字符串转换集合
            List<String> imageList = Arrays.stream(image.split(","))
                    .collect(Collectors.toList());
            imageList.forEach(item -> {
                RepairRecordsItem saveItem = new RepairRecordsItem();
                saveItem.setRecordId(recordId);
                saveItem.setTicketId(ticketId);
                saveItem.setRepairItemId(repairItemId);
                saveItem.setImage(item);
                saveList.add(saveItem);
            });
            saveBatch(saveList);
        }
    }

    /**
     * 设置图片是否开放给用户
     *
     * @param ids    前端选中图片id（多个用“，”分隔）
     * @param isOpen 0否1是
     * @author PQZ
     * @date 14:22 2024/10/11
     **/
    @Override
    public void setRepairOpen(String ids, String isOpen) {
        if (StringUtils.isNotEmpty(ids)) {
            //id字符串转换集合
            List<String> idList = Arrays.stream(ids.split(","))
                    .collect(Collectors.toList());
            LambdaUpdateWrapper<RepairRecordsItem> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
            //设置更新条件
            lambdaUpdateWrapper.in(RepairRecordsItem::getId, idList).set(RepairRecordsItem::getIsOpen, isOpen);
            //更新
            update(lambdaUpdateWrapper);
        }
    }

    /**
     * 封装查询条件
     *
     * @param mainType ticket：工单；repairItem：工单附属项目；record：维修记录
     * @param mainId   主表id
     * @return com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<cn.iocoder.yudao.module.base.entity.RepairRecordsItem>
     * @author PQZ
     * @date 14:36 2024/10/11
     **/
    private LambdaQueryWrapper<RepairRecordsItem> queryType(String mainType, String mainId) {
        LambdaQueryWrapper<RepairRecordsItem> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        switch (mainType) {
            //匹配根据工单表id删除条件
            case REPAIR_RECORD_TYPE_TICKET:
                lambdaQueryWrapper.eq(RepairRecordsItem::getTicketId, mainId);
                break;
            //匹配根据工单子表id删除条件
            case REPAIR_RECORD_TYPE_REPAIR_ITEM:
                lambdaQueryWrapper.eq(RepairRecordsItem::getRepairItemId, mainId);
                break;
            //匹配根据根据记录表id删除条件
            case REPAIR_RECORD_TYPE_RECORD:
                lambdaQueryWrapper.eq(RepairRecordsItem::getRecordId, mainId);
                break;
            default:
                break;
        }
        return lambdaQueryWrapper;
    }
}
