package com.ruoyi.system.service;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.ruoyi.chargingPile.api.feignClient.SiteClient;
import com.ruoyi.chargingPile.api.model.Partner;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.exception.ServiceException;
import com.ruoyi.system.api.domain.SysRole;
import com.ruoyi.system.api.domain.SysUser;
import com.ruoyi.system.domain.SysUserRole;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import org.mockito.ArgumentCaptor;

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

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
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 PartnerTypeRoleServiceTest {

    @ParameterizedTest
    @CsvSource({
            "1, independent_partner, 11",
            "2, site_owner, 12",
            "3, service_provider, 13"
    })
    void addsRoleMatchingPartnerType(Integer partnerType, String expectedRoleKey, Long expectedRoleId) {
        Fixture fixture = new Fixture(partnerType);
        fixture.stubBuiltInRoles();
        when(fixture.userRoleService.list(any(Wrapper.class))).thenReturn(Collections.emptyList());

        fixture.service.synchronize(fixture.user);

        ArgumentCaptor<SysUserRole> captor = ArgumentCaptor.forClass(SysUserRole.class);
        verify(fixture.userRoleService).save(captor.capture());
        assertEquals(expectedRoleId, captor.getValue().getRoleId());
        assertEquals(expectedRoleKey, fixture.roleKey(expectedRoleId));
    }

    @Test
    void replacesStaleBuiltInRoleButKeepsUnrelatedCustomRole() {
        Fixture fixture = new Fixture(2);
        fixture.stubBuiltInRoles();
        SysUserRole oldTypeRole = userRole(100L, 11L);
        SysUserRole customRole = userRole(100L, 99L);
        when(fixture.userRoleService.list(any(Wrapper.class)))
                .thenReturn(Arrays.asList(oldTypeRole, customRole));

        fixture.service.synchronize(fixture.user);

        verify(fixture.userRoleService).remove(any(Wrapper.class));
        ArgumentCaptor<SysUserRole> captor = ArgumentCaptor.forClass(SysUserRole.class);
        verify(fixture.userRoleService).save(captor.capture());
        assertEquals(Long.valueOf(12L), captor.getValue().getRoleId());
    }

    @Test
    void doesNothingForPlatformUser() {
        Fixture fixture = new Fixture(1);
        fixture.user.setRoleType(1);

        fixture.service.synchronize(fixture.user);

        verify(fixture.siteClient, never()).getPartnerR(any());
        verify(fixture.roleService, never()).list(any(Wrapper.class));
        verify(fixture.userRoleService, never()).save(any(SysUserRole.class));
    }

    @Test
    void failsClearlyWhenConfiguredRoleIsMissing() {
        Fixture fixture = new Fixture(3);
        when(fixture.roleService.list(any(Wrapper.class)))
                .thenReturn(Arrays.asList(role(11L, "independent_partner"), role(12L, "site_owner")));

        ServiceException exception = assertThrows(ServiceException.class,
                () -> fixture.service.synchronize(fixture.user));

        assertEquals("系统角色【service_provider】不存在或已停用，请先配置角色", exception.getMessage());
        verify(fixture.userRoleService, never()).save(any(SysUserRole.class));
    }

    private static SysRole role(Long roleId, String roleKey) {
        SysRole role = new SysRole();
        role.setRoleId(roleId);
        role.setRoleKey(roleKey);
        return role;
    }

    private static SysUserRole userRole(Long userId, Long roleId) {
        SysUserRole userRole = new SysUserRole();
        userRole.setUserId(userId);
        userRole.setRoleId(roleId);
        return userRole;
    }

    private static class Fixture {
        private final SiteClient siteClient = mock(SiteClient.class);
        private final ISysRoleService roleService = mock(ISysRoleService.class);
        private final ISysUserRoleService userRoleService = mock(ISysUserRoleService.class);
        private final PartnerTypeRoleService service =
                new PartnerTypeRoleService(siteClient, roleService, userRoleService);
        private final SysUser user = new SysUser();

        private Fixture(Integer partnerType) {
            user.setUserId(100L);
            user.setRoleType(2);
            user.setObjectId(715);
            Partner partner = new Partner();
            partner.setId(715);
            partner.setPartnerType(partnerType);
            when(siteClient.getPartnerR(715)).thenReturn(R.ok(partner));
        }

        private void stubBuiltInRoles() {
            when(roleService.list(any(Wrapper.class))).thenReturn(Arrays.asList(
                    role(11L, "independent_partner"),
                    role(12L, "site_owner"),
                    role(13L, "service_provider")
            ));
        }

        private String roleKey(Long roleId) {
            if (Long.valueOf(11L).equals(roleId)) {
                return "independent_partner";
            }
            if (Long.valueOf(12L).equals(roleId)) {
                return "site_owner";
            }
            return "service_provider";
        }
    }
}