package com.zy.core.utils;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.zy.asrs.entity.BasCrnp;
import com.zy.asrs.entity.LocMast;
import com.zy.asrs.entity.WrkMast;
import com.zy.asrs.service.BasCrnpService;
import com.zy.asrs.service.LocMastService;
import com.zy.asrs.service.WrkAnalysisService;
import com.zy.asrs.service.WrkMastService;
import com.zy.asrs.utils.NotifyUtils;
import com.zy.common.service.CommonService;
import com.zy.common.utils.RedisUtil;
import com.zy.core.cache.MessageQueue;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.CrnModeType;
import com.zy.core.enums.CrnStatusType;
import com.zy.core.enums.SlaveType;
import com.zy.core.enums.WrkIoType;
import com.zy.core.enums.WrkStsType;
import com.zy.core.model.Task;
import com.zy.core.model.command.CrnCommand;
import com.zy.core.model.protocol.CrnProtocol;
import com.zy.core.thread.CrnThread;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.springframework.test.util.ReflectionTestUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

class CrnOperateProcessUtilsTest {

    @AfterEach
    void tearDown() {
        safeClearQueue(1);
        safeClearQueue(2);
        SlaveConnection.remove(SlaveType.Crn, 1);
        SlaveConnection.remove(SlaveType.Crn, 2);
        SlaveConnection.remove(SlaveType.Devp, 101);
    }

    @Test
    void dispatchCrnMove_createsFormalTaskOnly() {
        CrnOperateProcessUtils utils = new CrnOperateProcessUtils();
        WrkMastService wrkMastService = mock(WrkMastService.class);
        CommonService commonService = mock(CommonService.class);
        WrkAnalysisService wrkAnalysisService = mock(WrkAnalysisService.class);
        CrnThread crnThread = mock(CrnThread.class);

        ReflectionTestUtils.setField(utils, "wrkMastService", wrkMastService);
        ReflectionTestUtils.setField(utils, "commonService", commonService);
        ReflectionTestUtils.setField(utils, "wrkAnalysisService", wrkAnalysisService);

        when(wrkMastService.count(any())).thenReturn(0L);
        when(wrkMastService.getOne(any())).thenReturn(null);
        when(commonService.getWorkNo(WrkIoType.CRN_MOVE.id)).thenReturn(30001);
        AtomicReference<WrkMast> savedSnapshot = new AtomicReference<>();
        when(wrkMastService.save(any(WrkMast.class))).thenAnswer(invocation -> {
            WrkMast source = invocation.getArgument(0);
            WrkMast snapshot = new WrkMast();
            snapshot.setWrkNo(source.getWrkNo());
            snapshot.setIoType(source.getIoType());
            snapshot.setWrkSts(source.getWrkSts());
            snapshot.setLocNo(source.getLocNo());
            snapshot.setCrnNo(source.getCrnNo());
            savedSnapshot.set(snapshot);
            return true;
        });

        MessageQueue.init(SlaveType.Crn, 1);
        CrnProtocol protocol = buildProtocol(1, CrnStatusType.IDLE.id, 0);
        protocol.setBay(8);
        protocol.setLevel(3);
        when(crnThread.getStatus()).thenReturn(protocol);
        SlaveConnection.put(SlaveType.Crn, 1, crnThread);

        boolean dispatched = utils.dispatchCrnMove(1, "2-1-1");

        assertTrue(dispatched);

        verify(wrkMastService).save(any(WrkMast.class));
        WrkMast saved = savedSnapshot.get();
        assertNotNull(saved);
        assertEquals(30001, saved.getWrkNo());
        assertEquals(WrkIoType.CRN_MOVE.id, saved.getIoType());
        assertEquals(WrkStsType.NEW_CRN_MOVE.sts, saved.getWrkSts());
        assertEquals("2-1-1", saved.getLocNo());
        assertEquals(1, saved.getCrnNo());

        verify(wrkMastService, never()).updateById(any(WrkMast.class));
        verify(wrkAnalysisService, never()).markCraneStart(any(WrkMast.class), any());
        assertNull(MessageQueue.peek(SlaveType.Crn, 1));
    }

