package com.ruoyi.account.service;

import com.ruoyi.chargingPile.api.dto.GetSiteListDTO;
import com.ruoyi.chargingPile.api.feignClient.SiteClient;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.exception.ServiceException;
import com.ruoyi.common.security.service.TokenService;
import com.ruoyi.order.api.feignClient.ChargingOrderClient;
import com.ruoyi.system.api.domain.SysUser;
import com.ruoyi.system.api.feignClient.SysUserClient;
import com.ruoyi.system.api.model.LoginUser;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.test.util.ReflectionTestUtils;

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.assertDoesNotThrow;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class)
class PartnerAppUserAccessServiceTest {

    @Mock private TokenService tokenService;
    @Mock private SysUserClient sysUserClient;
    @Mock private SiteClient siteClient;
    @Mock private ChargingOrderClient chargingOrderClient;

    private PartnerAppUserAccessService service;

    @BeforeEach
    void setUp() {
        service = new PartnerAppUserAccessService();
        ReflectionTestUtils.setField(service, "tokenService", tokenService);
        ReflectionTestUtils.setField(service, "sysUserClient", sysUserClient);
        ReflectionTestUtils.setField(service, "siteClient", siteClient);
        ReflectionTestUtils.setField(service, "chargingOrderClient", chargingOrderClient);
    }

    @Test
    void partnerCanSeeOnlyUsersWhoChargedAtAuthorizedSites() {
        mockCurrentUser(2, 9);
        when(siteClient.getSiteListByUserId(1L))
                .thenReturn(R.ok(Arrays.asList(site(11), site(12))));
        when(chargingOrderClient.getAppUserIdsBySiteIds(Arrays.asList(11, 12)))
                .thenReturn(R.ok(Arrays.asList(101L, 102L, 101L)));

        List<Long> result = service.getVisibleUserIdsForCurrentPartner();

        assertEquals(Arrays.asList(101L, 102L), result);
        verify(chargingOrderClient).getAppUserIdsBySiteIds(Arrays.asList(11, 12));
    }

    @Test
    void partnerWithoutAuthorizedSitesGetsImpossibleUserId() {
        mockCurrentUser(2, 9);
        when(siteClient.getSiteListByUserId(1L))
                .thenReturn(R.ok(Collections.singletonList(site(-1))));

        assertEquals(Collections.singletonList(-1L), service.getVisibleUserIdsForCurrentPartner());
        verifyNoInteractions(chargingOrderClient);
    }

    @Test
    void orderServiceFailureDoesNotExposeAllUsers() {
        mockCurrentUser(2, 9);
        when(siteClient.getSiteListByUserId(1L))
                .thenReturn(R.ok(Collections.singletonList(site(11))));
        when(chargingOrderClient.getAppUserIdsBySiteIds(Collections.singletonList(11)))
                .thenReturn(R.fail("order unavailable"));

        assertEquals(Collections.singletonList(-1L), service.getVisibleUserIdsForCurrentPartner());
    }

    @Test
    void platformUserKeepsUnrestrictedScope() {
        mockCurrentUser(1, null);

        assertNull(service.getVisibleUserIdsForCurrentPartner());
        verifyNoInteractions(siteClient, chargingOrderClient);
    }

    @Test
    void partnerCannotReadUserOutsideVisibleScope() {
        mockCurrentUser(2, 9);
        when(siteClient.getSiteListByUserId(1L))
                .thenReturn(R.ok(Collections.singletonList(site(11))));
        when(chargingOrderClient.getAppUserIdsBySiteIds(Collections.singletonList(11)))
                .thenReturn(R.ok(Collections.singletonList(101L)));

        assertThrows(ServiceException.class, () -> service.assertUserVisible(999L));
    }

    @Test
    void partnerCanOperateUsersInsideVisibleScope() {
        mockCurrentUser(2, 9);
        when(siteClient.getSiteListByUserId(1L))
                .thenReturn(R.ok(Collections.singletonList(site(11))));
        when(chargingOrderClient.getAppUserIdsBySiteIds(Collections.singletonList(11)))
                .thenReturn(R.ok(Arrays.asList(101L, 102L)));

        assertDoesNotThrow(() -> service.assertUsersVisible(Arrays.asList(101L, 102L)));
    }

    @Test
    void partnerCannotOperateBulkUsersWhenOneIsOutsideVisibleScope() {
        mockCurrentUser(2, 9);
        when(siteClient.getSiteListByUserId(1L))
                .thenReturn(R.ok(Collections.singletonList(site(11))));
        when(chargingOrderClient.getAppUserIdsBySiteIds(Collections.singletonList(11)))
                .thenReturn(R.ok(Collections.singletonList(101L)));

        ServiceException exception = assertThrows(ServiceException.class,
                () -> service.assertUsersVisible(Arrays.asList(101L, 999L)));

        assertEquals("无权操作所选用户", exception.getMessage());
    }

    private void mockCurrentUser(Integer roleType, Integer objectId) {
        SysUser sysUser = new SysUser();
        sysUser.setUserId(1L);
        sysUser.setRoleType(roleType);
        sysUser.setObjectId(objectId);
        LoginUser loginUser = new LoginUser();
        loginUser.setUserid(1L);
        loginUser.setSysUser(sysUser);
        when(tokenService.getLoginUser()).thenReturn(loginUser);
    }

    private GetSiteListDTO site(Integer id) {
        GetSiteListDTO site = new GetSiteListDTO();
        site.setId(id);
        return site;
    }
}