package com.mangoo.rating.recommend.cart;

import com.mangoo.rating.recommend.AjaxResult;
import com.mangoo.rating.recommend.manager.ActiveBatchManager;
import com.mangoo.rating.recommend.manager.CardPopManager;
import com.mangoo.rating.recommend.manager.CardValueHistoryManager;
import com.mangoo.rating.recommend.manager.RatingRecommendRuleManager;
import com.mangoo.rating.recommend.po.RatingRecommendRulePO;
import com.mangoo.rating.recommend.request.recommend.RuleSyncCardDTO;
import com.mangoo.rating.recommend.request.recommend.RuleSyncRequest;
import com.mangoo.rating.recommend.service.impl.RuleSyncServiceImpl;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

/**
 * RuleSyncServiceImpl Mockito 单测
 *
 * @author gengjintao
 * @date 2026/06/25
 */
@ExtendWith(MockitoExtension.class)
class RuleSyncServiceImplTest {

    @Mock
    private RatingRecommendRuleManager ruleManager;
    @Mock
    private CardPopManager cardPopManager;
    @Mock
    private CardValueHistoryManager cardValueHistoryManager;
    @Mock
    private ActiveBatchManager activeBatchManager;
    @InjectMocks
    private RuleSyncServiceImpl ruleSyncService;

    @Captor
    private ArgumentCaptor<List<RatingRecommendRulePO>> ruleListCaptor;

    @BeforeEach
    void setUp() {
        // 默认无生效批次 + 清旧批次查询返回空，避免 NPE
        lenient().when(activeBatchManager.selectActiveBatchNo()).thenReturn(null);
        lenient().when(ruleManager.selectDistinctBatchNos()).thenReturn(Collections.emptyList());
    }

    private RuleSyncCardDTO card(String cardId) {
        RuleSyncCardDTO c = new RuleSyncCardDTO();
        c.setCardId(cardId);
        c.setPlayer("p");
        c.setYear("2026");
        c.setSeries("s");
        c.setCardSet("BASE");
        // 评级时效字段已重构：旧 recommendEfficiency(int) -> 新 evaluateEfficiencyId(Long)
        c.setEvaluateEfficiencyId(2L);
        return c;
    }

    private RuleSyncRequest req(String batchNo, RuleSyncCardDTO... cards) {
        RuleSyncRequest r = new RuleSyncRequest();
        r.setBatchNo(batchNo);
        r.setCards(new ArrayList<>(Arrays.asList(cards)));
        return r;
    }

    private int code(AjaxResult r) {
        return ((Number) r.get("code")).intValue();
    }

    @Test
    void 正常_全量替换并切批次() {
        AjaxResult result = ruleSyncService.sync(req("2026062501", card("CARD-1")));
        assertEquals(0, code(result)); // 成功码 0
        // 切指针到新批次
        verify(activeBatchManager).updateActiveBatchNo("2026062501");
        // 规则批量插入被调用
        verify(ruleManager).batchInsert(ruleListCaptor.capture());
        assertEquals(1, ruleListCaptor.getValue().size());
    }

    @Test
    void 空batchNo_拒绝且不写库() {
        AjaxResult result = ruleSyncService.sync(req("", card("CARD-1")));
        assertNotEquals(0, code(result));
        verify(ruleManager, never()).batchInsert(org.mockito.ArgumentMatchers.anyList());
        verify(activeBatchManager, never()).updateActiveBatchNo(org.mockito.ArgumentMatchers.anyString());
    }

    @Test
    void 空cards_拒绝() {
        RuleSyncRequest r = new RuleSyncRequest();
        r.setBatchNo("2026062501");
        r.setCards(new ArrayList<>());
        AjaxResult result = ruleSyncService.sync(r);
        assertNotEquals(0, code(result));
        verify(ruleManager, never()).batchInsert(org.mockito.ArgumentMatchers.anyList());
    }

    @Test
    void 旧批次_拒绝回灌() {
        when(activeBatchManager.selectActiveBatchNo()).thenReturn("2026062502");
        AjaxResult result = ruleSyncService.sync(req("2026062501", card("CARD-1")));
        assertNotEquals(0, code(result)); // 新批次 <= 生效批次，拒绝
        verify(ruleManager, never()).batchInsert(org.mockito.ArgumentMatchers.anyList());
    }

    @Test
    void cardId去重_重复只插一条() {
        AjaxResult result = ruleSyncService.sync(req("2026062501", card("DUP"), card("DUP")));
        assertEquals(0, code(result));
        verify(ruleManager).batchInsert(ruleListCaptor.capture());
        assertEquals(1, ruleListCaptor.getValue().size()); // 同 cardId 去重为 1
    }
}