package jnpf.dmsController.permission;

import com.fasterxml.jackson.databind.ObjectMapper;
import jnpf.dmsController.DmsControllerTestSupport;
import jnpf.dmsEntity.permission.entity.DmsDocumentEntity;
import jnpf.dmsEntity.permission.entity.DmsFileVersionEntity;
import jnpf.dmsEntity.permission.entity.DmsFolderEntity;
import jnpf.dmsEntity.permission.enums.DmsResourceType;
import jnpf.dmsEntity.permission.form.FolderAuditSignForm;
import jnpf.dmsEntity.permission.form.FolderCopyForm;
import jnpf.dmsEntity.permission.form.FolderCreateUserForm;
import jnpf.dmsEntity.permission.form.FolderDeleteForm;
import jnpf.dmsEntity.permission.form.FolderMoveForm;
import jnpf.dmsEntity.permission.form.FolderRenameForm;
import jnpf.dmsEntity.permission.form.FolderReorderForm;
import jnpf.dmsEntity.permission.vo.DmsCursorPageVO;
import jnpf.dmsEntity.permission.vo.DmsPermissionGrantVO;
import jnpf.dmsEntity.permission.vo.DmsPermissionResourceVO;
import jnpf.dmsEntity.permission.vo.DmsResourceTypeDefinitionVO;
import jnpf.dmsService.DmsFolderManagementService;
import jnpf.dmsService.DmsPermissionAdminQueryService;
import jnpf.dmsService.DmsResourceQueryService;
import jnpf.dmsService.DmsResourceService;
import org.junit.jupiter.api.Test;

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

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

class PermissionResourceControllerTest extends DmsControllerTestSupport {
    private final DmsResourceQueryService queryService = mock(DmsResourceQueryService.class);
    private final DmsPermissionAdminQueryService permissionQueryService =
            mock(DmsPermissionAdminQueryService.class);
    private final DmsResourceService resourceService = mock(DmsResourceService.class);
    private final DmsFolderManagementService folderService = mock(DmsFolderManagementService.class);
    private final PermissionResourceController controller = new PermissionResourceController(
            queryService, permissionQueryService, resourceService, folderService);

    @Test
    void delegatesResourceQueriesAndResolvesTypeBeforeLoadingGrants() {
        UUID resourceId = UUID.randomUUID();
        UUID folderId = UUID.randomUUID();
        UUID documentId = UUID.randomUUID();
        UUID versionId = UUID.randomUUID();
        List<DmsResourceTypeDefinitionVO> types =
                Collections.singletonList(mock(DmsResourceTypeDefinitionVO.class));
        DmsCursorPageVO<DmsPermissionResourceVO> page = new DmsCursorPageVO<>();
        List<DmsPermissionResourceVO> children =
                Collections.singletonList(mock(DmsPermissionResourceVO.class));
        DmsPermissionResourceVO resource = mock(DmsPermissionResourceVO.class);
        List<DmsPermissionGrantVO> grants = Collections.singletonList(mock(DmsPermissionGrantVO.class));
        DmsFolderEntity folder = mock(DmsFolderEntity.class);
        DmsDocumentEntity document = mock(DmsDocumentEntity.class);
        DmsFileVersionEntity version = mock(DmsFileVersionEntity.class);
        when(queryService.typeDefinitions()).thenReturn(types);
        when(queryService.page("FOLDER", "cursor", 25)).thenReturn(page);
        when(queryService.children(folderId, 30, "manual")).thenReturn(children);
        when(queryService.resource(resourceId)).thenReturn(resource);
        when(resource.getResourceType()).thenReturn("FOLDER");
        when(permissionQueryService.resourceGrants(DmsResourceType.FOLDER, resourceId)).thenReturn(grants);
        when(queryService.folder(folderId)).thenReturn(folder);
        when(queryService.document(documentId)).thenReturn(document);
        when(queryService.fileVersion(versionId)).thenReturn(version);

        assertSame(types, controller.resourceTypes().getData());
        assertSame(page, controller.resources("FOLDER", "cursor", 25).getData());
        assertSame(children, controller.resourceTree(folderId, 30, "manual").getData());
        assertSame(resource, controller.resource(resourceId).getData());
        assertSame(grants, controller.resourceGrants(resourceId).getData());
        assertSame(folder, controller.folder(folderId).getData());
        assertSame(document, controller.document(documentId).getData());
        assertSame(version, controller.fileVersion(versionId).getData());

        verify(queryService).typeDefinitions();
        verify(queryService).page("FOLDER", "cursor", 25);
        verify(queryService).children(folderId, 30, "manual");
        verify(queryService, times(2)).resource(resourceId);
        verify(permissionQueryService).resourceGrants(DmsResourceType.FOLDER, resourceId);
        verify(queryService).folder(folderId);
        verify(queryService).document(documentId);
        verify(queryService).fileVersion(versionId);
    }

