package jnpf.dmsService;

import jnpf.base.UserInfo;
import jnpf.dmsEntity.permission.model.DmsSubjectSet;
import jnpf.dmsEntity.permission.vo.DmsCursorPageVO;
import jnpf.dmsEntity.permission.vo.DmsFileCenterItemVO;
import jnpf.dmsMapper.DmsFileCenterMapper;
import jnpf.dmsPermission.DmsCurrentIdentity;
import jnpf.dmsPermission.DmsFileCenterCursorCodec;
import jnpf.dmsPermission.DmsFileCenterQuery;
import jnpf.dmsPermission.DmsPermissionException;
import jnpf.dmsPermission.DmsPermissionGroupMembershipResolver;
import jnpf.dmsPermission.DmsPermissionProperties;
import jnpf.dmsPermission.DmsSubjectResolver;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;

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

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

    @Test
    void resolvesOrdinaryUserSubjectsBeforeFolderQueryAndReturnsKeysetCursor() {
        Fixture fixture = new Fixture(false);
        DmsSubjectSet subjects = new DmsSubjectSet();
        subjects.getDirectOrgIds().add("org-direct");
        subjects.getAncestorOrgIds().add("org-parent");
        subjects.getPositionIds().add("position-1");
        subjects.getRoleIds().add("role-1");
        subjects.getPermissionGroupIds().add("group-1");
        when(fixture.subjectResolver.resolve(fixture.user)).thenReturn(subjects);

        DmsFileCenterItemVO first = folder("A", fixture.firstId);
        DmsFileCenterItemVO second = folder("B", fixture.secondId);
        DmsFileCenterItemVO overflow = folder("C", fixture.thirdId);
        when(fixture.mapper.selectFolders(any())).thenReturn(Arrays.asList(first, second, overflow));

        DmsCursorPageVO<DmsFileCenterItemVO> result = fixture.service.rootFolders(null, 2);

        assertEquals(Arrays.asList(first, second), result.getList());
        assertTrue(result.isHasMore());
        assertNotNull(result.getNextCursor());
        verify(fixture.groupResolver).resolveAll(subjects, 1000);

        ArgumentCaptor<DmsFileCenterQuery> queryCaptor = ArgumentCaptor.forClass(DmsFileCenterQuery.class);
        verify(fixture.mapper).selectFolders(queryCaptor.capture());
        DmsFileCenterQuery query = queryCaptor.getValue();
        assertFalse(query.isAdministrator());
        assertEquals(3, query.getLimit());
        assertEquals(Collections.singletonList("org-direct"), query.getDirectOrgIds());
        assertEquals(Collections.singletonList("org-parent"), query.getAncestorOrgIds());
        assertEquals(Collections.singletonList("position-1"), query.getPositionIds());
        assertEquals(Collections.singletonList("role-1"), query.getRoleIds());
        assertEquals(Collections.singletonList("group-1"), query.getPermissionGroupIds());
    }

    @Test
    void administratorSkipsSubjectAndPermissionGroupResolution() {
        Fixture fixture = new Fixture(true);
        when(fixture.mapper.selectCurrentDocuments(any())).thenReturn(Collections.emptyList());

        DmsCursorPageVO<DmsFileCenterItemVO> result = fixture.service.currentDocuments(
                fixture.folderId, null, null, "  report  ");

        assertFalse(result.isHasMore());
        assertEquals(Collections.emptyList(), result.getList());
        verify(fixture.subjectResolver, never()).resolve(any());
        verify(fixture.groupResolver, never()).resolveAll(any(), any(Integer.class));

        ArgumentCaptor<DmsFileCenterQuery> queryCaptor = ArgumentCaptor.forClass(DmsFileCenterQuery.class);
        verify(fixture.mapper).selectCurrentDocuments(queryCaptor.capture());
        assertTrue(queryCaptor.getValue().isAdministrator());
        assertEquals("report", queryCaptor.getValue().getKeyword());
        assertEquals(21, queryCaptor.getValue().getLimit());
    }

    @Test
    void rejectsUnknownSharedCenterBeforeCallingMapper() {
        Fixture fixture = new Fixture(true);

        assertThrows(DmsPermissionException.class,
                () -> fixture.service.sharedDocuments("ARCHIVE", null, 20));

        verify(fixture.mapper, never()).selectSharedDocuments(any());
        verify(fixture.mapper, never()).selectSharedHistoricalVersions(any());
    }

    private static DmsFileCenterItemVO folder(String name, UUID id) {
        DmsFileCenterItemVO value = new DmsFileCenterItemVO();
        value.setId(id);
        value.setName(name);
        value.setResourceType("Folder");
        return value;
    }

    private static class Fixture {
        private final UUID folderId = UUID.fromString("018f0000-0000-7000-8000-000000000201");
        private final UUID firstId = UUID.fromString("018f0000-0000-7000-8000-000000000202");
        private final UUID secondId = UUID.fromString("018f0000-0000-7000-8000-000000000203");
        private final UUID thirdId = UUID.fromString("018f0000-0000-7000-8000-000000000204");
        private final UserInfo user = new UserInfo();
        private final DmsCurrentIdentity currentIdentity = mock(DmsCurrentIdentity.class);
        private final DmsSubjectResolver subjectResolver = mock(DmsSubjectResolver.class);
        private final DmsPermissionGroupMembershipResolver groupResolver =
                mock(DmsPermissionGroupMembershipResolver.class);
        private final DmsPermissionProperties properties = properties();
        private final DmsFileCenterCursorCodec cursorCodec = new DmsFileCenterCursorCodec(properties);
        private final DmsFileCenterMapper mapper = mock(DmsFileCenterMapper.class);
        private final DmsFileCenterService service = new DmsFileCenterService(
                currentIdentity, subjectResolver, groupResolver, properties, cursorCodec, mapper);

        private Fixture(boolean administrator) {
            user.setUserId("user-1");
            user.setTenantId("tenant-1");
            when(currentIdentity.requireUser()).thenReturn(user);
            when(currentIdentity.tenantId(user)).thenReturn("tenant-1");
            when(currentIdentity.isPermissionAdministrator()).thenReturn(administrator);
        }

        private static DmsPermissionProperties properties() {
            DmsPermissionProperties value = new DmsPermissionProperties();
            value.setDefaultPageSize(20);
            value.setMaxPageSize(100);
            value.setMaxPermissionGroupScan(1000);
            value.setCursorSigningSecret("0123456789abcdef0123456789abcdef");
            return value;
        }
    }
}