package jnpf.dmsController.permission;

import cn.dev33.satoken.same.SaSameUtil;
import jnpf.dmsController.DmsControllerTestSupport;
import jnpf.dmsEntity.permission.form.DocumentCreateForm;
import jnpf.dmsEntity.download.form.DmsWorkflowDownloadAuthorizeForm;
import jnpf.dmsEntity.download.vo.DmsWorkflowDownloadAuthorizationVO;
import jnpf.dmsEntity.print.form.DmsWorkflowPrintAuthorizeForm;
import jnpf.dmsEntity.print.form.DmsWorkflowPrintFilesGrantForm;
import jnpf.dmsEntity.print.vo.DmsWorkflowPrintAuthorizationVO;
import jnpf.dmsEntity.print.vo.DmsWorkflowPrintFilesGrantResultVO;
import jnpf.dmsEntity.permission.form.FileVersionCreateForm;
import jnpf.dmsEntity.permission.form.FolderCreateForm;
import jnpf.dmsEntity.permission.form.DmsPersonalFolderBorrowForm;
import jnpf.dmsEntity.permission.form.DmsPersonalFolderDownloadForm;
import jnpf.dmsEntity.permission.vo.DmsPersonalFolderAddResultVO;
import jnpf.dmsEntity.permission.vo.DmsPermissionResourceVO;
import jnpf.dmsEntity.storage.form.DmsFileLifecycleUpdateForm;
import jnpf.dmsEntity.storage.form.DmsFileRevisionRegisterForm;
import jnpf.dmsEntity.storage.form.DmsFileUploadRegisterForm;
import jnpf.dmsEntity.storage.form.DmsWorkflowFilePrepareForm;
import jnpf.dmsEntity.storage.form.DmsWorkflowFileActivateForm;
import jnpf.dmsEntity.storage.form.DmsApprovedRegistrationCallback;
import jnpf.dmsEntity.storage.form.DmsWorkflowRevisionRegisterForm;
import jnpf.dmsEntity.storage.vo.DmsFileLifecycleUpdateVO;
import jnpf.dmsEntity.storage.vo.DmsFileUploadVO;
import jnpf.dmsEntity.storage.approval.DmsApprovedBatch;
import jnpf.dmsEntity.storage.vo.DmsWorkflowFilePrepareVO;
import jnpf.dmsPermission.DmsTrustedServiceGuard;
import jnpf.dmsPermission.DmsCurrentIdentity;
import jnpf.base.UserInfo;
import jnpf.dmsService.DmsFileLifecycleService;
import jnpf.dmsService.DmsFileRevisionService;
import jnpf.dmsService.DmsFileUploadService;
import jnpf.dmsService.DmsPersonalFolderService;
import jnpf.dmsService.DmsResourceService;
import jnpf.dmsService.DmsWorkflowFilePrepareService;
import jnpf.dmsService.DmsApprovedFlowService;
import jnpf.dmsService.DmsWorkflowFileRegistrationService;
import jnpf.dmsService.DmsWorkflowFileActivationService;
import jnpf.dmsService.DmsWorkflowDownloadAuthorizationService;
import jnpf.dmsService.DmsWorkflowPrintAuthorizationService;
import org.junit.jupiter.api.Test;
import org.mockito.InOrder;
import org.mockito.MockedStatic;

import java.util.concurrent.atomic.AtomicBoolean;

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.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.mockStatic;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.when;

