package com.ruoyi.inspect.service.impl;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
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.mapper.StandardProductListMapper;
import com.ruoyi.basic.pojo.StandardProductList;
import com.ruoyi.basic.utils.StandardTreePathParser;
import com.ruoyi.framework.exception.ErrorException;
import com.ruoyi.inspect.dto.InsProductBindingDto;
import com.ruoyi.inspect.dto.WriteInspectionConditionDto;
import com.ruoyi.inspect.mapper.InsOrderMapper;
import com.ruoyi.inspect.mapper.InsOrderStandardTemplateMapper;
import com.ruoyi.inspect.mapper.InsOrderTemplateDeviceMapper;
import com.ruoyi.inspect.mapper.InsProductMapper;
import com.ruoyi.inspect.mapper.InsSampleMapper;
import com.ruoyi.inspect.pojo.InsOrder;
import com.ruoyi.inspect.pojo.InsOrderStandardTemplate;
import com.ruoyi.inspect.pojo.InsOrderTemplateDevice;
import com.ruoyi.inspect.pojo.InsProduct;
import com.ruoyi.inspect.pojo.InsSample;
import com.ruoyi.inspect.service.InsProductService;
import com.ruoyi.performance.pojo.AuxiliaryOutputWorkingHours;
import lombok.AllArgsConstructor;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.stream.Collectors;

