package cn.iocoder.yudao.module.mes.service.md.workstation;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjUtil;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.enums.CommonStatusEnum;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.mes.controller.admin.md.workstation.vo.MesMdWorkstationPageReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.md.workstation.vo.MesMdWorkstationSaveReqVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.md.workstation.MesMdWorkshopDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.md.workstation.MesMdWorkstationDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.wm.warehouse.MesWmWarehouseDO;
import cn.iocoder.yudao.module.mes.dal.mysql.md.workstation.MesMdWorkstationMapper;
import cn.iocoder.yudao.module.mes.enums.wm.BarcodeBizTypeEnum;
import cn.iocoder.yudao.module.mes.service.wm.barcode.MesWmBarcodeService;
import cn.iocoder.yudao.module.mes.service.wm.warehouse.MesWmWarehouseService;
import cn.iocoder.yudao.module.mes.service.pro.process.MesProProcessService;
import jakarta.annotation.Resource;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;

import java.util.Collection;
import java.util.Collections;
import java.util.List;

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 MesMdWorkstationServiceImpl implements MesMdWorkstationService {

    @Resource
    private MesMdWorkstationMapper workstationMapper;

    @Resource
    @Lazy
    private MesMdWorkstationMachineService workstationMachineService;
    @Resource
    private MesMdWorkstationToolService workstationToolService;
    @Resource
    private MesMdWorkstationWorkerService workstationWorkerService;
    @Resource
    private MesMdWorkshopService workshopService;
    @Resource
    private MesWmWarehouseService warehouseService;
    @Resource
    private MesWmBarcodeService barcodeService;
    @Resource
    private MesProProcessService processService;

    @Override
    public Long createWorkstation(MesMdWorkstationSaveReqVO createReqVO) {
        // 校验数据
        validateWorkstationSaveData(null, createReqVO);

        // 插入
        MesMdWorkstationDO workstation = BeanUtils.toBean(createReqVO, MesMdWorkstationDO.class);
        workstationMapper.insert(workstation);

        // 自动生成条码
        barcodeService.autoGenerateBarcode(BarcodeBizTypeEnum.WORKSTATION.getValue(),
                workstation.getId(), workstation.getCode(), workstation.getName());
        return workstation.getId();
    }

    @Override
    public void updateWorkstation(MesMdWorkstationSaveReqVO updateReqVO) {
        // 校验存在
        validateWorkstationExists(updateReqVO.getId());
        // 校验数据
        validateWorkstationSaveData(updateReqVO.getId(), updateReqVO);

        // 更新
        MesMdWorkstationDO updateObj = BeanUtils.toBean(updateReqVO, MesMdWorkstationDO.class);
        workstationMapper.updateById(updateObj);
    }

    private void validateWorkstationSaveData(Long id, MesMdWorkstationSaveReqVO reqVO) {
        // 校验编码唯一
        validateWorkstationCodeUnique(id, reqVO.getCode());
        // 校验名称唯一
        validateWorkstationNameUnique(id, reqVO.getName());
        // 校验车间存在
        validateWorkshopExists(reqVO.getWorkshopId());
        // 校验工序存在
        processService.validateProcessExistsAndEnable(reqVO.getProcessId());
        // 处理仓库层级（未指定仓库时自动设置虚拟线边库）
        handleWarehouseHierarchy(reqVO);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteWorkstation(Long id) {
        // 校验存在
        validateWorkstationExists(id);

        // 级联删除子资源
        workstationMachineService.deleteWorkstationMachineByWorkstationId(id);
        workstationToolService.deleteWorkstationToolByWorkstationId(id);
        workstationWorkerService.deleteWorkstationWorkerByWorkstationId(id);
        // 删除工作站
        workstationMapper.deleteById(id);
    }

    @Override
    public MesMdWorkstationDO validateWorkstationExists(Long id) {
        MesMdWorkstationDO workstation = workstationMapper.selectById(id);
        if (workstation == null) {
            throw exception(MD_WORKSTATION_NOT_EXISTS);
        }
        return workstation;
    }

    @Override
    public MesMdWorkstationDO validateWorkstationExistsAndEnable(Long id) {
        MesMdWorkstationDO workstation = validateWorkstationExists(id);
        if (ObjUtil.notEqual(CommonStatusEnum.ENABLE.getStatus(), workstation.getStatus())) {
            throw exception(MD_WORKSTATION_IS_DISABLE);
        }
        return workstation;
    }

    private void validateWorkshopExists(Long workshopId) {
        MesMdWorkshopDO workshop = workshopService.getWorkshop(workshopId);
        if (workshop == null) {
            throw exception(MD_WORKSHOP_NOT_EXISTS);
        }
    }

    /**
     * 处理仓库：未填写仓库时自动设置虚拟线边仓
     *
     * @param reqVO 工作站保存请求对象
     */
    private void handleWarehouseHierarchy(MesMdWorkstationSaveReqVO reqVO) {
        Long warehouseId = reqVO.getWarehouseId();
        if (warehouseId == null) {
            MesWmWarehouseDO warehouse = warehouseService.getWarehouseByCode(MesWmWarehouseDO.WIP_VIRTUAL_WAREHOUSE);
            reqVO.setWarehouseId(warehouse.getId());
            return;
        }
        warehouseService.validateWarehouseExists(warehouseId);
    }

    private void validateWorkstationCodeUnique(Long id, String code) {
        MesMdWorkstationDO workstation = workstationMapper.selectByCode(code);
        if (workstation == null) {
            return;
        }
        if (ObjUtil.notEqual(workstation.getId(), id)) {
            throw exception(MD_WORKSTATION_CODE_DUPLICATE);
        }
    }

    private void validateWorkstationNameUnique(Long id, String name) {
        MesMdWorkstationDO workstation = workstationMapper.selectByName(name);
        if (workstation == null) {
            return;
        }
        if (ObjUtil.notEqual(workstation.getId(), id)) {
            throw exception(MD_WORKSTATION_NAME_DUPLICATE);
        }
    }

    @Override
    public MesMdWorkstationDO getWorkstation(Long id) {
        return workstationMapper.selectById(id);
    }

    @Override
    public PageResult<MesMdWorkstationDO> getWorkstationPage(MesMdWorkstationPageReqVO pageReqVO) {
        return workstationMapper.selectPage(pageReqVO);
    }

    @Override
    public List<MesMdWorkstationDO> getWorkstationListByStatus(Integer status) {
        return workstationMapper.selectListByStatus(status);
    }

    @Override
    public Long getWorkstationCountByWorkshopId(Long workshopId) {
        return workstationMapper.selectCountByWorkshopId(workshopId);
    }

    @Override
    public Long getWorkstationCountByWarehouseId(Long warehouseId) {
        return workstationMapper.selectCountByWarehouseId(warehouseId);
    }

    @Override
    public Long getWorkstationCountByLocationId(Long locationId) {
        return workstationMapper.selectCountByLocationId(locationId);
    }

    @Override
    public Long getWorkstationCountByAreaId(Long areaId) {
        return workstationMapper.selectCountByAreaId(areaId);
    }

    @Override
    public List<MesMdWorkstationDO> getWorkstationList(Collection<Long> ids) {
        if (CollUtil.isEmpty(ids)) {
            return Collections.emptyList();
        }
        return workstationMapper.selectByIds(ids);
    }

}