package com.zy.asrs.task;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.zy.asrs.entity.BasStation;
import com.zy.asrs.entity.WrkMast;
import com.zy.asrs.service.BasStationService;
import com.zy.asrs.service.WrkAnalysisService;
import com.zy.asrs.service.WrkMastService;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.SlaveType;
import com.zy.core.enums.StationCommandType;
import com.zy.core.enums.WrkStsType;
import com.zy.core.model.CommandResponse;
import com.zy.core.model.command.StationCommand;
import com.zy.core.model.protocol.StationProtocol;
import com.zy.core.thread.StationThread;
import com.zy.core.utils.StationOperateProcessUtils;
import org.junit.jupiter.api.Test;

import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

class WrkAnalysisStationArrivalScannerTest {

    @Test
    void scanInboundStationArrival_completesTaskWhenRecentArrivalWasObserved() {
        WrkMastService wrkMastService = mock(WrkMastService.class);
        BasStationService basStationService = mock(BasStationService.class);
        WrkAnalysisService wrkAnalysisService = mock(WrkAnalysisService.class);
        StationOperateProcessUtils stationOperateProcessUtils = mock(StationOperateProcessUtils.class);

        WrkAnalysisStationArrivalScanner scanner = new WrkAnalysisStationArrivalScanner(
                wrkMastService,
                basStationService,
                wrkAnalysisService,
                stationOperateProcessUtils
        );

        WrkMast wrkMast = inboundWrkMast(1001, 12);
        BasStation basStation = station(12, 3);

        when(wrkMastService.list(any(QueryWrapper.class))).thenReturn(List.of(wrkMast));
        when(basStationService.getOne(any())).thenReturn(basStation);
        when(wrkAnalysisService.completeInboundStationRun(any(WrkMast.class), any(Date.class))).thenReturn(true);

        ArrivalAwareStationThread stationThread = new ArrivalAwareStationThread(true);
        StationProtocol stationProtocol = new StationProtocol();
        stationProtocol.setStationId(12);
        stationProtocol.setTaskNo(0);
        stationProtocol.setLoading(false);
        stationThread.putStatus(stationProtocol);

        SlaveConnection.put(SlaveType.Devp, 3, stationThread);
        try {
            scanner.scanInboundStationArrival();
        } finally {
            SlaveConnection.remove(SlaveType.Devp, 3);
        }

        verify(wrkAnalysisService).completeInboundStationRun(any(WrkMast.class), any(Date.class));
    }

    @Test
    void scanInboundStationArrival_completesTaskWhenProtocolMatchesCurrentTask() {
        WrkMastService wrkMastService = mock(WrkMastService.class);
        BasStationService basStationService = mock(BasStationService.class);
        WrkAnalysisService wrkAnalysisService = mock(WrkAnalysisService.class);
        StationOperateProcessUtils stationOperateProcessUtils = mock(StationOperateProcessUtils.class);

        WrkAnalysisStationArrivalScanner scanner = new WrkAnalysisStationArrivalScanner(
                wrkMastService,
                basStationService,
                wrkAnalysisService,
                stationOperateProcessUtils
        );

        WrkMast wrkMast = inboundWrkMast(1002, 15);
        BasStation basStation = station(15, 5);

        when(wrkMastService.list(any(QueryWrapper.class))).thenReturn(List.of(wrkMast));
        when(basStationService.getOne(any())).thenReturn(basStation);
        when(wrkAnalysisService.completeInboundStationRun(any(WrkMast.class), any(Date.class))).thenReturn(true);

        ArrivalAwareStationThread stationThread = new ArrivalAwareStationThread(false);
        StationProtocol stationProtocol = new StationProtocol();
        stationProtocol.setStationId(15);
        stationProtocol.setTaskNo(1002);
        stationProtocol.setLoading(true);
        stationThread.putStatus(stationProtocol);

        SlaveConnection.put(SlaveType.Devp, 5, stationThread);
        try {
            scanner.scanInboundStationArrival();
        } finally {
            SlaveConnection.remove(SlaveType.Devp, 5);
        }

        verify(wrkAnalysisService).completeInboundStationRun(any(WrkMast.class), any(Date.class));
    }