    @Test
    void dispatchCrnMove_returnsFalseWhenOtherTaskRunning() {
        CrnOperateProcessUtils utils = new CrnOperateProcessUtils();
        WrkMastService wrkMastService = mock(WrkMastService.class);
        CommonService commonService = mock(CommonService.class);
        WrkAnalysisService wrkAnalysisService = mock(WrkAnalysisService.class);

        ReflectionTestUtils.setField(utils, "wrkMastService", wrkMastService);
        ReflectionTestUtils.setField(utils, "commonService", commonService);
        ReflectionTestUtils.setField(utils, "wrkAnalysisService", wrkAnalysisService);

        when(wrkMastService.count(any())).thenReturn(1L);
        when(wrkMastService.getOne(any())).thenReturn(null);
        when(wrkMastService.save(any(WrkMast.class))).thenReturn(true);
        when(commonService.getWorkNo(WrkIoType.CRN_MOVE.id)).thenReturn(30001);

        boolean dispatched = utils.dispatchCrnMove(1, "2-1-1");

        assertFalse(dispatched);
        verify(wrkMastService, never()).save(any(WrkMast.class));
        verify(commonService, never()).getWorkNo(anyInt());
        verify(wrkAnalysisService, never()).initForTask(any(WrkMast.class));
    }

    @Test
    void crnIoExecuteNormal_prioritizesCrnMoveTask() {
        CrnOperateProcessUtils utils = new CrnOperateProcessUtils();
        BasCrnpService basCrnpService = mock(BasCrnpService.class);
        WrkMastService wrkMastService = mock(WrkMastService.class);
        RedisUtil redisUtil = mock(RedisUtil.class);
        LocMastService locMastService = mock(LocMastService.class);
        NotifyUtils notifyUtils = mock(NotifyUtils.class);
        WrkAnalysisService wrkAnalysisService = mock(WrkAnalysisService.class);
        CrnThread crnThread = mock(CrnThread.class);

        ReflectionTestUtils.setField(utils, "basCrnpService", basCrnpService);
        ReflectionTestUtils.setField(utils, "wrkMastService", wrkMastService);
        ReflectionTestUtils.setField(utils, "redisUtil", redisUtil);
        ReflectionTestUtils.setField(utils, "locMastService", locMastService);
        ReflectionTestUtils.setField(utils, "notifyUtils", notifyUtils);
        ReflectionTestUtils.setField(utils, "wrkAnalysisService", wrkAnalysisService);

        when(basCrnpService.list(anyWrapper())).thenReturn(List.of(buildBasCrnp(1, "[[2,3]]", "[2]")));
        when(redisUtil.get(anyString())).thenReturn(null);
        when(wrkMastService.count(any())).thenReturn(0L);
        when(wrkMastService.updateById(any(WrkMast.class))).thenReturn(true);

        WrkMast crnMoveTask = new WrkMast();
        crnMoveTask.setWrkNo(30001);
        crnMoveTask.setCrnNo(1);
        crnMoveTask.setIoType(WrkIoType.CRN_MOVE.id);
        crnMoveTask.setWrkSts(WrkStsType.NEW_CRN_MOVE.sts);
        crnMoveTask.setLocNo("2-1-1");
        crnMoveTask.setIoPri(999D);

        WrkMast locMoveTask = new WrkMast();
        locMoveTask.setWrkNo(20001);
        locMoveTask.setCrnNo(1);
        locMoveTask.setIoType(WrkIoType.LOC_MOVE.id);
        locMoveTask.setWrkSts(WrkStsType.NEW_LOC_MOVE.sts);
        locMoveTask.setSourceLocNo("3-1-1");
        locMoveTask.setLocNo("4-1-1");
        locMoveTask.setIoPri(1D);

        when(wrkMastService.list(anyWrapper()))
                .thenReturn(new ArrayList<>(List.of(crnMoveTask)))
                .thenReturn(new ArrayList<>(List.of(locMoveTask, crnMoveTask)));

        LocMast sourceLoc = new LocMast();
        sourceLoc.setLocNo("3-1-1");
        sourceLoc.setLocSts("R");
        LocMast targetLoc = new LocMast();
        targetLoc.setLocNo("4-1-1");
        targetLoc.setLocSts("S");
        when(locMastService.getById("3-1-1")).thenReturn(sourceLoc);
        when(locMastService.getById("4-1-1")).thenReturn(targetLoc);

        CrnProtocol protocol = buildProtocol(1, CrnStatusType.IDLE.id, 0);
        protocol.setBay(1);
        protocol.setLevel(1);
        when(crnThread.getStatus()).thenReturn(protocol);

        CrnCommand moveCommand = new CrnCommand();
        moveCommand.setCrnNo(1);
        moveCommand.setTaskNo(30001);
        when(crnThread.getMoveCommand("2-1-1", 30001, 1)).thenReturn(moveCommand);

        CrnCommand locMoveCommand = new CrnCommand();
        locMoveCommand.setCrnNo(1);
        locMoveCommand.setTaskNo(20001);
        when(crnThread.getPickAndPutCommand("3-1-1", "4-1-1", 20001, 1)).thenReturn(locMoveCommand);

        MessageQueue.init(SlaveType.Crn, 1);
        SlaveConnection.put(SlaveType.Crn, 1, crnThread);

        utils.crnIoExecuteNormal();

        ArgumentCaptor<WrkMast> updateCaptor = ArgumentCaptor.forClass(WrkMast.class);
        verify(wrkMastService).updateById(updateCaptor.capture());
        assertEquals(30001, updateCaptor.getValue().getWrkNo());
        assertEquals(WrkStsType.CRN_MOVE_RUN.sts, updateCaptor.getValue().getWrkSts());
        verify(wrkAnalysisService).markCraneStart(any(WrkMast.class), any());

        Task task = MessageQueue.peek(SlaveType.Crn, 1);
        assertNotNull(task);
        assertSame(moveCommand, task.getData());
    }

