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

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
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.AnnualMaintenance;
import com.gkhy.exam.system.domain.AnnualMaintenanceDevice;
import com.gkhy.exam.system.domain.AnnualMaintenanceDeviceType;
import com.gkhy.exam.system.domain.StandardizedQuality;
import com.gkhy.exam.system.domain.vo.AnnualMaintenanceDeviceSaveDTOReq;
import com.gkhy.exam.system.domain.vo.AnnualMaintenanceInfoRep;
import com.gkhy.exam.system.domain.vo.AnnualMaintenanceSaveDTOReq;
import com.gkhy.exam.system.mapper.AnnualMaintenanceDeviceMapper;
import com.gkhy.exam.system.mapper.AnnualMaintenanceDeviceTypeMapper;
import com.gkhy.exam.system.mapper.AnnualMaintenanceMapper;
import com.gkhy.exam.system.service.AnnualMaintenanceService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.BeanUtils;
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.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * <p>
 * 年度基础设施维护计划主表 服务实现类
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Service
public class AnnualMaintenanceServiceImpl extends ServiceImpl<AnnualMaintenanceMapper, AnnualMaintenance> implements AnnualMaintenanceService {


    @Autowired
    private AnnualMaintenanceMapper annualMaintenanceMapper;

    @Autowired
    private AnnualMaintenanceDeviceMapper annualMaintenanceDeviceMapper;

    @Autowired
    private AnnualMaintenanceDeviceTypeMapper annualMaintenanceDeviceTypeMapper;


    @Override
    public CommonPage selectAnnualMaintenanceList(AnnualMaintenance annualMaintenance) {
        PageUtils.startPage();
        List<AnnualMaintenance> annualMaintenances = annualMaintenanceMapper.getAnnualMaintenances(annualMaintenance);
        return CommonPage.restPage(annualMaintenances);
    }

    @Override
    @Transactional
    public CommonResult saveAnnualMaintenance(AnnualMaintenanceSaveDTOReq annualMaintenanceSaveDTOReq) {
        List<AnnualMaintenanceDeviceSaveDTOReq> annualMaintenanceDeviceSaveDTOReqs = annualMaintenanceSaveDTOReq.getAnnualMaintenanceDeviceSaveDTOReqs();
        if (ObjectUtils.isEmpty(annualMaintenanceDeviceSaveDTOReqs)){
            return CommonResult.failed("年度基础设施维护计划设备保存参数不能为空");
        }
        int i = 0;

        AnnualMaintenance annualMaintenance = new AnnualMaintenance();
        BeanUtils.copyProperties(annualMaintenanceSaveDTOReq,annualMaintenance);
        boolean isAdd = annualMaintenance.getId() == null;
        if (isAdd){
            annualMaintenance.setCreateBy(SecurityUtils.getUsername());
            annualMaintenance.setCreateTime(LocalDateTime.now());
            i = annualMaintenanceMapper.insert(annualMaintenance);
        }else {
            annualMaintenance.setUpdateBy(SecurityUtils.getUsername());
            annualMaintenance.setUpdateTime(LocalDateTime.now());
            i = annualMaintenanceMapper.updateById(annualMaintenance);
        }


        if (i > 0){

            batchSaveDevice(annualMaintenance.getId(), annualMaintenanceDeviceSaveDTOReqs,annualMaintenanceSaveDTOReq.getDelDeviceIds());

            return CommonResult.success();
        }

        return CommonResult.failed();
    }


