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.AnnualMaintenanceRecord;
import com.gkhy.exam.system.domain.AnnualMaintenanceRecordUser;
import com.gkhy.exam.system.mapper.AnnualMaintenanceRecordMapper;
import com.gkhy.exam.system.mapper.AnnualMaintenanceRecordUserMapper;
import com.gkhy.exam.system.service.AnnualMaintenanceRecordService;
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.Set;
import java.util.stream.Collectors;

/**
 * <p>
 * 年度基础设施维护记录表	 服务实现类
 * </p>
 *
 * @author hh
 * @since 2025-07-31 16:12:02
 */
@Service
public class AnnualMaintenanceRecordServiceImpl extends ServiceImpl<AnnualMaintenanceRecordMapper, AnnualMaintenanceRecord> implements AnnualMaintenanceRecordService {

    @Autowired
    private AnnualMaintenanceRecordMapper annualMaintenanceRecordMapper;
    @Autowired
    private AnnualMaintenanceRecordUserMapper annualMaintenanceRecordUserMapper;

    @Override
    public CommonPage selectAnnualMaintenanceRecordList(AnnualMaintenanceRecord annualMaintenanceRecord) {
        PageUtils.startPage();
        List<AnnualMaintenanceRecord> annualMaintenanceRecords = annualMaintenanceRecordMapper.getAnnualMaintenanceRecord(annualMaintenanceRecord);
        return CommonPage.restPage(annualMaintenanceRecords);
    }

    @Override
    @Transactional
    public CommonResult saveAnnualMaintenanceRecord(AnnualMaintenanceRecord annualMaintenanceRecord) {
        List<AnnualMaintenanceRecordUser> annualMaintenanceRecordUsers = annualMaintenanceRecord.getAnnualMaintenanceRecordUsers();
        if (ObjectUtils.isEmpty(annualMaintenanceRecordUsers)){
            return CommonResult.failed("年度基础设施维护记录人员不能为空");
        }
        boolean isAdd = annualMaintenanceRecord.getId() == null;
        int i = 0;
        if (isAdd){
            annualMaintenanceRecord.setCreateBy(SecurityUtils.getUsername());
            annualMaintenanceRecord.setCreateTime(LocalDateTime.now());
            i = annualMaintenanceRecordMapper.insert(annualMaintenanceRecord);
        }else {
            annualMaintenanceRecord.setUpdateBy(SecurityUtils.getUsername());
            annualMaintenanceRecord.setUpdateTime(LocalDateTime.now());
            i = annualMaintenanceRecordMapper.updateById(annualMaintenanceRecord);
        }
        if (i > 0){

            return CommonResult.success();
        }
        return CommonResult.failed();
    }
    private void batchSaveRecordUser(boolean isAdd,Long annualMaintenanceRecordId, List<AnnualMaintenanceRecordUser> annualMaintenanceRecordUsers,List<Long> delRecordUserIds) {
        List<AnnualMaintenanceRecordUser> filteredUsers = annualMaintenanceRecordUsers.stream()
                .filter(user -> 1 == user.getUserType())
                .collect(Collectors.toList());
        Set<Long> userIdSet = filteredUsers.stream()
                .map(AnnualMaintenanceRecordUser::getUserId)
                .collect(Collectors.toSet());
        if (userIdSet.size() != filteredUsers.size()){
            throw new RuntimeException("年度基础设施维护记录操作管理人员重复");
        }
        List<AnnualMaintenanceRecordUser> fixUsers = annualMaintenanceRecordUsers.stream()
                .filter(user -> 2 == user.getUserType())
                .collect(Collectors.toList());
        Set<Long> fixUserIdSet = fixUsers.stream()
                .map(AnnualMaintenanceRecordUser::getUserId)
                .collect(Collectors.toSet());
        if (fixUserIdSet.size() != fixUsers.size()){
            throw new RuntimeException("年度基础设施维护记录人员重复");
        }
        if (ObjectUtils.isEmpty(filteredUsers) || ObjectUtils.isEmpty(fixUsers)){
            throw new RuntimeException("年度基础设施维护记录人员或操作管理人员不能为空");
        }

        if (ObjectUtils.isNotEmpty(delRecordUserIds)){

            int update = annualMaintenanceRecordUserMapper.update(new AnnualMaintenanceRecordUser(),
                    new LambdaUpdateWrapper<AnnualMaintenanceRecordUser>().set(AnnualMaintenanceRecordUser::getDelFlag, UserConstant.DEPT_DISABLE)
                            .set(AnnualMaintenanceRecordUser::getUpdateTime, LocalDateTime.now()).set(AnnualMaintenanceRecordUser::getUpdateBy, SecurityUtils.getUsername())
                            .in(AnnualMaintenanceRecordUser::getId, delRecordUserIds)
            );
            if (update <= 0){
                throw new RuntimeException("删除年度基础设施维护记录人员失败");
            }
        }


        if (isAdd){
            annualMaintenanceRecordUsers.forEach(user -> {
                user.setAnnualMaintenanceRecordId(annualMaintenanceRecordId);
                user.setCreateTime(LocalDateTime.now());
                user.setCreateBy(SecurityUtils.getUsername());
            });
            int insert = annualMaintenanceRecordUserMapper.batchInsert(annualMaintenanceRecordUsers);
            if (insert <= 0){
                throw new RuntimeException("保存年度基础设施维护记录人员失败");
            }
        }else {
            List<AnnualMaintenanceRecordUser> addUser = annualMaintenanceRecordUsers.stream()
                    .filter(user -> null == user.getId())
                    .collect(Collectors.toList());
            if (ObjectUtils.isNotEmpty(addUser)){
                addUser.forEach(user -> {
                    user.setAnnualMaintenanceRecordId(annualMaintenanceRecordId);
                    user.setCreateTime(LocalDateTime.now());
                    user.setCreateBy(SecurityUtils.getUsername());
                });
                int insert = annualMaintenanceRecordUserMapper.batchInsert(annualMaintenanceRecordUsers);
                if (insert <= 0){
                    throw new RuntimeException("保存年度基础设施维护记录人员失败");
                }
            }

            List<AnnualMaintenanceRecordUser> updateUser = annualMaintenanceRecordUsers.stream()
                    .filter(user -> null == user.getId())
                    .collect(Collectors.toList());
            if (ObjectUtils.isNotEmpty(updateUser)){
                updateUser.forEach(user -> {
                    user.setUpdateTime(LocalDateTime.now());
                    user.setUpdateBy(SecurityUtils.getUsername());
                });
                int update = annualMaintenanceRecordUserMapper.batchUpdate(updateUser);
                if (update <= 0){
                    throw new RuntimeException("保存年度基础设施维护记录人员失败");
                }
            }

        }



    }


