package com.ruoyi.technology.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
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.common.exception.ServiceException;
import com.ruoyi.technology.bean.dto.TechnologyRoutingOperationParamDto;
import com.ruoyi.technology.bean.dto.TechnologyRoutingOperationParamSyncDto;
import com.ruoyi.technology.bean.vo.TechnologyRoutingOperationParamVo;
import com.ruoyi.technology.mapper.TechnologyOperationParamMapper;
import com.ruoyi.technology.mapper.TechnologyParamMapper;
import com.ruoyi.technology.mapper.TechnologyRoutingOperationMapper;
import com.ruoyi.technology.mapper.TechnologyRoutingOperationParamMapper;
import com.ruoyi.technology.pojo.TechnologyOperationParam;
import com.ruoyi.technology.pojo.TechnologyParam;
import com.ruoyi.technology.pojo.TechnologyRoutingOperation;
import com.ruoyi.technology.pojo.TechnologyRoutingOperationParam;
import com.ruoyi.technology.service.TechnologyRoutingOperationParamService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
@Transactional(rollbackFor = Exception.class)
@RequiredArgsConstructor
public class TechnologyRoutingOperationParamServiceImpl extends ServiceImpl<TechnologyRoutingOperationParamMapper, TechnologyRoutingOperationParam>
        implements TechnologyRoutingOperationParamService {

    private final TechnologyRoutingOperationParamMapper technologyRoutingOperationParamMapper;
    private final TechnologyRoutingOperationMapper technologyRoutingOperationMapper;
    private final TechnologyOperationParamMapper technologyOperationParamMapper;
    private final TechnologyParamMapper technologyParamMapper;

    @Override
    public IPage<TechnologyRoutingOperationParamVo> pageTechnologyRoutingOperationParam(Page<TechnologyRoutingOperationParamDto> page,
                                                                                         TechnologyRoutingOperationParamDto dto) {
        Page<TechnologyRoutingOperationParam> entityPage = new Page<>(page.getCurrent(), page.getSize(), page.getTotal());
        return this.page(entityPage, buildQueryWrapper(dto))
                .convert(item -> BeanUtil.copyProperties(item, TechnologyRoutingOperationParamVo.class));
    }

    @Override
    public List<TechnologyRoutingOperationParamVo> listTechnologyRoutingOperationParam(TechnologyRoutingOperationParamDto dto) {
        return BeanUtil.copyToList(this.list(buildQueryWrapper(dto)), TechnologyRoutingOperationParamVo.class);
    }

    @Override
    public TechnologyRoutingOperationParamVo getTechnologyRoutingOperationParamInfo(Long id) {
        TechnologyRoutingOperationParam item = this.getById(id);
        if (item == null) {
            return null;
        }
        return BeanUtil.copyProperties(item, TechnologyRoutingOperationParamVo.class);
    }

    @Override
    public boolean saveTechnologyRoutingOperationParam(TechnologyRoutingOperationParam item) {
        TechnologyRoutingOperation routingOperation = getRoutingOperation(item.getTechnologyRoutingOperationId());
        fillFromOperationParam(item, routingOperation);
        checkDuplicate(item);
        return this.saveOrUpdate(item);
    }

    @Override
    public boolean removeTechnologyRoutingOperationParam(Long id) {
        return this.removeById(id);
    }

    @Override
    public int syncTechnologyRoutingOperationParam(TechnologyRoutingOperationParamSyncDto syncDto) {
        if (syncDto == null || syncDto.getTechnologyRoutingOperationId() == null) {
            throw new ServiceException("工艺路线工序ID不能为空");
        }
        TechnologyRoutingOperation routingOperation = getRoutingOperation(syncDto.getTechnologyRoutingOperationId());
        List<TechnologyOperationParam> operationParamList = technologyOperationParamMapper.selectList(
                Wrappers.<TechnologyOperationParam>lambdaQuery()
                        .eq(TechnologyOperationParam::getTechnologyOperationId, routingOperation.getTechnologyOperationId())
                        .orderByAsc(TechnologyOperationParam::getId)
        );
        boolean replaceExisting = syncDto.getReplaceExisting() == null || syncDto.getReplaceExisting();
        if (replaceExisting) {
            technologyRoutingOperationParamMapper.delete(
                    Wrappers.<TechnologyRoutingOperationParam>lambdaQuery()
                            .eq(TechnologyRoutingOperationParam::getTechnologyRoutingOperationId, routingOperation.getId())
            );
        }
        int successCount = 0;
        if (CollectionUtils.isNotEmpty(operationParamList)) {
            for (TechnologyOperationParam operationParam : operationParamList) {
                boolean exists = technologyRoutingOperationParamMapper.selectCount(
                        Wrappers.<TechnologyRoutingOperationParam>lambdaQuery()
                                .eq(TechnologyRoutingOperationParam::getTechnologyRoutingOperationId, routingOperation.getId())
                                .eq(TechnologyRoutingOperationParam::getTechnologyOperationParamId, operationParam.getId())
                ) > 0;
                if (!replaceExisting && exists) {
                    continue;
                }
                TechnologyRoutingOperationParam snapshot = new TechnologyRoutingOperationParam();
                snapshot.setTechnologyRoutingOperationId(routingOperation.getId());
                snapshot.setTechnologyOperationParamId(operationParam.getId());
                snapshot.setTechnologyOperationId(operationParam.getTechnologyOperationId());
                snapshot.setStandardValue(operationParam.getStandardValue());
                fillFromOperationParam(snapshot, routingOperation);
                technologyRoutingOperationParamMapper.insert(snapshot);
                successCount++;
            }
        }
        return successCount;
    }

    private LambdaQueryWrapper<TechnologyRoutingOperationParam> buildQueryWrapper(TechnologyRoutingOperationParamDto dto) {
        TechnologyRoutingOperationParam query = dto == null ? new TechnologyRoutingOperationParam() : dto;
        return Wrappers.<TechnologyRoutingOperationParam>lambdaQuery()
                .eq(query.getId() != null, TechnologyRoutingOperationParam::getId, query.getId())
                .eq(query.getTechnologyRoutingOperationId() != null,
                        TechnologyRoutingOperationParam::getTechnologyRoutingOperationId, query.getTechnologyRoutingOperationId())
                .eq(query.getTechnologyOperationId() != null,
                        TechnologyRoutingOperationParam::getTechnologyOperationId, query.getTechnologyOperationId())
                .eq(query.getTechnologyOperationParamId() != null,
                        TechnologyRoutingOperationParam::getTechnologyOperationParamId, query.getTechnologyOperationParamId())
                .eq(query.getParamId() != null, TechnologyRoutingOperationParam::getParamId, query.getParamId())
                .eq(query.getParamType() != null, TechnologyRoutingOperationParam::getParamType, query.getParamType())
                .like(query.getParamCode() != null && !query.getParamCode().isEmpty(),
                        TechnologyRoutingOperationParam::getParamCode, query.getParamCode())
                .like(query.getParamName() != null && !query.getParamName().isEmpty(),
                        TechnologyRoutingOperationParam::getParamName, query.getParamName())
                .orderByAsc(TechnologyRoutingOperationParam::getTechnologyRoutingOperationId)
                .orderByAsc(TechnologyRoutingOperationParam::getId);
    }

    private TechnologyRoutingOperation getRoutingOperation(Long technologyRoutingOperationId) {
        if (technologyRoutingOperationId == null) {
            throw new ServiceException("工艺路线工序ID不能为空");
        }
        TechnologyRoutingOperation routingOperation = technologyRoutingOperationMapper.selectById(technologyRoutingOperationId);
        if (routingOperation == null) {
            throw new ServiceException("工艺路线工序不存在");
        }
        return routingOperation;
    }

    private void fillFromOperationParam(TechnologyRoutingOperationParam item, TechnologyRoutingOperation routingOperation) {
        if (item.getTechnologyOperationId() == null) {
            item.setTechnologyOperationId(routingOperation.getTechnologyOperationId());
        } else if (!item.getTechnologyOperationId().equals(routingOperation.getTechnologyOperationId())) {
            throw new ServiceException("工序ID与工艺路线工序不匹配");
        }

        if (item.getTechnologyOperationParamId() != null) {
            TechnologyOperationParam operationParam = technologyOperationParamMapper.selectById(item.getTechnologyOperationParamId());
            if (operationParam == null) {
                throw new ServiceException("工序参数不存在");
            }
            if (!routingOperation.getTechnologyOperationId().equals(operationParam.getTechnologyOperationId())) {
                throw new ServiceException("工序参数不属于当前工艺路线工序");
            }
            TechnologyParam technologyParam = technologyParamMapper.selectById(operationParam.getTechnologyParamId());
            if (technologyParam == null) {
                throw new ServiceException("基础参数不存在");
            }
            fillFromTechnologyParam(item, technologyParam);
            if (item.getStandardValue() == null) {
                item.setStandardValue(operationParam.getStandardValue());
            }
            return;
        }

        if (item.getParamId() != null) {
            TechnologyParam technologyParam = technologyParamMapper.selectById(item.getParamId());
            if (technologyParam == null) {
                throw new ServiceException("基础参数不存在");
            }
            fillFromTechnologyParam(item, technologyParam);
            TechnologyOperationParam operationParam = technologyOperationParamMapper.selectOne(
                    Wrappers.<TechnologyOperationParam>lambdaQuery()
                            .eq(TechnologyOperationParam::getTechnologyOperationId, routingOperation.getTechnologyOperationId())
                            .eq(TechnologyOperationParam::getTechnologyParamId, item.getParamId())
                            .orderByAsc(TechnologyOperationParam::getId)
                            .last("limit 1")
            );
            if (operationParam != null) {
                item.setTechnologyOperationParamId(operationParam.getId());
                if (item.getStandardValue() == null) {
                    item.setStandardValue(operationParam.getStandardValue());
                }
            }
            return;
        }

        throw new ServiceException("paramId或technologyOperationParamId不能为空");
    }

    private void fillFromTechnologyParam(TechnologyRoutingOperationParam item, TechnologyParam technologyParam) {
        item.setParamId(technologyParam.getId());
        item.setParamCode(technologyParam.getParamCode());
        item.setParamName(technologyParam.getParamName());
        item.setParamType(technologyParam.getParamType());
        item.setParamFormat(technologyParam.getParamFormat());
        item.setUnit(technologyParam.getUnit());
        item.setIsRequired(technologyParam.getIsRequired());
        if (item.getRemark() == null || item.getRemark().trim().isEmpty()) {
            item.setRemark(technologyParam.getRemark());
        }
    }

    private void checkDuplicate(TechnologyRoutingOperationParam item) {
        boolean duplicate = technologyRoutingOperationParamMapper.selectCount(
                Wrappers.<TechnologyRoutingOperationParam>lambdaQuery()
                        .eq(TechnologyRoutingOperationParam::getTechnologyRoutingOperationId, item.getTechnologyRoutingOperationId())
                        .eq(item.getTechnologyOperationParamId() != null,
                                TechnologyRoutingOperationParam::getTechnologyOperationParamId, item.getTechnologyOperationParamId())
                        .eq(item.getTechnologyOperationParamId() == null && item.getParamId() != null,
                                TechnologyRoutingOperationParam::getParamId, item.getParamId())
                        .eq(item.getTechnologyOperationParamId() == null && item.getParamId() == null && item.getParamCode() != null,
                                TechnologyRoutingOperationParam::getParamCode, item.getParamCode())
                        .ne(item.getId() != null, TechnologyRoutingOperationParam::getId, item.getId())
        ) > 0;
        if (duplicate) {
            throw new ServiceException("工艺路线工序参数重复");
        }
    }
}