    private void batchSaveDevice(Long annualMaintenanceId, List<AnnualMaintenanceDeviceSaveDTOReq> annualMaintenanceDeviceSaveDTOReqs,List<Long> delDeviceIds) {
        if (ObjectUtils.isNotEmpty(delDeviceIds)){
            int update = annualMaintenanceDeviceMapper.update(new AnnualMaintenanceDevice(),
                    new LambdaUpdateWrapper<AnnualMaintenanceDevice>().set(AnnualMaintenanceDevice::getDelFlag, UserConstant.DEPT_DISABLE)
                            .set(AnnualMaintenanceDevice::getUpdateTime, LocalDateTime.now()).set(AnnualMaintenanceDevice::getUpdateBy, SecurityUtils.getUsername())
                            .in(AnnualMaintenanceDevice::getId, delDeviceIds)
            );
            if (update <= 0){
                throw new RuntimeException("删除年度基础设施维护计划设备失败");
            }
        }
        
        for (AnnualMaintenanceDeviceSaveDTOReq annualMaintenanceDeviceSaveDTOReq : annualMaintenanceDeviceSaveDTOReqs) {
            AnnualMaintenanceDevice annualMaintenanceDevice = new AnnualMaintenanceDevice();
            BeanUtils.copyProperties(annualMaintenanceDeviceSaveDTOReq,annualMaintenanceDevice);
            annualMaintenanceDevice.setAnnualMaintenanceId(annualMaintenanceId);
            if (annualMaintenanceDevice.getId() == null){
                annualMaintenanceDevice.setCreateBy(SecurityUtils.getUsername());
                annualMaintenanceDevice.setCreateTime(LocalDateTime.now());
                int insert = annualMaintenanceDeviceMapper.insert(annualMaintenanceDevice);
                if (insert <= 0){
                    throw new RuntimeException("保存年度基础设施维护计划设备失败");
                }
                
                List<AnnualMaintenanceDeviceType> annualMaintenanceDeviceTypes = annualMaintenanceDeviceSaveDTOReq.getAnnualMaintenanceDeviceTypes();
                if (ObjectUtils.isNotEmpty(annualMaintenanceDeviceTypes)){ 
                    for (AnnualMaintenanceDeviceType annualMaintenanceDeviceType : annualMaintenanceDeviceTypes) { 
                        annualMaintenanceDeviceType.setAnnualMaintenanceDeviceId(annualMaintenanceDevice.getId());
                        annualMaintenanceDeviceType.setCreateBy(SecurityUtils.getUsername());
                        annualMaintenanceDeviceType.setCreateTime(LocalDateTime.now());
                        int insert1 = annualMaintenanceDeviceTypeMapper.insert(annualMaintenanceDeviceType);
                        if (insert1 <= 0){
                            throw new RuntimeException("保存年度基础设施维护计划设备类型失败");
                        }
                    }
                }
            }else {
                annualMaintenanceDevice.setUpdateBy(SecurityUtils.getUsername());
                annualMaintenanceDevice.setUpdateTime(LocalDateTime.now());
                int update = annualMaintenanceDeviceMapper.updateById(annualMaintenanceDevice);
                if (update <= 0){
                    throw new RuntimeException("更新年度基础设施维护计划设备失败");
                }
                List<AnnualMaintenanceDeviceType> annualMaintenanceDeviceTypes = annualMaintenanceDeviceSaveDTOReq.getAnnualMaintenanceDeviceTypes();
                if (ObjectUtils.isNotEmpty(annualMaintenanceDeviceTypes)){ 
                    for (AnnualMaintenanceDeviceType annualMaintenanceDeviceType : annualMaintenanceDeviceTypes) { 
                        annualMaintenanceDeviceType.setAnnualMaintenanceDeviceId(annualMaintenanceDevice.getId());
                        if (annualMaintenanceDeviceType.getId() == null){
                            annualMaintenanceDeviceType.setCreateBy(SecurityUtils.getUsername());
                            annualMaintenanceDeviceType.setCreateTime(LocalDateTime.now());
                            int insert1 = annualMaintenanceDeviceTypeMapper.insert(annualMaintenanceDeviceType);
                            if (insert1 <= 0){
                                throw new RuntimeException("保存年度基础设施维护计划设备类型失败");
                            }
                        }else {
                            annualMaintenanceDeviceType.setUpdateBy(SecurityUtils.getUsername());
                            annualMaintenanceDeviceType.setUpdateTime(LocalDateTime.now());
                            int update1 = annualMaintenanceDeviceTypeMapper.updateById(annualMaintenanceDeviceType);
                            if (update1 <= 0){
                                throw new RuntimeException("更新年度基础设施维护计划设备类型失败");
                            }
                        }
                       
                    }
                }
                
            }
          
          
        }
    }
    @Override
    public CommonResult getAnnualMaintenance(Integer id) {

        AnnualMaintenanceInfoRep annualMaintenanceInfoRep = new AnnualMaintenanceInfoRep();
        AnnualMaintenance annualMaintenance = annualMaintenanceMapper.selectById(id);
        BeanUtils.copyProperties(annualMaintenance,annualMaintenanceInfoRep);
        LambdaQueryWrapper<AnnualMaintenanceDevice> eq = new LambdaQueryWrapper<AnnualMaintenanceDevice>().eq(AnnualMaintenanceDevice::getAnnualMaintenanceId, id)
                .eq(AnnualMaintenanceDevice::getDelFlag, UserConstant.ENABLE).orderByDesc(AnnualMaintenanceDevice::getCreateTime);
        List<AnnualMaintenanceDevice> annualMaintenanceDevices = annualMaintenanceDeviceMapper.selectList(eq);
        if (ObjectUtils.isNotEmpty(annualMaintenanceDevices)){
            for (AnnualMaintenanceDevice annualMaintenanceDevice : annualMaintenanceDevices) {

                List<AnnualMaintenanceDeviceType> annualMaintenanceDeviceTypes =
                        annualMaintenanceDeviceTypeMapper.selectList(new LambdaQueryWrapper<AnnualMaintenanceDeviceType>()
                                .eq(AnnualMaintenanceDeviceType::getAnnualMaintenanceDeviceId, annualMaintenanceDevice.getId())
                                        .eq(AnnualMaintenanceDeviceType::getDelFlag, UserConstant.ENABLE)
                                .orderByAsc(AnnualMaintenanceDeviceType::getProjectType));
                annualMaintenanceDevice.setAnnualMaintenanceDeviceTypeList(annualMaintenanceDeviceTypes);
            }
        }
        annualMaintenanceInfoRep.setAnnualMaintenanceDeviceList(annualMaintenanceDevices);

        return CommonResult.success(annualMaintenanceInfoRep);
    }