class DmsInternalResourceControllerTest extends DmsControllerTestSupport {
    private final DmsTrustedServiceGuard trustedServiceGuard = mock(DmsTrustedServiceGuard.class);
    private final DmsResourceService resourceService = mock(DmsResourceService.class);
    private final DmsFileUploadService uploadService = mock(DmsFileUploadService.class);
    private final DmsFileRevisionService revisionService = mock(DmsFileRevisionService.class);
    private final DmsFileLifecycleService lifecycleService = mock(DmsFileLifecycleService.class);
    private final DmsWorkflowFilePrepareService workflowFilePrepareService =
            mock(DmsWorkflowFilePrepareService.class);
    private final DmsWorkflowFileRegistrationService workflowRegistrationService =
            mock(DmsWorkflowFileRegistrationService.class);
    private final DmsWorkflowFileActivationService workflowActivationService =
            mock(DmsWorkflowFileActivationService.class);
    private final DmsWorkflowDownloadAuthorizationService workflowDownloadAuthorizationService =
            mock(DmsWorkflowDownloadAuthorizationService.class);
    private final DmsWorkflowPrintAuthorizationService workflowPrintAuthorizationService =
            mock(DmsWorkflowPrintAuthorizationService.class);
    private final DmsApprovedFlowService approvedFlowService = mock(DmsApprovedFlowService.class);
    private final DmsPersonalFolderService personalFolderService = mock(DmsPersonalFolderService.class);
    private final DmsCurrentIdentity currentIdentity = mock(DmsCurrentIdentity.class);
    private final DmsInternalResourceController controller = new DmsInternalResourceController(
            trustedServiceGuard, resourceService, uploadService, revisionService, lifecycleService,
            workflowFilePrepareService, approvedFlowService, workflowRegistrationService, workflowActivationService,
            workflowDownloadAuthorizationService, workflowPrintAuthorizationService,
            personalFolderService, currentIdentity);