    @Test
    void scanInboundStationArrival_skipsWhenArrivalWasNotObserved() {
        WrkMastService wrkMastService = mock(WrkMastService.class);
        BasStationService basStationService = mock(BasStationService.class);
        WrkAnalysisService wrkAnalysisService = mock(WrkAnalysisService.class);
        StationOperateProcessUtils stationOperateProcessUtils = mock(StationOperateProcessUtils.class);

        WrkAnalysisStationArrivalScanner scanner = new WrkAnalysisStationArrivalScanner(
                wrkMastService,
                basStationService,
                wrkAnalysisService,
                stationOperateProcessUtils
        );

        WrkMast wrkMast = inboundWrkMast(1003, 18);
        BasStation basStation = station(18, 8);

        when(wrkMastService.list(any(QueryWrapper.class))).thenReturn(List.of(wrkMast));
        when(basStationService.getOne(any())).thenReturn(basStation);

        ArrivalAwareStationThread stationThread = new ArrivalAwareStationThread(false);
        StationProtocol stationProtocol = new StationProtocol();
        stationProtocol.setStationId(18);
        stationProtocol.setTaskNo(9999);
        stationProtocol.setLoading(true);
        stationThread.putStatus(stationProtocol);

        SlaveConnection.put(SlaveType.Devp, 8, stationThread);
        try {
            scanner.scanInboundStationArrival();
        } finally {
            SlaveConnection.remove(SlaveType.Devp, 8);
        }

        verify(wrkAnalysisService, never()).completeInboundStationRun(any(WrkMast.class), any(Date.class));
    }

    @Test
    void scanOutboundStationFlow_triggersStationOperateProcessSteps() {
        WrkMastService wrkMastService = mock(WrkMastService.class);
        BasStationService basStationService = mock(BasStationService.class);
        WrkAnalysisService wrkAnalysisService = mock(WrkAnalysisService.class);
        StationOperateProcessUtils stationOperateProcessUtils = mock(StationOperateProcessUtils.class);

        WrkAnalysisStationArrivalScanner scanner = new WrkAnalysisStationArrivalScanner(
                wrkMastService,
                basStationService,
                wrkAnalysisService,
                stationOperateProcessUtils
        );

        scanner.scanOutboundStationFlow();

        verify(stationOperateProcessUtils).stationOutExecuteFinish();
        verify(stationOperateProcessUtils).checkTaskToComplete();
    }

    private WrkMast inboundWrkMast(int wrkNo, int stationId) {
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(wrkNo);
        wrkMast.setIoType(1);
        wrkMast.setWrkSts(WrkStsType.INBOUND_STATION_RUN.sts);
        wrkMast.setStaNo(stationId);
        return wrkMast;
    }

    private BasStation station(int stationId, int deviceNo) {
        BasStation basStation = new BasStation();
        basStation.setStationId(stationId);
        basStation.setDeviceNo(deviceNo);
        return basStation;
    }

    private static class ArrivalAwareStationThread implements StationThread {

        private final boolean recentArrival;
        private final Map<Integer, StationProtocol> statusMap = new HashMap<>();

        private ArrivalAwareStationThread(boolean recentArrival) {
            this.recentArrival = recentArrival;
        }

        private void putStatus(StationProtocol stationProtocol) {
            statusMap.put(stationProtocol.getStationId(), stationProtocol);
        }

        @Override
        public List<StationProtocol> getStatus() {
            return Collections.emptyList();
        }

        @Override
        public Map<Integer, StationProtocol> getStatusMap() {
            return statusMap;
        }

        public boolean hasRecentArrival(Integer stationId, Integer taskNo) {
            return recentArrival;
        }

        @Override
        public StationCommand getCommand(StationCommandType commandType, Integer taskNo, Integer stationId, Integer targetStationId, Integer palletSize) {
            return null;
        }

        @Override
        public boolean clearPath(Integer taskNo) {
            return false;
        }

        @Override
        public CommandResponse sendCommand(StationCommand command) {
            return null;
        }

        @Override
        public CommandResponse sendOriginCommand(String address, short[] data) {
            return null;
        }

        @Override
        public byte[] readOriginCommand(String address, int length) {
            return new byte[0];
        }

        @Override
        public void run() {
        }

        @Override
        public boolean connect() {
            return true;
        }

        @Override
        public void close() {
        }
    }
}