package com.gkhy.exam.system.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.gkhy.exam.common.api.CommonPage;
import com.gkhy.exam.common.api.CommonResult;
import com.gkhy.exam.common.constant.UserConstant;
import com.gkhy.exam.common.utils.PageUtils;
import com.gkhy.exam.common.utils.SecurityUtils;
import com.gkhy.exam.system.domain.AnnualMaintenanceEvaluate;
import com.gkhy.exam.system.domain.AnnualMaintenanceEvaluateDevice;
import com.gkhy.exam.system.domain.AnnualMaintenanceRecord;
import com.gkhy.exam.system.mapper.AnnualMaintenanceEvaluateDeviceMapper;
import com.gkhy.exam.system.mapper.AnnualMaintenanceEvaluateMapper;
import com.gkhy.exam.system.service.AnnualMaintenanceEvaluateService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * <p>
 * 设备完好评价记录及完整率统计 服务实现类
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Service
public class AnnualMaintenanceEvaluateServiceImpl extends ServiceImpl<AnnualMaintenanceEvaluateMapper, AnnualMaintenanceEvaluate> implements AnnualMaintenanceEvaluateService {

    @Autowired
    private AnnualMaintenanceEvaluateMapper annualMaintenanceEvaluateMapper;

    @Autowired
    private AnnualMaintenanceEvaluateDeviceMapper annualMaintenanceEvaluateDeviceMapper;

    @Override
    public CommonPage selectAnnualMaintenanceEvaluateList(AnnualMaintenanceEvaluate annualMaintenanceEvaluate) {
        PageUtils.startPage();
        List<AnnualMaintenanceEvaluate> annualMaintenanceEvaluates = annualMaintenanceEvaluateMapper.getAnnualMaintenanceEvaluate(annualMaintenanceEvaluate);
        return CommonPage.restPage(annualMaintenanceEvaluates);
    }

    @Override
    @Transactional
    public CommonResult saveAnnualMaintenanceEvaluate(AnnualMaintenanceEvaluate annualMaintenanceEvaluate) {
        List<AnnualMaintenanceEvaluateDevice> annualMaintenanceEvaluateDeviceList = annualMaintenanceEvaluate.getAnnualMaintenanceEvaluateDeviceList();
        if (ObjectUtils.isEmpty(annualMaintenanceEvaluateDeviceList)){
            return CommonResult.failed("设备列表不能为空");
        }
        boolean isAdd = annualMaintenanceEvaluate.getId() == null;
        int i = 0;
        if (isAdd){
            annualMaintenanceEvaluate.setCreateBy(SecurityUtils.getUsername());
            annualMaintenanceEvaluate.setCreateTime(LocalDateTime.now());
             i = annualMaintenanceEvaluateMapper.insert(annualMaintenanceEvaluate);
        }else {
            annualMaintenanceEvaluate.setUpdateBy(SecurityUtils.getUsername());
            annualMaintenanceEvaluate.setUpdateTime(LocalDateTime.now());
            i = annualMaintenanceEvaluateMapper.updateById(annualMaintenanceEvaluate);
        }
        if (i > 0){
            batchSaveEvaluateDevice(annualMaintenanceEvaluate.getId(), annualMaintenanceEvaluateDeviceList, annualMaintenanceEvaluate.getEvaluateDeviceIds());
            return CommonResult.success("保存成功");
        }

        return CommonResult.failed();
    }