    @Test
    void crnIoExecuteNormal_allowsOtherCraneToRunWhenOneCraneHasMoveTask() {
        CrnOperateProcessUtils utils = new CrnOperateProcessUtils();
        BasCrnpService basCrnpService = mock(BasCrnpService.class);
        WrkMastService wrkMastService = mock(WrkMastService.class);
        RedisUtil redisUtil = mock(RedisUtil.class);
        LocMastService locMastService = mock(LocMastService.class);
        NotifyUtils notifyUtils = mock(NotifyUtils.class);
        WrkAnalysisService wrkAnalysisService = mock(WrkAnalysisService.class);
        CrnThread crnThread1 = mock(CrnThread.class);
        CrnThread crnThread2 = mock(CrnThread.class);

        ReflectionTestUtils.setField(utils, "basCrnpService", basCrnpService);
        ReflectionTestUtils.setField(utils, "wrkMastService", wrkMastService);
        ReflectionTestUtils.setField(utils, "redisUtil", redisUtil);
        ReflectionTestUtils.setField(utils, "locMastService", locMastService);
        ReflectionTestUtils.setField(utils, "notifyUtils", notifyUtils);
        ReflectionTestUtils.setField(utils, "wrkAnalysisService", wrkAnalysisService);

        when(basCrnpService.list(anyWrapper())).thenReturn(List.of(
                buildBasCrnp(1, "[[2,3]]", "[2]"),
                buildBasCrnp(2, "[[4,5]]", "[4]")
        ));
        when(redisUtil.get(anyString())).thenReturn(null);
        when(wrkMastService.count(any())).thenReturn(0L);
        when(wrkMastService.updateById(any(WrkMast.class))).thenReturn(true);

        WrkMast crnMoveTask = new WrkMast();
        crnMoveTask.setWrkNo(30001);
        crnMoveTask.setCrnNo(1);
        crnMoveTask.setIoType(WrkIoType.CRN_MOVE.id);
        crnMoveTask.setWrkSts(WrkStsType.NEW_CRN_MOVE.sts);
        crnMoveTask.setLocNo("2-1-1");

        WrkMast locMoveTask = new WrkMast();
        locMoveTask.setWrkNo(20002);
        locMoveTask.setCrnNo(2);
        locMoveTask.setIoType(WrkIoType.LOC_MOVE.id);
        locMoveTask.setWrkSts(WrkStsType.NEW_LOC_MOVE.sts);
        locMoveTask.setSourceLocNo("4-1-1");
        locMoveTask.setLocNo("5-1-1");
        locMoveTask.setIoPri(1D);

        when(wrkMastService.list(anyWrapper()))
                .thenReturn(new ArrayList<>(List.of(crnMoveTask)))
                .thenReturn(new ArrayList<>(List.of(crnMoveTask)))
                .thenReturn(new ArrayList<>(List.of(locMoveTask)));

        LocMast sourceLoc = new LocMast();
        sourceLoc.setLocNo("4-1-1");
        sourceLoc.setLocSts("R");
        LocMast targetLoc = new LocMast();
        targetLoc.setLocNo("5-1-1");
        targetLoc.setLocSts("S");
        when(locMastService.getById("4-1-1")).thenReturn(sourceLoc);
        when(locMastService.getById("5-1-1")).thenReturn(targetLoc);

        CrnProtocol protocol1 = buildProtocol(1, CrnStatusType.IDLE.id, 0);
        when(crnThread1.getStatus()).thenReturn(protocol1);
        CrnProtocol protocol2 = buildProtocol(2, CrnStatusType.IDLE.id, 0);
        when(crnThread2.getStatus()).thenReturn(protocol2);

        CrnCommand moveCommand = new CrnCommand();
        moveCommand.setCrnNo(1);
        moveCommand.setTaskNo(30001);
        when(crnThread1.getMoveCommand("2-1-1", 30001, 1)).thenReturn(moveCommand);

        CrnCommand locMoveCommand = new CrnCommand();
        locMoveCommand.setCrnNo(2);
        locMoveCommand.setTaskNo(20002);
        when(crnThread2.getPickAndPutCommand("4-1-1", "5-1-1", 20002, 2)).thenReturn(locMoveCommand);

        MessageQueue.init(SlaveType.Crn, 1);
        MessageQueue.init(SlaveType.Crn, 2);
        SlaveConnection.put(SlaveType.Crn, 1, crnThread1);
        SlaveConnection.put(SlaveType.Crn, 2, crnThread2);

        utils.crnIoExecuteNormal();

        ArgumentCaptor<WrkMast> updateCaptor = ArgumentCaptor.forClass(WrkMast.class);
        verify(wrkMastService, times(2)).updateById(updateCaptor.capture());
        List<WrkMast> updatedList = updateCaptor.getAllValues();
        assertEquals(30001, updatedList.get(0).getWrkNo());
        assertEquals(WrkStsType.CRN_MOVE_RUN.sts, updatedList.get(0).getWrkSts());
        assertEquals(20002, updatedList.get(1).getWrkNo());
        assertEquals(WrkStsType.LOC_MOVE_RUN.sts, updatedList.get(1).getWrkSts());

        Task task1 = MessageQueue.peek(SlaveType.Crn, 1);
        assertNotNull(task1);
        assertSame(moveCommand, task1.getData());

        Task task2 = MessageQueue.peek(SlaveType.Crn, 2);
        assertNotNull(task2);
        assertSame(locMoveCommand, task2.getData());
    }