@Service
@AllArgsConstructor
@Transactional(rollbackFor = Exception.class)
public class InsProductServiceImpl extends ServiceImpl<InsProductMapper, InsProduct>
        implements InsProductService {

    private InsProductMapper insProductMapper;

    private InsOrderMapper insOrderMapper;

    private InsSampleMapper insSampleMapper;

    private StandardProductListMapper standardProductListMapper;

    private InsOrderStandardTemplateMapper insOrderStandardTemplateMapper;

    private InsOrderTemplateDeviceMapper insOrderTemplateDeviceMapper;

    @Override
    public int selectOrderManDay(Integer orderId) {
        return insProductMapper.selectOrderManDay(orderId);
    }

    @Override
    public int updateInspected(Integer id, String ids) {
        InsOrder insOrder = new InsOrder();
        insOrder.setId(id);
        insOrder.setIsRevocation(1);//需要审核
        insOrder.setRevocationInsProductIds(ids);
        return insOrderMapper.updateById(insOrder);
    }

    @Override
    public boolean write(WriteInspectionConditionDto dto) {
        if (dto == null || dto.getId() == null) {
            throw new ErrorException("订单ID不能为空");
        }
        if (dto.getTemplateId() != null) {
            InsOrderStandardTemplate snapshot = insOrderStandardTemplateMapper.selectOne(
                    Wrappers.<InsOrderStandardTemplate>lambdaQuery()
                            .eq(InsOrderStandardTemplate::getInsOrderId, dto.getId())
                            .eq(InsOrderStandardTemplate::getTemplateId, dto.getTemplateId())
                            .last("limit 1"));
            if (snapshot == null) {
                throw new ErrorException("未找到当前模板的原始记录快照");
            }
            boolean hasSnapshotField = dto.isTemperaturePresent() || dto.isHumidityPresent()
                    || dto.isDetectionTimePresent() || dto.isDetectionPlacePresent()
                    || dto.isInsResultPresent();
            if (hasSnapshotField) {
                insOrderStandardTemplateMapper.update(null,
                        Wrappers.<InsOrderStandardTemplate>lambdaUpdate()
                                .eq(InsOrderStandardTemplate::getId, snapshot.getId())
                                .set(dto.isTemperaturePresent(),
                                        InsOrderStandardTemplate::getTemperature, dto.getTemperature())
                                .set(dto.isHumidityPresent(),
                                        InsOrderStandardTemplate::getHumidity, dto.getHumidity())
                                .set(dto.isDetectionTimePresent(),
                                        InsOrderStandardTemplate::getDetectionTime, dto.getDetectionTime())
                                .set(dto.isDetectionPlacePresent(),
                                        InsOrderStandardTemplate::getDetectionPlace, dto.getDetectionPlace())
                                .set(dto.isInsResultPresent(),
                                        InsOrderStandardTemplate::getInsResult, dto.getInsResult()));
            }
            if (dto.isDeviceIdsPresent()) {
                insOrderTemplateDeviceMapper.delete(
                        Wrappers.<InsOrderTemplateDevice>lambdaQuery()
                                .eq(InsOrderTemplateDevice::getInsOrderId, dto.getId())
                                .eq(InsOrderTemplateDevice::getTemplateId, dto.getTemplateId()));
                List<Integer> deviceIds = dto.getDeviceIds() == null
                        ? Collections.emptyList()
                        : dto.getDeviceIds().stream()
                                .filter(Objects::nonNull)
                                .distinct()
                                .collect(Collectors.toList());
                if (!deviceIds.isEmpty()
                        && insOrderTemplateDeviceMapper.selectExistingDeviceIds(deviceIds).size() != deviceIds.size()) {
                    throw new ErrorException("所选设备不存在，请刷新设备列表后重试");
                }
                for (int index = 0; index < deviceIds.size(); index++) {
                    InsOrderTemplateDevice relation = new InsOrderTemplateDevice();
                    relation.setInsOrderId(dto.getId());
                    relation.setTemplateId(dto.getTemplateId());
                    relation.setDeviceId(deviceIds.get(index));
                    relation.setSort(index);
                    insOrderTemplateDeviceMapper.insert(relation);
                }
            }
            if (!hasSnapshotField && !dto.isDeviceIdsPresent()) {
                throw new ErrorException("没有需要保存的模板检验条件");
            }
            return true;
        }
        InsOrder insOrder = new InsOrder();
        insOrder.setId(dto.getId());
        insOrder.setRemark(dto.getRemark());
        insOrderMapper.updateById(insOrder);
        return true;
    }

    //查询待检项目
    @Override
    public IPage<InsProduct> selectNoProducts(Page page, InsProduct insProduct, Integer orderId, String ids) {
        List<Integer> noIds = null;
        if (StringUtils.isNotBlank(ids)) {
            noIds = Arrays.asList(ids.split(",")).stream()
                    .map(Integer::parseInt)
                    .collect(Collectors.toList());
        }
        IPage<InsProduct> insProductIPage = baseMapper.selectNoProducts(page, orderId, noIds);
        return insProductIPage;
    }

    //审核待检撤销
    @Override
    public void checkUpdate(Integer orderId, Integer state) {
        InsOrder insOrder = insOrderMapper.selectById(orderId);
        if (state == 1) {
            List<String> list = new ArrayList<>();
            try {
                list = Arrays.asList(insOrder.getRevocationInsProductIds().split(","));
            } catch (Exception e) {
                throw new ErrorException("还没有选择应该要撤销的检验项目");
            }
            List<Integer> ids = list.stream()
                    .map(Integer::parseInt)
                    .collect(Collectors.toList());
            List<InsSample> insSamples = insSampleMapper.selectList(Wrappers.<InsSample>lambdaQuery().eq(InsSample::getInsOrderId, orderId));
            List<Integer> collect = insSamples.stream().map(InsSample::getId).collect(Collectors.toList());
            List<InsProduct> insProducts = insProductMapper.selectList(Wrappers.<InsProduct>lambdaQuery().eq(InsProduct::getState, 1).in(InsProduct::getInsSampleId, collect));
            if (insProducts.stream().map(InsProduct::getId).collect(Collectors.toList()).equals(ids)) {
                //如果该检验单下的所有项目全部都撤销,那么这个单子也需要撤销
                insOrder.setState(3);
            } else {
                List<InsProduct> products = insProductMapper.selectBatchIds(ids);
                //首先根据选择的项目id进行撤销项目
                updateBatchById(products.stream().map(insProduct -> {
                    insProduct.setState(0);
                    return insProduct;
                }).collect(Collectors.toList()));
            }
            //insProductMapper.updateInspected(id);
        }
        //不通过
        insOrder.setIsRevocation(0);
        insOrderMapper.updateById(insOrder);

    }


    /**
     * 根据检验项id查询检验项树信息
     * @param productId
     * @return
     */
    @Override
    public List<InsProduct> getProductTreeByProductId(Integer productId) {
        // 查询检验项信息
        InsProduct insProduct = insProductMapper.selectById(productId);
        String tree;
        if (insProduct.getSampleType() == null && insProduct.getModel() == null
                && StringUtils.isNotBlank(insProduct.getLaboratory())
                && StringUtils.isNotBlank(insProduct.getSample())) {
            tree = StandardTreePathParser.canonical(insProduct.getLaboratory(), insProduct.getSample());
        } else {
            tree = insProduct.getFactory() + " - " +
                    insProduct.getLaboratory() + " - " +
                    insProduct.getSampleType() + " - " +
                    insProduct.getSample() + " - " +
                    insProduct.getModel();
        }
        // 查询标准树
        List<StandardProductList> standardProductLists = standardProductListMapper.selectList(Wrappers.<StandardProductList>lambdaQuery()
                .eq(StandardProductList::getStandardMethodListId, insProduct.getStandardMethodListId())
                .eq(StandardProductList::getTree, tree));

        List<InsProduct> insProducts = standardProductLists.stream().map(standardProductList -> {
            InsProduct product = new InsProduct();
            BeanUtils.copyProperties(standardProductList, product);
            // 防止序列化错误
            product.setTemplate(null);
            product.setStyle(null);
            return product;
        }).sorted((o1, o2) -> (o1.getSort() == null ? 0 : o1.getSort())
                - (o2.getSort() == null ? 0 : o2.getSort())).collect(Collectors.toList());
        return insProducts;
    }

    /**
     * 特殊检验项绑定
     * @param insProductBindingDto
     * @return
     */
    @Override
    public boolean bindingProductTreeByProductId(InsProductBindingDto insProductBindingDto) {
        if (insProductBindingDto.getInsProductId() == null) {
            throw new ErrorException("缺少检验项绑定id");
        }

        List<InsProduct> insProductBindingList = insProductBindingDto.getInsProductBindingList();
        // 查询原本检验项
        InsProduct insProduct = insProductMapper.selectById(insProductBindingDto.getInsProductId());

        for (InsProduct product : insProductBindingList) {
            product.setBindingProductId(insProductBindingDto.getInsProductId());
            product.setAsk(null);
            product.setTell(null);
            product.setPrice(null);
            product.setManHour(null);
            product.setSection(null);
            // 关联标识
            product.setRawMaterialTag(insProduct.getRawMaterialTag());
            product.setRepetitionTag(insProduct.getRepetitionTag());
            product.setInsSampleId(insProduct.getInsSampleId());
            product.setIsBinding(1);
            product.setState(1);
        }

        // 判断是否是电缆是电缆需要添加所有电缆关联关系
        if (StringUtils.isNotBlank(insProduct.getCableTag())) {
            // 查询其他电缆
            List<InsProduct> insProducts = insProductMapper.selectList(Wrappers.<InsProduct>lambdaQuery()
                    .eq(InsProduct::getInsSampleId, insProduct.getInsSampleId())
                    .eq(InsProduct::getStructureItemParameterId, insProduct.getStructureItemParameterId())
                    .isNotNull(InsProduct::getCableTag));
            for (InsProduct product : insProducts) {
                for (InsProduct insProduct1 : insProductBindingList) {
                    insProduct1.setId(null);
                    insProduct1.setBindingProductId(product.getId());
                    insProduct1.setCableTag(product.getCableTag());
                }
                this.saveBatch(insProductBindingList);
            }
        } else {
            this.saveBatch(insProductBindingList);
        }

        return true;
    }

    /**
     * 删除特殊检验项绑定信息
     * @param productId
     * @return
     */
    @Override
    public boolean removeBindingProductTree(Integer productId) {
        // 查询检验项
        InsProduct insProduct = insProductMapper.selectById(productId);
        // 判断是否是电缆配置, 需要删除关联的所有的检验项
        if (StringUtils.isNotBlank(insProduct.getCableTag())) {
            insProductMapper.delete(Wrappers.<InsProduct>lambdaQuery()
                    .eq(InsProduct::getInsSampleId, insProduct.getInsSampleId())
                    .eq(InsProduct::getIsBinding, 1)
                    .isNotNull(InsProduct::getBindingProductId)
                    .eq(InsProduct::getStructureItemParameterId, insProduct.getStructureItemParameterId())
                    .isNotNull(InsProduct::getCableTag));
        } else {
            insProductMapper.deleteById(productId);
        }
        return false;
    }

    @Override
    public List<InsProduct> getRevocationInsProductList(Integer orderId) {
        InsOrder insOrder = insOrderMapper.selectById(orderId);
        if(Objects.isNull(insOrder)){
            throw new RuntimeException("未找到该订单");
        }
        String revocationInsProductIds = insOrder.getRevocationInsProductIds();
        List<Integer> ids = new ArrayList<>();
        if(StringUtils.isNotBlank(revocationInsProductIds)){
            ids = Arrays.asList(revocationInsProductIds.split(",")).stream().map(Integer::parseInt).collect(Collectors.toList());
        }
        return baseMapper.getRevocationInsProductList(ids);
    }


}