package jnpf.dmsService;

import jnpf.base.UserInfo;
import jnpf.dmsEntity.permission.model.DmsSubjectSet;
import jnpf.dmsEntity.permission.enums.DmsPermissionAction;
import jnpf.dmsEntity.permission.enums.DmsResourceType;
import jnpf.dmsEntity.permission.vo.DmsCursorPageVO;
import jnpf.dmsEntity.permission.vo.DmsFileCenterItemVO;
import jnpf.dmsEntity.permission.vo.DmsFolderTreeNodeVO;
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.times;
import static org.mockito.Mockito.when;

class DmsFileCenterServiceTest {

    @Test
    void folderTreeReturnsOnlyOnePageWithPermissionFilteredExpansionState() {
        Fixture fixture = new Fixture(false);
        when(fixture.subjectResolver.resolve(fixture.user)).thenReturn(new DmsSubjectSet());
        DmsFileCenterItemVO first = folder("A", fixture.firstId);
        first.setParentId(fixture.folderId);
        first.setHasChildren(true);
        DmsFileCenterItemVO second = folder("B", fixture.secondId);
        second.setHasChildren(false);
        when(fixture.mapper.selectFolders(any())).thenReturn(Arrays.asList(first, second));

        DmsCursorPageVO<DmsFolderTreeNodeVO> result = fixture.service.folderTree(fixture.folderId, null, 1);

        assertEquals(1, result.getList().size());
        assertEquals(first.getId(), result.getList().get(0).getId());
        assertEquals(first.getParentId(), result.getList().get(0).getParentId());
        assertEquals(first.getName(), result.getList().get(0).getName());
        assertTrue(result.getList().get(0).isHasChildren());
        assertTrue(result.isHasMore());
        DmsFileCenterCursorCodec.Cursor decoded = fixture.cursorCodec.decode(result.getNextCursor(), "FOLDER", "tenant-1",
                "user-1", fixture.folderId, fixture.cursorCodec.fingerprint(null));
        assertEquals(first.getId(), decoded.getId());
        assertEquals(first.getSortCode(), decoded.getSortCode());
        ArgumentCaptor<DmsFileCenterQuery> captor = ArgumentCaptor.forClass(DmsFileCenterQuery.class);
        verify(fixture.mapper).selectFolders(captor.capture());
        assertTrue(captor.getValue().isIncludeFolderChildren());
        assertFalse(captor.getValue().isAdministrator());
        assertEquals(fixture.folderId, captor.getValue().getParentId());
        assertEquals("tenant-1", captor.getValue().getTenantId());
        assertEquals("user-1", captor.getValue().getUserId());
    }

    @Test
    void folderTreeSupportsRootLeafAndEmptyResults() {
        Fixture fixture = new Fixture(true);
        DmsFileCenterItemVO leaf = folder("A", fixture.firstId);
        leaf.setHasChildren(false);
        when(fixture.mapper.selectFolders(any())).thenReturn(Collections.singletonList(leaf),
                Collections.emptyList());

        DmsCursorPageVO<DmsFolderTreeNodeVO> root = fixture.service.folderTree(null, null, 20);
        assertFalse(root.getList().get(0).isHasChildren());
        assertFalse(root.isHasMore());
        assertTrue(fixture.service.folderTree(fixture.firstId, null, 20).getList().isEmpty());
    }

    @Test
    void folderTreeRejectsInvalidPageSizeAndCursorFromAnotherParentOrUser() {
        Fixture fixture = new Fixture(true);
        String cursor = fixture.cursorCodec.encode("FOLDER", "tenant-1", "user-1", fixture.folderId,
                fixture.cursorCodec.fingerprint(null), new DmsFileCenterCursorCodec.Cursor(
                        "A", null, null, 1024L, fixture.firstId));
        assertThrows(DmsPermissionException.class, () -> fixture.service.folderTree(null, null, 0));
        assertThrows(DmsPermissionException.class, () -> fixture.service.folderTree(null, null, 101));
        assertThrows(DmsPermissionException.class, () -> fixture.service.folderTree(null, cursor, 20));
        fixture.user.setUserId("user-2");
        assertThrows(DmsPermissionException.class,
                () -> fixture.service.folderTree(fixture.folderId, cursor, 20));
        verify(fixture.mapper, never()).selectFolders(any());
    }