    @Test
    void protectsAndDelegatesEveryInternalRegistrationApi() {
        String requestedServiceId = "jnpf-file";
        String trustedServiceId = "trusted-jnpf-file";
        FolderCreateForm folderForm = mock(FolderCreateForm.class);
        DocumentCreateForm documentForm = mock(DocumentCreateForm.class);
        FileVersionCreateForm versionForm = mock(FileVersionCreateForm.class);
        DmsFileLifecycleUpdateForm lifecycleForm = mock(DmsFileLifecycleUpdateForm.class);
        DmsFileUploadRegisterForm uploadForm = mock(DmsFileUploadRegisterForm.class);
        DmsFileRevisionRegisterForm revisionForm = mock(DmsFileRevisionRegisterForm.class);
        DmsWorkflowFilePrepareForm prepareForm = mock(DmsWorkflowFilePrepareForm.class);
        DmsApprovedRegistrationCallback workflowUpload = mock(DmsApprovedRegistrationCallback.class);
        DmsWorkflowRevisionRegisterForm workflowRevision = mock(DmsWorkflowRevisionRegisterForm.class);
        DmsWorkflowFileActivateForm activationForm = new DmsWorkflowFileActivateForm();
        activationForm.setSourceId("flow-1");
        activationForm.setTaskId("task-1");
        activationForm.setFileType(jnpf.dmsEntity.storage.enums.DmsWorkflowFileType.CREATE);
        DmsWorkflowDownloadAuthorizeForm downloadForm = new DmsWorkflowDownloadAuthorizeForm();
        downloadForm.setSourceId("flow-1");
        downloadForm.setTaskId("task-1");
        DmsWorkflowPrintAuthorizeForm printForm = new DmsWorkflowPrintAuthorizeForm();
        printForm.setSourceId("flow-1");
        printForm.setTaskId("task-1");
        DmsWorkflowPrintFilesGrantForm printFilesForm = mock(DmsWorkflowPrintFilesGrantForm.class);
        DmsWorkflowPrintFilesGrantResultVO printFilesResult =
                new DmsWorkflowPrintFilesGrantResultVO(1, 1);
        DmsPersonalFolderBorrowForm borrowForm = mock(DmsPersonalFolderBorrowForm.class);
        DmsPersonalFolderDownloadForm personalDownloadForm = mock(DmsPersonalFolderDownloadForm.class);
        DmsPersonalFolderAddResultVO borrowResult = new DmsPersonalFolderAddResultVO(1, 1);
        DmsPersonalFolderAddResultVO personalDownloadResult = new DmsPersonalFolderAddResultVO(1, 1);
        DmsPermissionResourceVO folder = mock(DmsPermissionResourceVO.class);
        DmsPermissionResourceVO document = mock(DmsPermissionResourceVO.class);
        DmsPermissionResourceVO version = mock(DmsPermissionResourceVO.class);
        DmsFileLifecycleUpdateVO lifecycle = mock(DmsFileLifecycleUpdateVO.class);
        DmsFileUploadVO upload = mock(DmsFileUploadVO.class);
        DmsFileUploadVO revision = mock(DmsFileUploadVO.class);
        DmsFileUploadVO activated = mock(DmsFileUploadVO.class);
        DmsWorkflowFilePrepareVO prepared = mock(DmsWorkflowFilePrepareVO.class);
        DmsApprovedBatch registered = mock(DmsApprovedBatch.class);
        DmsWorkflowDownloadAuthorizationVO authorized = mock(DmsWorkflowDownloadAuthorizationVO.class);
        DmsWorkflowPrintAuthorizationVO printAuthorized = mock(DmsWorkflowPrintAuthorizationVO.class);
        AtomicBoolean sameTokenChecked = new AtomicBoolean();
        when(trustedServiceGuard.requireAllowed(requestedServiceId)).thenAnswer(invocation -> {
            assertTrue(sameTokenChecked.getAndSet(false), "SAME-TOKEN must be checked before service ID");
            return trustedServiceId;
        });
        when(resourceService.createFolder(folderForm, trustedServiceId)).thenReturn(folder);
        when(resourceService.createDocument(documentForm, trustedServiceId)).thenReturn(document);
        when(resourceService.createFileVersion(versionForm, trustedServiceId)).thenReturn(version);
        when(lifecycleService.updateExpired(lifecycleForm, trustedServiceId)).thenReturn(lifecycle);
        when(uploadService.register(uploadForm, trustedServiceId)).thenReturn(upload);
        when(revisionService.register(revisionForm, trustedServiceId)).thenReturn(revision);
        when(workflowFilePrepareService.prepare(prepareForm, trustedServiceId)).thenReturn(prepared);
        when(approvedFlowService.completeRegistration(workflowUpload, trustedServiceId)).thenReturn(registered);
        when(workflowRegistrationService.revise(workflowRevision, trustedServiceId)).thenReturn(revision);
        UserInfo user = new UserInfo();
        user.setUserId("user-1");
        when(currentIdentity.requireUser()).thenReturn(user);
        when(currentIdentity.tenantId(user)).thenReturn("tenant-1");
        when(workflowActivationService.activate("tenant-1", "flow-1", "task-1",
                activationForm.getFileType(), "user-1")).thenReturn(activated);
        when(workflowDownloadAuthorizationService.authorize(
                "tenant-1", downloadForm, trustedServiceId)).thenReturn(authorized);
        when(workflowPrintAuthorizationService.authorize(
                "tenant-1", printForm, trustedServiceId)).thenReturn(printAuthorized);
        when(personalFolderService.addBorrowSnapshots(borrowForm, trustedServiceId))
                .thenReturn(borrowResult);
        when(personalFolderService.addDownloadSnapshots(personalDownloadForm, trustedServiceId))
                .thenReturn(personalDownloadResult);
        when(personalFolderService.grantPrintPermissions(printFilesForm, trustedServiceId))
                .thenReturn(printFilesResult);

        try (MockedStatic<SaSameUtil> sameToken = mockStatic(SaSameUtil.class)) {
            sameToken.when(SaSameUtil::checkCurrentRequestToken).thenAnswer(invocation -> {
                sameTokenChecked.set(true);
                return null;
            });

            assertSame(folder, controller.createFolder(requestedServiceId, folderForm).getData());
            assertSame(borrowResult, controller.addBorrowedFilesToPersonalFolder(
                    requestedServiceId, borrowForm).getData());
            assertSame(personalDownloadResult, controller.addDownloadedFilesToPersonalFolder(
                    requestedServiceId, personalDownloadForm).getData());
            assertSame(document, controller.createDocument(requestedServiceId, documentForm).getData());
            assertSame(version, controller.createFileVersion(requestedServiceId, versionForm).getData());
            assertSame(lifecycle, controller.updateFileLifecycle(
                    requestedServiceId, lifecycleForm).getData());
            assertSame(upload, controller.registerUpload(
                    requestedServiceId, "audit-sign-1", uploadForm).getData());
            assertSame(revision, controller.registerRevision(
                    requestedServiceId, "audit-sign-1", revisionForm).getData());
            assertSame(prepared, controller.prepareWorkflowFile(
                    requestedServiceId, prepareForm).getData());
            assertSame(registered, controller.registerWorkflowUpload(
                    requestedServiceId, "audit-sign-1", workflowUpload).getData());
            assertSame(revision, controller.registerWorkflowRevision(
                    requestedServiceId, "audit-sign-1", workflowRevision).getData());
            assertSame(activated, controller.activateWorkflowFile(
                    requestedServiceId, activationForm).getData());
            assertSame(authorized, controller.authorizeWorkflowDownload(
                    requestedServiceId, "audit-sign-1", downloadForm).getData());
            assertEquals("audit-sign-1", downloadForm.getBizSign());
            assertSame(printAuthorized, controller.authorizeWorkflowPrint(
                    requestedServiceId, "print-sign-1", printForm).getData());
            assertEquals("print-sign-1", printForm.getBizSign());
            assertSame(printFilesResult, controller.grantWorkflowPrintFiles(
                    requestedServiceId, printFilesForm).getData());

            sameToken.verify(SaSameUtil::checkCurrentRequestToken, times(15));
        }

        InOrder order = inOrder(trustedServiceGuard, resourceService, uploadService,
                revisionService, lifecycleService, workflowFilePrepareService, approvedFlowService, workflowRegistrationService,
                workflowActivationService, workflowDownloadAuthorizationService,
                workflowPrintAuthorizationService, personalFolderService);
        order.verify(trustedServiceGuard).requireAllowed(requestedServiceId);
        order.verify(resourceService).createFolder(folderForm, trustedServiceId);
        order.verify(trustedServiceGuard).requireAllowed(requestedServiceId);
        order.verify(personalFolderService).addBorrowSnapshots(borrowForm, trustedServiceId);
        order.verify(trustedServiceGuard).requireAllowed(requestedServiceId);
        order.verify(personalFolderService).addDownloadSnapshots(personalDownloadForm, trustedServiceId);
        order.verify(trustedServiceGuard).requireAllowed(requestedServiceId);
        order.verify(resourceService).createDocument(documentForm, trustedServiceId);
        order.verify(trustedServiceGuard).requireAllowed(requestedServiceId);
        order.verify(resourceService).createFileVersion(versionForm, trustedServiceId);
        order.verify(trustedServiceGuard).requireAllowed(requestedServiceId);
        order.verify(lifecycleService).updateExpired(lifecycleForm, trustedServiceId);
        order.verify(trustedServiceGuard).requireAllowed(requestedServiceId);
        order.verify(uploadService).register(uploadForm, trustedServiceId);
        order.verify(trustedServiceGuard).requireAllowed(requestedServiceId);
        order.verify(revisionService).register(revisionForm, trustedServiceId);
        order.verify(trustedServiceGuard).requireAllowed(requestedServiceId);
        order.verify(workflowFilePrepareService).prepare(prepareForm, trustedServiceId);
        order.verify(trustedServiceGuard).requireAllowed(requestedServiceId);
        order.verify(approvedFlowService).completeRegistration(workflowUpload, trustedServiceId);
        order.verify(trustedServiceGuard).requireAllowed(requestedServiceId);
        order.verify(workflowRegistrationService).revise(workflowRevision, trustedServiceId);
        order.verify(trustedServiceGuard).requireAllowed(requestedServiceId);
        order.verify(workflowActivationService).activate("tenant-1", "flow-1", "task-1",
                activationForm.getFileType(), "user-1");
        order.verify(trustedServiceGuard).requireAllowed(requestedServiceId);
        order.verify(workflowDownloadAuthorizationService).authorize(
                "tenant-1", downloadForm, trustedServiceId);
        order.verify(trustedServiceGuard).requireAllowed(requestedServiceId);
        order.verify(workflowPrintAuthorizationService).authorize(
                "tenant-1", printForm, trustedServiceId);
        order.verify(trustedServiceGuard).requireAllowed(requestedServiceId);
        order.verify(personalFolderService).grantPrintPermissions(printFilesForm, trustedServiceId);
    }
}