package com.mes.rawglassdetails.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.extension.service.impl.ServiceImpl;
import com.kangaroohy.milo.model.ReadWriteEntity;
import com.kangaroohy.milo.service.MiloService;
import com.mes.common.config.Const;
import com.mes.rawglassdetails.entity.RawGlassStorageDetails;
import com.mes.rawglassdetails.entity.dto.RawGlassStorageDetailsDTO;
import com.mes.rawglassdetails.entity.request.RawGlassRequest;
import com.mes.rawglassdetails.mapper.RawGlassStorageDetailsMapper;
import com.mes.rawglassdetails.service.RawGlassStorageDetailsService;
import com.mes.rawglassstation.entity.RawGlassStorageStation;
import com.mes.rawglassstation.service.RawGlassStorageStationService;
import com.mes.rawglasstask.entity.RawGlassStorageTask;
import com.mes.rawglasstask.service.RawGlassStorageTaskService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.MessageSource;
import org.springframework.context.i18n.LocaleContextHolder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * @author system
 * @since 2024-07-09 14:51:27
 */
@Service
@Slf4j
public class RawGlassStorageDetailsServiceImpl extends ServiceImpl<RawGlassStorageDetailsMapper, RawGlassStorageDetails> implements RawGlassStorageDetailsService {

    @Autowired
    RawGlassStorageTaskService rawGlassStorageTaskService;

    @Autowired
    RawGlassStorageStationService rawGlassStorageStationService;

    @Autowired(required = false)
    MiloService miloService;

    @Resource
    private MessageSource messageSource;

    // 吊装位
    private static final Integer LEFTING_01 = 99;

    @Override
    public boolean deleteRawGlassStorageDetails(String device_id) {
        QueryWrapper<RawGlassStorageDetails> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("device_id", device_id);
        return remove(queryWrapper);//remove才是删除，delete得用另外的依赖，默认方法是remove返回bool
    }

    @Override
    //返回类型                    方法名              传输值
    public List<RawGlassStorageDetails> selectDetails() {
//        QueryWrapper<RawGlassStorageDetails>queryWrapper=new QueryWrapper<>();
//         queryWrapper.eq("id",rs.getId());
//        return list(queryWrapper);
        return list();
    }

    // 空架子到吊装位
    @Override
    @Transactional(rollbackFor = Exception.class)
    public String warehousingRequest(int leftingStation) {
        RawGlassStorageDetails storageDetails = getOne(new LambdaQueryWrapper<RawGlassStorageDetails>()
                .in(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN_ALL)
                .eq(RawGlassStorageDetails::getSlot, leftingStation)
                // 添加行锁，其他请求需等待锁释放
                .last("FOR UPDATE"));

        if (null != storageDetails) {
            log.info("当前吊装位有架子，结束本地入库请求");
            return messageSource.getMessage(
                    "rawglass.warehousing.slot.occupied",
                    null,
                    LocaleContextHolder.getLocale()
            );
        }

        List<RawGlassStorageDetails> shelfList = listBySlotState(Const.RAW_GLASS_DEVICE, Const.RAW_GLASS_STATE_IN_ALL);
        if (CollectionUtils.isEmpty(shelfList)) {
            log.info("当前工位不存在可用的空架子");
            return messageSource.getMessage(
                    "rawglass.no.empty.shelf",
                    null,
                    LocaleContextHolder.getLocale()
            );
        }

        if (rawGlassStorageTaskService.count(new LambdaQueryWrapper<RawGlassStorageTask>()
                .eq(RawGlassStorageTask::getEndSlot, leftingStation)
                .in(RawGlassStorageTask::getTaskState, Const.RAW_GLASS_TASK_NEW, Const.RAW_GLASS_TASK_RUNNING)) > 0) {

            log.info("吊装位 {} 已有未完成任务，拒绝重复下发", leftingStation);
            return messageSource.getMessage(
                    "rawglass.warehousing.task.exists",
                    null,
                    LocaleContextHolder.getLocale()
            );
        }

        Integer shelf = shelfList.get(0).getSlot();
        Integer deviceId = shelfList.get(0).getDeviceId();
        log.info("生成任务");
        try {
            generateTask(shelf, leftingStation, shelf, 0, Const.RAW_GLASS_TASK_TYPE_IN_REQUEST);
        } catch (Exception e) {
            return messageSource.getMessage(
                    "rawglass.task.generate.error",
                    null,
                    LocaleContextHolder.getLocale()
            );
        }
        //生成一条详情数据  仅记录架子状态
        RawGlassStorageDetails details = new RawGlassStorageDetails();
        details.setSlot(shelf);
        details.setShelf(shelf);
        details.setDeviceId(deviceId);
        details.setState(Const.RAW_GLASS_STATE_RUNNING);
        save(details);
        return "success";
    }