    private void batchSaveEvaluateDevice(Long id, List<AnnualMaintenanceEvaluateDevice> annualMaintenanceEvaluateDeviceList,List<Long> evaluateDeviceIds)
    {
        if (ObjectUtils.isNotEmpty(evaluateDeviceIds)){
            int update = annualMaintenanceEvaluateDeviceMapper.update(new AnnualMaintenanceEvaluateDevice(),
                    new LambdaUpdateWrapper<AnnualMaintenanceEvaluateDevice>().set(AnnualMaintenanceEvaluateDevice::getDelFlag, UserConstant.DEPT_DISABLE)
                            .set(AnnualMaintenanceEvaluateDevice::getUpdateTime, LocalDateTime.now()).set(AnnualMaintenanceEvaluateDevice::getUpdateBy, SecurityUtils.getUsername())
                            .in(AnnualMaintenanceEvaluateDevice::getId, evaluateDeviceIds)
            );
            if (update <= 0){
                throw new RuntimeException("保存年度基础设施维护计划设备失败");
            }
        }

        List<AnnualMaintenanceEvaluateDevice> addData = annualMaintenanceEvaluateDeviceList.stream().filter(annualMaintenanceEvaluateDevice -> annualMaintenanceEvaluateDevice.getId() == null).collect(Collectors.toList());
        if (ObjectUtils.isNotEmpty(addData)){
            addData.forEach(annualMaintenanceEvaluateDevice -> {
                annualMaintenanceEvaluateDevice.setCreateTime(LocalDateTime.now());
                annualMaintenanceEvaluateDevice.setCreateBy(SecurityUtils.getUsername());
                annualMaintenanceEvaluateDevice.setAnnualMaintenanceEvaluateId(id);
            });
            int insert = annualMaintenanceEvaluateDeviceMapper.batchInsert(addData);
            if (insert <= 0){
                throw new RuntimeException("保存年度基础设施维护计划设备失败");
            }
        }

        List<AnnualMaintenanceEvaluateDevice> updateData = annualMaintenanceEvaluateDeviceList.stream().filter(annualMaintenanceEvaluateDevice -> annualMaintenanceEvaluateDevice.getId() != null).collect(Collectors.toList());
        if (ObjectUtils.isNotEmpty(updateData)){
            updateData.forEach(annualMaintenanceEvaluateDevice -> {
                annualMaintenanceEvaluateDevice.setUpdateTime(LocalDateTime.now());
                annualMaintenanceEvaluateDevice.setUpdateBy(SecurityUtils.getUsername());
            });
            int update = annualMaintenanceEvaluateDeviceMapper.batchUpdate(updateData);
            if (update <= 0){
                throw new RuntimeException("保存年度基础设施维护计划设备失败");
            }
        }
    }

    @Override
    public CommonResult getAnnualMaintenanceEvaluate(Integer id) {

        AnnualMaintenanceEvaluate annualMaintenanceEvaluate = annualMaintenanceEvaluateMapper.selectById(id);
        if (ObjectUtils.isNotEmpty(annualMaintenanceEvaluate)){

            List<AnnualMaintenanceEvaluateDevice> annualMaintenanceEvaluateDeviceList = annualMaintenanceEvaluateDeviceMapper.selectList(
                    new LambdaQueryWrapper<AnnualMaintenanceEvaluateDevice>().eq(AnnualMaintenanceEvaluateDevice::getAnnualMaintenanceEvaluateId, id)
                            .eq(AnnualMaintenanceEvaluateDevice::getDelFlag, UserConstant.ENABLE).orderByAsc(AnnualMaintenanceEvaluateDevice::getCreateTime));
            annualMaintenanceEvaluate.setAnnualMaintenanceEvaluateDeviceList(annualMaintenanceEvaluateDeviceList);
        }

        return CommonResult.success(annualMaintenanceEvaluate);
    }

    @Override
    @Transactional
    public CommonResult deletedAnnualMaintenanceEvaluate(Integer id) {

        AnnualMaintenanceEvaluate annualMaintenanceEvaluate = new AnnualMaintenanceEvaluate();
        annualMaintenanceEvaluate.setId(Long.valueOf( id));
        annualMaintenanceEvaluate.setDelFlag(UserConstant.DEPT_DISABLE);
        annualMaintenanceEvaluate.setUpdateBy(SecurityUtils.getUsername());
        annualMaintenanceEvaluate.setUpdateTime(LocalDateTime.now());
        int update = annualMaintenanceEvaluateMapper.updateById(annualMaintenanceEvaluate);
        if (update > 0){
            int update1 = annualMaintenanceEvaluateDeviceMapper.update(new AnnualMaintenanceEvaluateDevice(),
                    new LambdaUpdateWrapper<AnnualMaintenanceEvaluateDevice>().eq(AnnualMaintenanceEvaluateDevice::getAnnualMaintenanceEvaluateId, id)
                            .set(AnnualMaintenanceEvaluateDevice::getDelFlag, UserConstant.DEPT_DISABLE)
                            .set(AnnualMaintenanceEvaluateDevice::getUpdateTime, LocalDateTime.now())
                            .set(AnnualMaintenanceEvaluateDevice::getUpdateBy, SecurityUtils.getUsername()));
            if (update1 <= 0){
                throw new RuntimeException("删除年度基础设施维护计划设备失败");
            }
            return CommonResult.success("删除成功");
        }
        return CommonResult.failed();
    }
}