    @Override
    @Transactional
    public CommonResult deletedAnnualMaintenance(Integer id) {
        AnnualMaintenance annualMaintenance = new AnnualMaintenance();
        annualMaintenance.setId(Long.valueOf( id));
        annualMaintenance.setDelFlag(1);
        annualMaintenance.setUpdateBy(SecurityUtils.getUsername());
        annualMaintenance.setUpdateTime(LocalDateTime.now());
        int update = annualMaintenanceMapper.updateById(annualMaintenance);
        if (update > 0){
            LambdaQueryWrapper<AnnualMaintenanceDevice> eq = new LambdaQueryWrapper<AnnualMaintenanceDevice>().eq(AnnualMaintenanceDevice::getAnnualMaintenanceId, id).eq(AnnualMaintenanceDevice::getDelFlag, UserConstant.ENABLE);
            List<Long> deviceIds = annualMaintenanceDeviceMapper.selectList(eq).stream().map(AnnualMaintenanceDevice::getId).collect(Collectors.toList());
            if (ObjectUtils.isNotEmpty(deviceIds)){
                AnnualMaintenanceDevice annualMaintenanceDevice = new AnnualMaintenanceDevice();
                annualMaintenanceDevice.setDelFlag(1);
                annualMaintenanceDevice.setUpdateBy(SecurityUtils.getUsername());
                annualMaintenanceDevice.setUpdateTime(LocalDateTime.now());
                int update1 = annualMaintenanceDeviceMapper.update(annualMaintenanceDevice, eq);
                if (update1 > 0){
                    AnnualMaintenanceDeviceType annualMaintenanceDeviceType = new AnnualMaintenanceDeviceType();
                    annualMaintenanceDeviceType.setDelFlag(1);
                    annualMaintenanceDeviceType.setUpdateBy(SecurityUtils.getUsername());
                    annualMaintenanceDeviceType.setUpdateTime(LocalDateTime.now());
                    int update2 = annualMaintenanceDeviceTypeMapper.update(annualMaintenanceDeviceType, new LambdaQueryWrapper<AnnualMaintenanceDeviceType>().in(AnnualMaintenanceDeviceType::getAnnualMaintenanceDeviceId, deviceIds));
                    if (update2 <= 0){
                        throw new RuntimeException("删除数据失败");
                    }
                }
            }else {
                throw new RuntimeException("删除数据失败");
            }

            return CommonResult.success();
        }
        return CommonResult.failed();
    }
}