package com.ruoyi.business.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.basic.entity.Supply;
import com.ruoyi.basic.mapper.CoalInfoMapper;
import com.ruoyi.business.dto.EquipmentManagementDto;
import com.ruoyi.business.dto.EquipmentUsageRecordDto;
import com.ruoyi.business.entity.EquipmentManagement;
import com.ruoyi.business.entity.EquipmentUsageRecord;
import com.ruoyi.business.mapper.EquipmentManagementMapper;
import com.ruoyi.business.mapper.EquipmentUsageRecordMapper;
import com.ruoyi.business.service.EquipmentUsageRecordService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.utils.bean.BeanUtils;
import com.ruoyi.system.mapper.SysUserMapper;
import org.springframework.stereotype.Service;
import lombok.RequiredArgsConstructor;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDate;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * <p>
 * 设备使用记录表 服务实现类
 * </p>
 *
 * @author ld
 * @since 2025-07-07
 */
@Service
@RequiredArgsConstructor
public class EquipmentUsageRecordServiceImpl extends ServiceImpl<EquipmentUsageRecordMapper, EquipmentUsageRecord> implements EquipmentUsageRecordService {

    private final EquipmentUsageRecordMapper equipmentUsageRecordMapper;

    private final EquipmentManagementMapper equipmentManagementMapper;

    private final SysUserMapper sysUserMapper;

    @Override
    public IPage<EquipmentUsageRecordDto> selectUsageRecordList(Page<EquipmentUsageRecord> page, EquipmentUsageRecordDto equipmentUsageRecordDto) {
        Page<EquipmentUsageRecord> entityPage = equipmentUsageRecordMapper.selectPage(page, null);
        IPage<EquipmentUsageRecordDto> dtoPage = new Page<>();
        BeanUtils.copyProperties(entityPage, dtoPage);

        List<Long> eqIds = entityPage.getRecords().stream().map(EquipmentUsageRecord::getEquipmentId).toList();
        List<Long> userIds = entityPage.getRecords().stream().map(EquipmentUsageRecord::getUserId).toList();
        //批量查询设备
        Map<Long, EquipmentManagement> equipmentManagementMap;
        if (!eqIds.isEmpty()) {
            List<EquipmentManagement> infos = equipmentManagementMapper.selectList(new LambdaQueryWrapper<EquipmentManagement>().in(EquipmentManagement::getId, eqIds));
            equipmentManagementMap = infos.stream().collect(Collectors.toMap(EquipmentManagement::getId, Function.identity()));
        } else {
            equipmentManagementMap = new HashMap<>();
        }
        //人员查询
        Map<Long, SysUser> userMap;
        if (!userIds.isEmpty()) {
            List<SysUser> sysUsers = sysUserMapper.selectList(userIds);
            userMap = sysUsers.stream().collect(Collectors.toMap(SysUser::getUserId, Function.identity()));
        } else {
            userMap = new HashMap<>();
        }
        //匹配数据
        List<EquipmentUsageRecordDto> dtoRecords = entityPage.getRecords().stream().map(entity -> {
            EquipmentUsageRecordDto dto = new EquipmentUsageRecordDto();
            BeanUtils.copyProperties(entity, dto);
            EquipmentManagement equipment = equipmentManagementMap.get(entity.getEquipmentId());
            if (equipment != null) {
                dto.setEquipmentNo(equipment.getEquipmentNo());
                dto.setEquipmentName(equipment.getEquipmentName());
            }
            SysUser sysUser = userMap.get(entity.getUserId());
            if (sysUser != null) {
                dto.setUserName(sysUser.getNickName());
            }
            return dto;
        }).toList();
        dtoPage.setRecords(dtoRecords);
        return dtoPage;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public int addOrEditUsageRecord(EquipmentUsageRecordDto equipmentUsageRecordDto) {
        // 参数校验
        if (equipmentUsageRecordDto == null) {
            throw new IllegalArgumentException("设备使用记录参数不能为空");
        }

        // 复制属性到实体对象
        EquipmentUsageRecord equipmentUsageRecord = new EquipmentUsageRecord();
        BeanUtils.copyProperties(equipmentUsageRecordDto, equipmentUsageRecord);

        // 获取设备ID和领用数量
        Long equipmentId = equipmentUsageRecordDto.getEquipmentId();
        Integer newUsageQuantity = equipmentUsageRecordDto.getUsageQuantity();

        // 查询设备信息
        EquipmentManagement equipment = equipmentManagementMapper.selectById(equipmentId);
        if (equipment == null) {
            throw new RuntimeException("设备不存在");
        }

        // 新增记录逻辑
        if (Objects.isNull(equipmentUsageRecordDto.getId())) {
            // 检查库存是否充足
            if (equipment.getQuantity() < newUsageQuantity) {
                throw new RuntimeException("库存不足，当前库存：" + equipment.getQuantity());
            }

            // 扣减库存
            equipment.setQuantity(equipment.getQuantity() - newUsageQuantity);
            equipmentManagementMapper.updateById(equipment);

            // 设置使用开始时间为当前时间
            equipmentUsageRecord.setUsageStartTime(LocalDate.now());
            return equipmentUsageRecordMapper.insert(equipmentUsageRecord);
        } else {
            // 编辑记录逻辑
            EquipmentUsageRecord originalRecord = equipmentUsageRecordMapper.selectById(equipmentUsageRecordDto.getId());
            if (originalRecord == null) {
                throw new RuntimeException("领用记录不存在");
            }

            // 处理归还逻辑
            if (equipmentUsageRecordDto.getEquipmentStatus() == 2) {
                // 检查归还数量是否合法
                if (newUsageQuantity > originalRecord.getUsageQuantity()) {
                    throw new RuntimeException("归还数量不能超过原领用数量");
                }

                // 计算实际归还数量（原领用数量 - 新领用数量）
                int returnedQuantity = originalRecord.getUsageQuantity() - newUsageQuantity;

                // 恢复部分库存
                equipment.setQuantity(equipment.getQuantity() + returnedQuantity);
                equipmentManagementMapper.updateById(equipment);

                // 如果全部归还，设置归还时间
                if (newUsageQuantity == 0) {
                    equipmentUsageRecord.setUsageEndTime(LocalDate.now());
                }
                return equipmentUsageRecordMapper.updateById(equipmentUsageRecord);
            }

            // 处理普通编辑逻辑（非归还状态）
            if (!newUsageQuantity.equals(originalRecord.getUsageQuantity())) {
                // 计算库存变化量（旧数量 - 新数量）
                int quantityDelta = originalRecord.getUsageQuantity() - newUsageQuantity;

                // 检查调整后库存是否充足
                int newInventory = equipment.getQuantity() + quantityDelta;
                if (newInventory < 0) {
                    throw new RuntimeException("库存不足，调整后库存将为：" + newInventory);
                }

                // 调整库存
                equipment.setQuantity(newInventory);
                if (equipmentManagementMapper.updateById(equipment) == 0) {
                    throw new RuntimeException("库存更新失败，可能已被其他操作修改");
                }
            }

            // 更新领用记录
            return equipmentUsageRecordMapper.updateById(equipmentUsageRecord);
        }
    }
}