    @Override
    public CommonResult getAnnualMaintenanceRecord(Integer id) {
        AnnualMaintenanceRecord annualMaintenanceRecord = annualMaintenanceRecordMapper.selectById(id);
        if (ObjectUtils.isNotEmpty(annualMaintenanceRecord)){
            List<AnnualMaintenanceRecordUser> annualMaintenanceRecordUsers = annualMaintenanceRecordUserMapper.selectList(
                    new LambdaQueryWrapper<AnnualMaintenanceRecordUser>().eq(AnnualMaintenanceRecordUser::getAnnualMaintenanceRecordId, id)
                            .eq(AnnualMaintenanceRecordUser::getDelFlag, UserConstant.ENABLE).orderByAsc(AnnualMaintenanceRecordUser::getUserType));
            annualMaintenanceRecord.setAnnualMaintenanceRecordUsers(annualMaintenanceRecordUsers);
        }
        return CommonResult.success(annualMaintenanceRecord);
    }

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

        AnnualMaintenanceRecord annualMaintenanceRecord = new AnnualMaintenanceRecord();
        annualMaintenanceRecord.setId(Long.valueOf( id));
        annualMaintenanceRecord.setDelFlag(1);
        annualMaintenanceRecord.setUpdateBy(SecurityUtils.getUsername());
        annualMaintenanceRecord.setUpdateTime(LocalDateTime.now());
        int update = annualMaintenanceRecordMapper.updateById(annualMaintenanceRecord);
        if (update > 0){
            AnnualMaintenanceRecordUser annualMaintenanceRecordUser = new AnnualMaintenanceRecordUser();
            annualMaintenanceRecordUser.setDelFlag(1);
            annualMaintenanceRecordUser.setUpdateBy(SecurityUtils.getUsername());
            annualMaintenanceRecordUser.setUpdateTime(LocalDateTime.now());

            LambdaQueryWrapper<AnnualMaintenanceRecordUser> eq = new LambdaQueryWrapper<AnnualMaintenanceRecordUser>().eq(AnnualMaintenanceRecordUser::getAnnualMaintenanceRecordId, id);
            int update1 = annualMaintenanceRecordUserMapper.update(annualMaintenanceRecordUser, eq);
            if (update1 <= 0){
                throw new RuntimeException("删除年度基础设施维护计划人员失败");
            }
            return CommonResult.success();
        }
        return CommonResult.failed();
    }
}