    @Test
    void delegatesEveryFolderMutationWithConcurrencyArguments() {
        UUID folderId = UUID.randomUUID();
        FolderCreateUserForm createForm = mock(FolderCreateUserForm.class);
        FolderRenameForm renameForm = mock(FolderRenameForm.class);
        FolderReorderForm reorderForm = mock(FolderReorderForm.class);
        FolderMoveForm moveForm = mock(FolderMoveForm.class);
        FolderCopyForm copyForm = mock(FolderCopyForm.class);
        DmsPermissionResourceVO created = mock(DmsPermissionResourceVO.class);
        DmsPermissionResourceVO renamed = mock(DmsPermissionResourceVO.class);
        DmsPermissionResourceVO reordered = mock(DmsPermissionResourceVO.class);
        DmsPermissionResourceVO moved = mock(DmsPermissionResourceVO.class);
        DmsPermissionResourceVO copied = mock(DmsPermissionResourceVO.class);
        when(resourceService.createFolder(createForm)).thenReturn(created);
        when(folderService.rename(folderId, renameForm)).thenReturn(renamed);
        when(folderService.reorder(folderId, reorderForm)).thenReturn(reordered);
        when(folderService.move(folderId, moveForm)).thenReturn(moved);
        when(folderService.copy(folderId, copyForm)).thenReturn(copied);

        assertSame(created, controller.createFolder(createForm).getData());
        assertSame(renamed, controller.renameFolder(folderId, renameForm).getData());
        assertEquals("删除成功", controller.deleteFolder(folderId, 7L, new FolderDeleteForm()).getMsg());
        assertSame(reordered, controller.reorderFolder(folderId, reorderForm).getData());
        assertSame(moved, controller.moveFolder(folderId, moveForm).getData());
        assertSame(copied, controller.copyFolder(folderId, copyForm).getData());

        verify(resourceService).createFolder(createForm);
        verify(folderService).rename(folderId, renameForm);
        verify(folderService).delete(folderId, 7L);
        verify(folderService).reorder(folderId, reorderForm);
        verify(folderService).move(folderId, moveForm);
        verify(folderService).copy(folderId, copyForm);
    }

    @Test
    void bindsBizSignForEveryFolderMutationWithoutForwardingItToAuditParameters() throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();
        for (Class<? extends FolderAuditSignForm> formType : Arrays.asList(
                FolderCreateUserForm.class,
                FolderRenameForm.class,
                FolderDeleteForm.class,
                FolderReorderForm.class,
                FolderMoveForm.class,
                FolderCopyForm.class)) {
            FolderAuditSignForm form = objectMapper.readValue("{\"biz_sign\":\"sign-1\"}", formType);

            assertEquals("sign-1", form.getBizSign(), formType.getSimpleName());
            assertTrue(form.getAuditSignParameters().isEmpty(), formType.getSimpleName());
        }
    }
}