    @Test
    void crnIoExecuteFinish_marksCrnMoveTaskComplete() {
        CrnOperateProcessUtils utils = new CrnOperateProcessUtils();
        BasCrnpService basCrnpService = mock(BasCrnpService.class);
        WrkMastService wrkMastService = mock(WrkMastService.class);
        RedisUtil redisUtil = mock(RedisUtil.class);
        WrkAnalysisService wrkAnalysisService = mock(WrkAnalysisService.class);
        CrnThread crnThread = mock(CrnThread.class);

        ReflectionTestUtils.setField(utils, "basCrnpService", basCrnpService);
        ReflectionTestUtils.setField(utils, "wrkMastService", wrkMastService);
        ReflectionTestUtils.setField(utils, "redisUtil", redisUtil);
        ReflectionTestUtils.setField(utils, "wrkAnalysisService", wrkAnalysisService);

        when(basCrnpService.list(anyWrapper())).thenReturn(List.of(buildBasCrnp(1, "[[2,3]]", "[2]")));
        when(redisUtil.get(anyString())).thenReturn(null);
        when(wrkMastService.updateById(any(WrkMast.class))).thenReturn(true);

        CrnProtocol protocol = buildProtocol(1, CrnStatusType.WAITING.id, 30001);
        when(crnThread.getStatus()).thenReturn(protocol);

        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(30001);
        wrkMast.setIoType(WrkIoType.CRN_MOVE.id);
        wrkMast.setWrkSts(WrkStsType.CRN_MOVE_RUN.sts);
        wrkMast.setCrnNo(1);
        when(wrkMastService.selectByWorkNo(30001)).thenReturn(wrkMast);

        CrnCommand resetCommand = new CrnCommand();
        resetCommand.setCrnNo(1);
        resetCommand.setTaskNo(30001);
        when(crnThread.getResetCommand(30001, 1)).thenReturn(resetCommand);

        MessageQueue.init(SlaveType.Crn, 1);
        SlaveConnection.put(SlaveType.Crn, 1, crnThread);

        utils.crnIoExecuteFinish();

        ArgumentCaptor<WrkMast> updateCaptor = ArgumentCaptor.forClass(WrkMast.class);
        verify(wrkMastService, times(1)).updateById(updateCaptor.capture());
        assertEquals(WrkStsType.COMPLETE_CRN_MOVE.sts, updateCaptor.getValue().getWrkSts());
        verify(wrkAnalysisService).markCraneComplete(any(WrkMast.class), any(), eq(WrkStsType.COMPLETE_CRN_MOVE.sts));

        Task task = MessageQueue.peek(SlaveType.Crn, 1);
        assertNotNull(task);
        assertSame(resetCommand, task.getData());
    }

    private BasCrnp buildBasCrnp(int crnNo, String controlRows, String deepRows) {
        BasCrnp basCrnp = new BasCrnp();
        basCrnp.setCrnNo(crnNo);
        basCrnp.setControlRows(controlRows);
        basCrnp.setDeepRows(deepRows);
        return basCrnp;
    }

    private CrnProtocol buildProtocol(int crnNo, int status, int taskNo) {
        CrnProtocol protocol = new CrnProtocol();
        protocol.setCrnNo(crnNo);
        protocol.setMode(CrnModeType.AUTO.id);
        protocol.setTaskNo(taskNo);
        protocol.setStatus(status);
        protocol.setLoaded(0);
        protocol.setForkPos(0);
        protocol.setAlarm(0);
        return protocol;
    }

    private void safeClearQueue(int crnNo) {
        try {
            MessageQueue.clear(SlaveType.Crn, crnNo);
        } catch (Exception ignore) {
        }
    }

    @SuppressWarnings("unchecked")
    private <T> Wrapper<T> anyWrapper() {
        return any(Wrapper.class);
    }
}