package com.zy.ai.service.impl;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.zy.asrs.entity.BasStation;
import com.zy.asrs.entity.StationFlowCapacity;
import com.zy.asrs.entity.WrkMast;
import com.zy.asrs.service.BasStationService;
import com.zy.asrs.service.StationFlowCapacityService;
import com.zy.asrs.service.WrkMastService;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.springframework.test.util.ReflectionTestUtils;

import java.util.Arrays;
import java.util.Collections;
import java.util.Map;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
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 AutoTuneSnapshotServiceImplTest {

    private AutoTuneSnapshotServiceImpl service;

    @BeforeEach
    void setUp() {
        service = new AutoTuneSnapshotServiceImpl();
    }

    @Test
    void buildStationOutTaskLimitMapPreservesNullZeroAndNegativeLimits() {
        Map<String, Integer> result = service.buildStationOutTaskLimitMap(Arrays.asList(
                station(101, null),
                station(102, 0),
                station(103, -1),
                station(104, 5)
        ));

        assertNull(result.get("101"));
        assertEquals(0, result.get("102"));
        assertEquals(-1, result.get("103"));
        assertEquals(5, result.get("104"));
    }

    @Test
    void loadActiveTasksIncludesNullWrkStatusInGroupedCondition() {
        WrkMastService wrkMastService = mock(WrkMastService.class);
        when(wrkMastService.list(any(Wrapper.class))).thenReturn(Collections.emptyList());
        ReflectionTestUtils.setField(service, "wrkMastService", wrkMastService);

        ReflectionTestUtils.invokeMethod(service, "loadActiveTasks");

        ArgumentCaptor<Wrapper<WrkMast>> wrapperCaptor = ArgumentCaptor.forClass(Wrapper.class);
        verify(wrkMastService).list(wrapperCaptor.capture());
        String sqlSegment = wrapperCaptor.getValue().getSqlSegment();
        String normalizedSqlSegment = sqlSegment.replaceAll("\\s+", " ");
        assertTrue(normalizedSqlSegment.contains("(wrk_sts NOT IN"));
        assertTrue(normalizedSqlSegment.contains("OR wrk_sts IS NULL"));
    }

    @Test
    void loadStationOutTaskLimitsOnlyQueriesConfiguredOutDirectionStations() {
        BasStationService basStationService = mock(BasStationService.class);
        StationFlowCapacityService stationFlowCapacityService = mock(StationFlowCapacityService.class);
        ReflectionTestUtils.setField(service, "basStationService", basStationService);
        ReflectionTestUtils.setField(service, "stationFlowCapacityService", stationFlowCapacityService);
        when(stationFlowCapacityService.list(any(Wrapper.class))).thenReturn(Arrays.asList(
                capacity(101, "OUT"),
                capacity(102, "OUT")
        ));
        when(basStationService.list(any(Wrapper.class))).thenReturn(Arrays.asList(
                station(101, 2),
                station(102, 3)
        ));

        Map<String, Integer> result = ReflectionTestUtils.invokeMethod(service, "loadStationOutTaskLimits");

        assertEquals(2, result.size());
        assertEquals(2, result.get("101"));
        assertEquals(3, result.get("102"));

        ArgumentCaptor<Wrapper<StationFlowCapacity>> capacityWrapperCaptor = ArgumentCaptor.forClass(Wrapper.class);
        verify(stationFlowCapacityService).list(capacityWrapperCaptor.capture());
        assertTrue(capacityWrapperCaptor.getValue().getSqlSegment().contains("direction_code ="));

        ArgumentCaptor<Wrapper<BasStation>> stationWrapperCaptor = ArgumentCaptor.forClass(Wrapper.class);
        verify(basStationService).list(stationWrapperCaptor.capture());
        assertTrue(stationWrapperCaptor.getValue().getSqlSegment().contains("station_id IN"));
    }

    @Test
    void loadStationOutTaskLimitsDoesNotQueryStationsWhenNoOutCapacityExists() {
        BasStationService basStationService = mock(BasStationService.class);
        StationFlowCapacityService stationFlowCapacityService = mock(StationFlowCapacityService.class);
        ReflectionTestUtils.setField(service, "basStationService", basStationService);
        ReflectionTestUtils.setField(service, "stationFlowCapacityService", stationFlowCapacityService);
        when(stationFlowCapacityService.list(any(Wrapper.class))).thenReturn(Collections.emptyList());

        Map<String, Integer> result = ReflectionTestUtils.invokeMethod(service, "loadStationOutTaskLimits");

        assertTrue(result.isEmpty());
        verify(basStationService, never()).list(any(Wrapper.class));
    }

    private BasStation station(Integer stationId, Integer outTaskLimit) {
        BasStation station = new BasStation();
        station.setStationId(stationId);
        station.setOutTaskLimit(outTaskLimit);
        return station;
    }

    private StationFlowCapacity capacity(Integer stationId, String directionCode) {
        StationFlowCapacity capacity = new StationFlowCapacity();
        capacity.setStationId(stationId);
        capacity.setDirectionCode(directionCode);
        return capacity;
    }
}