    @Test
    void folderTreeRequiresAuthenticatedUser() {
        Fixture fixture = new Fixture(false);
        when(fixture.currentIdentity.requireUser()).thenThrow(new IllegalStateException("not logged in"));
        assertThrows(IllegalStateException.class, () -> fixture.service.folderTree(null, null, 20));
        verify(fixture.mapper, never()).selectFolders(any());
    }

    @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.selectCurrentFiles(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(DmsSubjectSet.class), any(Integer.class));

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

    @Test
    void fileNameExistenceChecksExactNameWithoutUsingVersion() {
        Fixture fixture = new Fixture(true);
        when(fixture.mapper.fileNameExists("tenant-1", fixture.folderId, "report.pdf"))
                .thenReturn(true);

        assertTrue(fixture.service.fileNameExists(fixture.folderId, " report.pdf ", "V1"));
        assertTrue(fixture.service.fileNameExists(fixture.folderId, " report.pdf ", "V2"));

        verify(fixture.mapper, times(2)).fileNameExists("tenant-1", fixture.folderId, "report.pdf");
    }

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

        assertThrows(DmsPermissionException.class,
                () -> fixture.service.fileNameExists(null, "report.pdf", "V1"));
        assertThrows(DmsPermissionException.class,
                () -> fixture.service.fileNameExists(fixture.folderId, " ", "V1"));
        verify(fixture.mapper, never()).fileNameExists(any(), any(), any());
    }

    @Test
    void fileNameExistenceRequiresFolderCreatePermission() {
        Fixture fixture = new Fixture(false);

        fixture.service.fileNameExists(fixture.folderId, "report.pdf", "V1");

        verify(fixture.decisionService).requireAllowed(
                DmsResourceType.FOLDER, fixture.folderId, DmsPermissionAction.CREATE);
        verify(fixture.mapper).fileNameExists("tenant-1", fixture.folderId, "report.pdf");
    }

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

        fixture.service.historicalVersions(fixture.folderId, null, 20, "  ");

        verify(fixture.mapper).selectHistoricalVersions(any());
        verify(fixture.mapper, never()).selectHistoricalFiles(any());
    }

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

        fixture.service.historicalVersions(fixture.folderId, null, 20, " report ");

        ArgumentCaptor<DmsFileCenterQuery> queryCaptor = ArgumentCaptor.forClass(DmsFileCenterQuery.class);
        verify(fixture.mapper).selectHistoricalFiles(queryCaptor.capture());
        verify(fixture.mapper, never()).selectHistoricalVersions(any());
        assertEquals("report", queryCaptor.getValue().getKeyword());
    }

    @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());
    }

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

        fixture.service.documentVersions(fixture.firstId, "CURRENT", null, 20, " report ");

        ArgumentCaptor<DmsFileCenterQuery> queryCaptor = ArgumentCaptor.forClass(DmsFileCenterQuery.class);
        verify(fixture.mapper).selectCurrentDocumentVersions(queryCaptor.capture());
        verify(fixture.mapper, never()).selectDocumentVersions(any());
        assertEquals(fixture.firstId, queryCaptor.getValue().getDocumentId());
        assertEquals("report", queryCaptor.getValue().getKeyword());
    }

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

        fixture.service.documentVersions(fixture.firstId, "HISTORICAL", null, 20, null);

        verify(fixture.mapper).selectDocumentVersions(any());
        verify(fixture.mapper, never()).selectCurrentDocumentVersions(any());
    }

    private static DmsFileCenterItemVO folder(String name, UUID id) {
        DmsFileCenterItemVO value = new DmsFileCenterItemVO();
        value.setId(id);
        value.setName(name);
        value.setResourceType("Folder");
        value.setSortCode((long) name.charAt(0) * 1024);
        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 DmsPermissionDecisionService decisionService = mock(DmsPermissionDecisionService.class);
        private final DmsFileCenterService service = new DmsFileCenterService(
                currentIdentity, subjectResolver, groupResolver, properties, cursorCodec, mapper,
                decisionService);

        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;
        }
    }
}