package com.yunhai.userbase.service.impl;

import com.yunhai.userbase.entity.SysUserGroupRel;
import com.yunhai.userbase.entity.SysUserRoleRel;
import com.yunhai.userbase.enums.StatusEnum;
import com.yunhai.userbase.repository.SysGroupRepository;
import com.yunhai.userbase.repository.SysUserCurrentRoleRepository;
import com.yunhai.userbase.repository.SysUserGroupRelRepository;
import com.yunhai.userbase.repository.SysUserRoleRelRepository;
import com.yunhai.userbase.service.ISysGroupService;
import com.yunhai.userbase.service.resolve.MainGroupResolver;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;

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.Mockito.when;

/**
 * IdentityService 主身份动态解析（resolveMainIdentity / resolveMainIdentityByUser）单元测试。
 * 规则：主组 → 主校 → 该校正常态身份行中 sortNo 最小、并列取 id 最小。
 */
class IdentityServiceTest {

    @InjectMocks
    private IdentityService identityService;

    @Mock
    private SysUserRoleRelRepository sysUserRoleRelRepository;
    @Mock
    private SysUserCurrentRoleRepository sysUserCurrentRoleRepository;
    @Mock
    private SysGroupRepository sysGroupRepository;
    @Mock
    private SysUserGroupRelRepository sysUserGroupRelRepository;
    @Mock
    private MainGroupResolver mainGroupResolver;
    @Mock
    private ISysGroupService sysGroupService;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
    }

    private SysUserGroupRel groupRel(Integer groupId, Integer isMain) {
        SysUserGroupRel r = new SysUserGroupRel();
        r.setUserId(1);
        r.setGroupId(groupId);
        r.setIsMain(isMain);
        return r;
    }

    private SysUserRoleRel roleRel(Integer id, Integer userId, Integer schoolId, Integer sortNo) {
        SysUserRoleRel r = new SysUserRoleRel();
        r.setId(id);
        r.setUserId(userId);
        r.setSchoolId(schoolId);
        r.setSortNo(sortNo);
        r.setStatus(StatusEnum.NORMAL);
        return r;
    }

    // ===================== 单用户 resolveMainIdentity =====================

    /** 无组关系 → null */
    @Test
    void resolveMainIdentity_noGroup_returnsNull() {
        when(mainGroupResolver.resolve(1)).thenReturn(Optional.empty());
        assertNull(identityService.resolveMainIdentity(1));
    }

    /** 主校无身份行（身份行全在其它学校）→ null */
    @Test
    void resolveMainIdentity_mainSchoolHasNoRows_returnsNull() {
        when(mainGroupResolver.resolve(1)).thenReturn(Optional.of(groupRel(16, 1)));
        when(sysGroupService.resolveSchoolId(16)).thenReturn(16);
        when(sysUserRoleRelRepository.findByUserIdAndStatus(1, StatusEnum.NORMAL))
                .thenReturn(Collections.singletonList(roleRel(10, 1, 20, 0)));
        assertNull(identityService.resolveMainIdentity(1));
    }

    /** 主校多行：sortNo 最小、并列取 id 最小 */
    @Test
    void resolveMainIdentity_picksMinSortNoThenMinId() {
        when(mainGroupResolver.resolve(1)).thenReturn(Optional.of(groupRel(16, 1)));
        when(sysGroupService.resolveSchoolId(16)).thenReturn(16);
        List<SysUserRoleRel> rels = Arrays.asList(
                roleRel(30, 1, 16, 2),
                roleRel(31, 1, 16, 1),
                roleRel(25, 1, 16, 1),   // 与 31 同 sortNo → 取 id 小者
                roleRel(10, 1, 20, 0));  // 其它学校，不参与
        when(sysUserRoleRelRepository.findByUserIdAndStatus(1, StatusEnum.NORMAL)).thenReturn(rels);
        SysUserRoleRel main = identityService.resolveMainIdentity(1);
        assertEquals(Integer.valueOf(25), main.getId());
    }

    // ===================== 批量 resolveMainIdentityByUser =====================

    /** 批量：3 次查询路径，无主组/主校无行的用户跳过 */
    @Test
    void resolveMainIdentityByUser_skipsUsersWithoutMain() {
        Map<Integer, SysUserGroupRel> mainGroupMap = new HashMap<>();
        mainGroupMap.put(1, groupRel(16, 1));   // 用户 1：主组 16
        mainGroupMap.put(2, groupRel(20, 1));   // 用户 2：主组 20
        when(mainGroupResolver.resolveByUserIds(Arrays.asList(1, 2, 3))).thenReturn(mainGroupMap);
        Map<Integer, Integer> schoolByGroup = new HashMap<>();
        schoolByGroup.put(16, 16);
        schoolByGroup.put(20, 20);
        when(sysGroupService.resolveSchoolIds(Arrays.asList(16, 20))).thenReturn(schoolByGroup);
        when(sysUserRoleRelRepository.findByUserIdInAndStatus(Arrays.asList(1, 2, 3), StatusEnum.NORMAL))
                .thenReturn(Arrays.asList(
                        roleRel(30, 1, 16, 1),
                        roleRel(31, 1, 16, 2),
                        roleRel(40, 2, 99, 0))); // 用户 2 主校 20 无行 → 跳过
        Map<Integer, SysUserRoleRel> result = identityService.resolveMainIdentityByUser(Arrays.asList(1, 2, 3));
        assertEquals(1, result.size());
        assertEquals(Integer.valueOf(30), result.get(1).getId());
    }

    /** 批量：空入参 → 空映射 */
    @Test
    void resolveMainIdentityByUser_emptyInput_returnsEmptyMap() {
        assertTrue(identityService.resolveMainIdentityByUser(Collections.emptyList()).isEmpty());
    }
}