package com.ruoyi.basic.service.impl;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.basic.dto.PageTestObjectDto;
import com.ruoyi.basic.dto.TestItemDto;
import com.ruoyi.basic.mapper.*;
import com.ruoyi.basic.pojo.*;
import com.ruoyi.basic.service.CapacityScopeService;
import com.ruoyi.common.core.domain.entity.SysDictData;
import com.ruoyi.common.exception.base.BaseException;
import com.ruoyi.common.utils.QueryWrappers;
import com.ruoyi.basic.service.StandardProductListService;
import com.ruoyi.basic.service.StructureItemParameterService;
import com.ruoyi.system.mapper.SysDictTypeMapper;
import com.ruoyi.system.service.ISysDictTypeService;
import lombok.AllArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;

/**
 * 检验项目参数(StructureItemParameter)表服务实现类
 *
 * @author makejava
 * @since 2024-02-26 16:21:17
 */
@Service
@AllArgsConstructor
public class CapacityScopeServiceImpl extends ServiceImpl<StructureItemParameterMapper, StructureItemParameter> implements CapacityScopeService {

    private StandardProductListMapper standardProductListMapper;

    private ThreadPoolTaskExecutor threadPoolTaskExecutor;

    private StructureItemParameterMapper structureItemParameterMapper;

    private StructureTestObjectMapper structureTestObjectMapper;

    private ProductMapper productMapper;

    private StandardProductListService standardProductListService;

    private StandardTreeMapper standardTreeMapper;

    private StructureItemParameterService structureItemParameterService;

    private ISysDictTypeService sysDictTypeService;

    @Override
    public IPage<StructureItemParameter> selectItemParameterList(Page page, StructureItemParameter itemParameter) {
        IPage<StructureItemParameter> parameterIPage = structureItemParameterMapper.selectItemParameterList(page, QueryWrappers.queryWrappers(itemParameter));
        //查询字典
        Map<String, List<SysDictData>> dictMaps = sysDictTypeService.selectEnumListByCategory(Arrays.asList("检验项类型", "是否", "检验值类型", "单位"));
        parameterIPage.getRecords().forEach(ele->{
            ele.setInspectionItemTypeTwo(getLabelByValue(dictMaps.get("检验项类型"),ele.getInspectionItemType()));
            ele.setUpdateBsm(getLabelByValue(dictMaps.get("是否"),ele.getBsm()));
            ele.setInspectionValueTypeTwo(getLabelByValue(dictMaps.get("检验值类型"),ele.getInspectionValueType()));
        });
        return parameterIPage;
    }

    /**
     * 根据value获取字典
     * @param dictList
     * @param value
     * @return
     */
    private String getLabelByValue(List<SysDictData> dictList, String value){
        if(dictList.isEmpty()){
            return "";
        }
        return dictList.stream().filter(ele-> Objects.equals(ele.getDictValue(),value)).map(SysDictData::getDictLabel).findFirst().orElse("");
    }

    @Override
    public int addItemParameter(StructureItemParameter itemParameter) {
        if (itemParameter.getBsm().equals("")||itemParameter.getBsm()==null){
            itemParameter.setBsm("0");
        }
        int insert = structureItemParameterMapper.insert(itemParameter);
        return insert;
    }

