package cn.iocoder.yudao.module.mes.service.dv.borrow;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.mes.controller.admin.dv.borrow.vo.MesDvBorrowPageReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.dv.borrow.vo.MesDvBorrowSaveReqVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.dv.borrow.MesDvBorrowDO;
import cn.iocoder.yudao.module.mes.dal.mysql.dv.borrow.MesDvBorrowMapper;
import cn.iocoder.yudao.module.mes.enums.dv.MesDvBorrowStatusEnum;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Objects;

import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.*;

/**
 * MES 设备借用归还 Service 实现类
 *
 * @author 超级管理员
 */
@Service
@Validated
public class MesDvBorrowServiceImpl implements MesDvBorrowService {

    private static final DateTimeFormatter CODE_TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyyMMddHHmmss");

    @Resource
    private MesDvBorrowMapper borrowMapper;

    @Override
    public Long createBorrow(MesDvBorrowSaveReqVO createReqVO) {
        // 同一台设备不允许存在多条未归还记录，否则归还时无法判断归还的是哪一次借用
        if (borrowMapper.selectCountByMachineryIdAndStatus(createReqVO.getMachineryId(),
                MesDvBorrowStatusEnum.BORROWED.getStatus()) > 0) {
            throw exception(DV_BORROW_MACHINERY_BORROWED);
        }
        MesDvBorrowDO borrow = BeanUtils.toBean(createReqVO, MesDvBorrowDO.class);
        if (StrUtil.isBlank(borrow.getCode())) {
            borrow.setCode("JY" + LocalDateTime.now().format(CODE_TIME_FORMATTER));
        }
        if (borrowMapper.selectByCode(borrow.getCode()) != null) {
            throw exception(DV_BORROW_CODE_DUPLICATE);
        }
        borrow.setStatus(MesDvBorrowStatusEnum.BORROWED.getStatus());
        borrowMapper.insert(borrow);
        return borrow.getId();
    }

    @Override
    public void updateBorrow(MesDvBorrowSaveReqVO updateReqVO) {
        MesDvBorrowDO borrow = validateBorrowExists(updateReqVO.getId());
        if (MesDvBorrowStatusEnum.RETURNED.getStatus().equals(borrow.getStatus())) {
            throw exception(DV_BORROW_ALREADY_RETURNED);
        }
        if (StrUtil.isNotBlank(updateReqVO.getCode())) {
            MesDvBorrowDO sameCode = borrowMapper.selectByCode(updateReqVO.getCode());
            if (sameCode != null && !Objects.equals(sameCode.getId(), updateReqVO.getId())) {
                throw exception(DV_BORROW_CODE_DUPLICATE);
            }
        }
        MesDvBorrowDO updateObj = BeanUtils.toBean(updateReqVO, MesDvBorrowDO.class);
        updateObj.setStatus(null); // 状态只能通过归还接口变更
        borrowMapper.updateById(updateObj);
    }

    @Override
    public void deleteBorrow(Long id) {
        validateBorrowExists(id);
        borrowMapper.deleteById(id);
    }

    @Override
    public void returnBorrow(Long id, String returnCondition) {
        MesDvBorrowDO borrow = validateBorrowExists(id);
        if (MesDvBorrowStatusEnum.RETURNED.getStatus().equals(borrow.getStatus())) {
            throw exception(DV_BORROW_ALREADY_RETURNED);
        }
        borrowMapper.updateById(new MesDvBorrowDO().setId(id)
                .setStatus(MesDvBorrowStatusEnum.RETURNED.getStatus())
                .setActualReturnTime(LocalDateTime.now())
                .setReturnCondition(returnCondition));
    }

    @Override
    public MesDvBorrowDO getBorrow(Long id) {
        return borrowMapper.selectById(id);
    }

    @Override
    public PageResult<MesDvBorrowDO> getBorrowPage(MesDvBorrowPageReqVO pageReqVO) {
        return borrowMapper.selectPage(pageReqVO);
    }

    @Override
    public Map<Long, MesDvBorrowDO> getBorrowMap(Collection<Long> ids) {
        if (CollUtil.isEmpty(ids)) {
            return Collections.emptyMap();
        }
        return cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertMap(
                borrowMapper.selectByIds(ids), MesDvBorrowDO::getId);
    }

    @Override
    public List<MesDvBorrowDO> getBorrowedListByMachineryId(Long machineryId) {
        return borrowMapper.selectList(new cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX<MesDvBorrowDO>()
                .eq(MesDvBorrowDO::getMachineryId, machineryId)
                .eq(MesDvBorrowDO::getStatus, MesDvBorrowStatusEnum.BORROWED.getStatus()));
    }

    private MesDvBorrowDO validateBorrowExists(Long id) {
        MesDvBorrowDO borrow = borrowMapper.selectById(id);
        if (borrow == null) {
            throw exception(DV_BORROW_NOT_EXISTS);
        }
        return borrow;
    }

}