    /**
     * 原片入库
     *
     * @param request
     * @return
     */
    @Override
    public String patternWarehousing(RawGlassRequest request) {
        RawGlassStorageDetails glassStorageDetails = getOne(new LambdaQueryWrapper<RawGlassStorageDetails>()
                .eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
                .eq(RawGlassStorageDetails::getSlot, request.getSlot()));
        if (null == glassStorageDetails) {
            log.info("当前工位不存在可用的架子");
            return messageSource.getMessage(
                    "rawglass.no.empty.shelf",
                    null,
                    LocaleContextHolder.getLocale()
            );
        }
        //原片信息存入详情表
        BeanUtils.copyProperties(request, glassStorageDetails);
        log.info("覆盖后得到的工位详情信息为：{}", glassStorageDetails);
        updateById(glassStorageDetails);
        return "success";
    }

    @Override
    public String updateQuantity(RawGlassRequest request) {
        RawGlassStorageDetails one = getOne(new LambdaQueryWrapper<RawGlassStorageDetails>().eq(RawGlassStorageDetails::getSlot, request.getSlot())
                .eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN));
        if (null == one) {
            RawGlassStorageDetails details = new RawGlassStorageDetails();
            BeanUtils.copyProperties(request, details);
            details.setState(Const.RAW_GLASS_STATE_IN);
            details.setShelf(request.getSlot());
            save(details);
        } else {
            update(
                    new LambdaUpdateWrapper<RawGlassStorageDetails>()
                            .set(RawGlassStorageDetails::getRemainQuantity, request.getRemainQuantity())
                            .set(RawGlassStorageDetails::getPatternWidth, request.getPatternWidth())
                            .set(RawGlassStorageDetails::getPatternHeight, request.getPatternHeight())
                            .set(RawGlassStorageDetails::getPatternThickness, request.getPatternThickness())
                            .set(RawGlassStorageDetails::getFilmsId, request.getFilmsId())
                            .eq(RawGlassStorageDetails::getSlot, request.getSlot())
                            .eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN));
        }
        return "success";
    }

    @Override
    public String deleteWarehousing(Long slotId) {
        remove(new LambdaUpdateWrapper<RawGlassStorageDetails>().eq(RawGlassStorageDetails::getSlot, slotId)
                .eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN));
        return "success";
    }

    // 出库
    @Override
    public String outWarehousing(Long slotId) {
        // 1. 检查当前架子状态
        RawGlassStorageDetails details = getOne(new LambdaQueryWrapper<RawGlassStorageDetails>()
                .eq(RawGlassStorageDetails::getSlot, slotId)
                .eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN));
        if (details == null) {
            log.info("架子状态异常，无法执行出库操作");
            return messageSource.getMessage(
                    "rawglass.outWarehousing.error",
                    null,
                    LocaleContextHolder.getLocale()
            );
        }

        // 2. 将架子状态改为“待出库”（标记为可执行）
        update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
                .eq(RawGlassStorageDetails::getSlot, slotId)
                .set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_WAIT_OUT));

        // 3. 直接生成出库任务（关键：在页面点击时就创建任务记录）
        try {
            // 起始位：仓库存储位（slotId），目标位：吊装位99
            generateTask(
                    slotId.intValue(),          // 起始位：仓库存储位（slotId）
                    LEFTING_01,                 // 目标位：吊装位99
                    slotId.intValue(),          // 架子号
                    details.getRemainQuantity(), // 数量
                    Const.RAW_GLASS_TASK_TYPE_OUT // 任务类型：出库
            );
            log.info("出库任务生成成功，架子：{}，目标位：{}", slotId, LEFTING_01);
            return "success";
        } catch (Exception e) {
            log.error("生成出库任务失败", e);
            // 失败时回滚状态
            update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
                    .eq(RawGlassStorageDetails::getSlot, slotId)
                    .set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN));
            return messageSource.getMessage(
                    "rawglass.task.generate.error",
                    null,
                    LocaleContextHolder.getLocale()
            );
        }
    }

    @Override
    public List<RawGlassStorageDetails> listBySlotState(List<Integer> liftingStation, List<Integer> state) {
        return baseMapper.listBySlotState(liftingStation, state);
    }

    // 回库
    @Override
    public String outWarehousingRequest(int leftingStation) {
        //对应工位是否有空架子
        RawGlassStorageDetails details = getOne(new LambdaQueryWrapper<RawGlassStorageDetails>().eq(RawGlassStorageDetails::getState, Const.GLASS_STATE_IN)
                .eq(RawGlassStorageDetails::getSlot, leftingStation));
        if (null == details) {
            log.info("无空架子，结束回库任务");
            return messageSource.getMessage(
                    "rawglass.no.empty.shelf",
                    null,
                    LocaleContextHolder.getLocale()
            );
        }
        //生成一条详情数据  仅记录架子状态
        update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
                .eq(RawGlassStorageDetails::getSlot, details.getSlot())
                .eq(RawGlassStorageDetails::getState, Const.GLASS_STATE_IN)
                .set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_RUNNING));
        try {
            generateTask(leftingStation, details.getShelf(), details.getShelf(), details.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_IN);
        } catch (Exception e) {
            return messageSource.getMessage(
                    "rawglass.task.generate.error",
                    null,
                    LocaleContextHolder.getLocale()
            );
        }
        return "success";
    }

    /**
     * 生成原片仓储任务
     *
     * @param startSlot
     * @param endSlot
     * @param patternQuantity
     * @param taskType
     * @return
     */
    @Override
    public boolean generateTask(int startSlot, int endSlot, int shelf, int patternQuantity, int taskType) throws Exception {
        RawGlassStorageTask task = RawGlassStorageTask.builder()
                .startSlot(startSlot)
                .endSlot(endSlot)
                .patternQuantity(patternQuantity)
                .taskType(taskType)
                .taskState(Const.RAW_GLASS_TASK_NEW)
                .shelf(shelf)
                .createTime(new Date()).build();
        rawGlassStorageTaskService.save(task);
//        List<ReadWriteEntity> list = new ArrayList<>();
//        list.add(generateReadWriteEntity("CC.CC.taskWord", 1));
//        list.add(generateReadWriteEntity("CC.CC.startSlot", startSlot));
//        list.add(generateReadWriteEntity("CC.CC.endSlot", endSlot));
//        miloService.writeToOpcWord(list);
        return Boolean.TRUE;
    }

    private ReadWriteEntity generateReadWriteEntity(String identifier, int value) {
        ReadWriteEntity readWriteEntity = new ReadWriteEntity();
        readWriteEntity.setIdentifier(identifier);
        readWriteEntity.setValue(value);
        return readWriteEntity;
    }

    @Override
    public String shelfReset(Long slot) {
        update(new LambdaUpdateWrapper<RawGlassStorageDetails>().eq(RawGlassStorageDetails::getSlot, slot)
                .eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
                .set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_RESET));
        //生成一条详情数据  仅记录架子状态
        return "success";
    }

    @Override
    public List<RawGlassStorageDetailsDTO> patternUsage(String width, String height, String thickness, String films){
        return baseMapper.patternUsage(width, height, thickness, films);
    }

    @Override
    public RawGlassStorageDetails generateDetails(RawGlassStorageDetails details, Integer targetSlot) {
        RawGlassStorageDetails targetDetails = new RawGlassStorageDetails();
        RawGlassStorageStation station = rawGlassStorageStationService.getOne(new LambdaQueryWrapper<RawGlassStorageStation>()
                .eq(RawGlassStorageStation::getSlot, targetSlot));
        targetDetails.setDeviceId(station.getDeviceId());
        targetDetails.setSlot(targetSlot);
        targetDetails.setShelf(details.getShelf());
        targetDetails.setPatternWidth(details.getPatternWidth());
        targetDetails.setPatternHeight(details.getPatternHeight());
        targetDetails.setPatternThickness(details.getPatternThickness());
        targetDetails.setFilmsId(details.getFilmsId());
        targetDetails.setRemainQuantity(details.getRemainQuantity());
        targetDetails.setCreateTime(new Date());
        targetDetails.setState(Const.RAW_GLASS_STATE_IN);
        return targetDetails;
    }
}