    @Override
    public int delItemParameter(Integer id) {
        return structureItemParameterMapper.deleteById(id);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public int upItemParameter(StructureItemParameter itemParameter) {
        //能力范围更新，同时更新对应的标准库
        StructureItemParameter oldParameter = structureItemParameterMapper.selectById(itemParameter.getId());
        //判断检验项、检验子项、单位是否有修改，有就同时修改标准库对应的数据
        if(
                !StringUtils.equals(itemParameter.getInspectionItem(),oldParameter.getInspectionItem()) ||
                        !StringUtils.equals(itemParameter.getInspectionItemSubclass(),oldParameter.getInspectionItemSubclass()) ||
                        !StringUtils.equals(itemParameter.getInspectionItemEn(),oldParameter.getInspectionItemEn()) ||
                        !StringUtils.equals(itemParameter.getInspectionItemSubclassEn(),oldParameter.getInspectionItemSubclassEn()) ||
                        !StringUtils.equals(itemParameter.getUnit(),oldParameter.getUnit())
        ){
            CompletableFuture.runAsync(() -> {
                LambdaUpdateWrapper<StandardProductList> updateWrapper = Wrappers.<StandardProductList>lambdaUpdate()
                        .set(StandardProductList::getInspectionItem, itemParameter.getInspectionItem())
                        .set(StandardProductList::getInspectionItemEn, itemParameter.getInspectionItemEn())
                        .set(StandardProductList::getInspectionItemSubclass, itemParameter.getInspectionItemSubclass())
                        .set(StandardProductList::getInspectionItemSubclassEn, itemParameter.getInspectionItemSubclassEn())
                        .set(StandardProductList::getUnit, itemParameter.getUnit())
                        .eq(StandardProductList::getStructureItemParameterId,itemParameter.getId());
                standardProductListMapper.update(null,updateWrapper);
            },threadPoolTaskExecutor);
        }
        return structureItemParameterMapper.updateById(itemParameter);
    }

    @Override
    public IPage<PageTestObjectDto> selectTestObjectList(Page page, PageTestObjectDto pageTestObjectDto) {
        return structureTestObjectMapper.selectTestObjectList(page, QueryWrappers.queryWrappers(pageTestObjectDto));
    }

    @Override
    public int addTestObject(StructureTestObject testObject) {
        Long count = structureTestObjectMapper.selectCount(Wrappers.<StructureTestObject>lambdaQuery().eq(StructureTestObject::getSpecimenName, testObject.getSpecimenName()));
        if(count.compareTo(0L) > 0){
            throw new BaseException("检验对象不能重复");
        }
        return structureTestObjectMapper.insert(testObject);
    }

    @Override
    public int delTestObject(Integer id) {
        List<Product> products = productMapper.selectList(Wrappers.<Product>lambdaQuery()
                .eq(Product::getObjectId, id));
        List<Integer> productIds = products.stream().map(Product::getId).collect(Collectors.toList());
        // 删除产品维护
        if (productIds.size()>0) {
            productMapper.delete(Wrappers.<Product>lambdaQuery()
                    .in(Product::getId, productIds));
        }
        return structureTestObjectMapper.deleteById(id);
    }

    @Override
    public int upTestObject(StructureTestObject testObject) {
        // 查询旧的检验对象
        StructureTestObject oldTestObject = structureTestObjectMapper.selectById(testObject.getId());

        if (!oldTestObject.getSpecimenName().equals(testObject.getSpecimenName())) {
            // 查询所有对象一样的检验项目
            List<StandardProductList> standardProductLists = standardProductListService.list(Wrappers.<StandardProductList>lambdaUpdate()
                    .eq(StandardProductList::getSampleType, oldTestObject.getSpecimenName()));
            if (CollectionUtils.isNotEmpty(standardProductLists)){
                for (StandardProductList standardProductList : standardProductLists) {
                    // 修改所有的对象名称和数型结构
                    standardProductList.setSampleType(testObject.getSpecimenName());
                    // 需要截取第三级, 避免三四级名称一样修改错误
                    String[] trees = standardProductList.getTree().split(" - ");
                    trees[2] = testObject.getSpecimenName();
                    List<String> list = CollUtil.newArrayList(trees);
                    String newName = CollUtil.join(list, " - ");
                    standardProductList.setTree(newName);
                }
                standardProductListService.updateBatchById(standardProductLists);
            }
            // 修改检验项目参数的检验对象
            // 拼接 ["object", 查询检验项目参数修改绑定的检验对象
            String format = "[\"{}\",";
            String sampleOld = StrUtil.format(format, oldTestObject.getSpecimenName());
            List<StructureItemParameter> itemParameterList = structureItemParameterService.list(Wrappers.<StructureItemParameter>lambdaQuery()
                    .like(StructureItemParameter::getSample, sampleOld));
            if (CollectionUtils.isNotEmpty(itemParameterList)) {
                for (StructureItemParameter structureItemParameter : itemParameterList) {
                    // 修改绑定的样品名称
                    String sampleNew = StrUtil.format(format, testObject.getSpecimenName());
                    String sampleUp = structureItemParameter.getSample().replace(sampleOld, sampleNew);
                    structureItemParameter.setSample(sampleUp);
                }
                structureItemParameterService.updateBatchById(itemParameterList);
            }

            // 修改树的型号
            standardTreeMapper.update(null, Wrappers.<StandardTree>lambdaUpdate()
                    .eq(StandardTree::getSampleType, oldTestObject.getSpecimenName())
                    .set(StandardTree::getSampleType, testObject.getSpecimenName()));
        }

        Long count = structureTestObjectMapper.selectCount(Wrappers.<StructureTestObject>lambdaQuery()
                .eq(StructureTestObject::getSpecimenName, testObject.getSpecimenName())
                .ne(StructureTestObject::getId, testObject.getId()));
        if(count.compareTo(0L) > 0){
            throw new BaseException("检验对象不能重复");
        }

        return structureTestObjectMapper.updateById(testObject);
    }

    @Override
    public List<StructureTestObject> selectTestObjectByName() {
        return structureTestObjectMapper.selectList(Wrappers.<StructureTestObject>lambdaQuery().select(StructureTestObject::getSpecimenName,StructureTestObject::getId));
    }

    //设备里面选择检验项目(树形结构)
    @Override
    public List<Map<String, Object>> getInsProduction() {
        return structureItemParameterMapper.getInsProduction();
    }

    @Override
    public List<TestItemDto> getItemTree() {
        return structureItemParameterMapper.getItemTree();
    }
}