package jnpf.fileStorage.dms;

import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.WriteListener;
import jnpf.dmsEntity.download.model.DmsFileDownloadTicket;
import jnpf.dmsEntity.storage.model.DmsPersistentPdfSource;
import jnpf.dmsEntity.preview.model.DmsWatermarkSnapshot;
import jnpf.exception.DataException;
import jnpf.base.ActionResult;
import jnpf.onlyoffice.DmsDownloadPdfApi;
import jnpf.onlyoffice.DmsDownloadPdfRequest;
import jnpf.util.JsonUtil;
import org.dromara.x.file.storage.core.FileStorageService;
import org.dromara.x.file.storage.core.FileInfo;
import org.dromara.x.file.storage.core.platform.MinioFileStorage;
import org.junit.Test;

import java.io.ByteArrayOutputStream;
import java.io.OutputStream;
import java.util.Collections;
import java.util.UUID;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
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;

public class DmsFileDownloadStorageServiceTest {
    private static final UUID VERSION_ID =
            UUID.fromString("018f0000-0000-7000-8000-000000000702");

    @Test
    public void parsesValidDownloadPayloadWithFrozenWatermarks() {
        DmsFileDownloadTicket payload = payload(60_000L);
        payload.setWatermarks(Collections.singletonList(new DmsWatermarkSnapshot()));
        DmsFileDownloadStorageService service = service(payload);

        DmsFileDownloadTicket parsed = service.parse("ticket");

        assertEquals(VERSION_ID, parsed.getFileVersionId());
        assertEquals(1, parsed.getWatermarks().size());
    }

    @Test(expected = DataException.class)
    public void rejectsExpiredDownloadPayload() {
        service(payload(-1L)).parse("ticket");
    }

    @Test
    public void rejectsPreviewScopeBeforeAccessingStorage() {
        FileStorageService storageService = mock(FileStorageService.class);
        DmsFileDownloadTicket payload = payload(60_000L);
        payload.setScope("dms:onlyoffice:preview");
        DmsFileDownloadStorageService service = new DmsFileDownloadStorageService(storageService,
                ticket -> JsonUtil.getObjectToString(payload), mock(DmsFileWatermarkService.class),
                mock(DmsDownloadPdfApi.class));

        try {
            service.stream(VERSION_ID, "ticket", mock(HttpServletResponse.class));
            fail("expected invalid ticket scope");
        } catch (DataException expected) {
            assertEquals("DMS 下载票据无效或已过期", expected.getMessage());
        }

        verify(storageService, never()).getFileStorageVerify("seaweedfs-1");
    }

    @Test
    public void dynamicallyWatermarksDocxAndReturnsItAsAttachment() throws Exception {
        byte[] sourceBytes = new byte[]{1, 2, 3};
        byte[] watermarkedBytes = new byte[]{4, 5, 6, 7};
        DmsFileDownloadTicket payload = payload(60_000L);
        payload.setWatermarks(Collections.singletonList(new DmsWatermarkSnapshot()));
        FileStorageService storageService = mock(FileStorageService.class,
                org.mockito.Mockito.RETURNS_DEEP_STUBS);
        MinioFileStorage storage = mock(MinioFileStorage.class);
        when(storage.getBucketName()).thenReturn("jnpf-dms");
        when(storageService.getFileStorageVerify("seaweedfs-1")).thenReturn(storage);
        Class<?> downloaderType = FileStorageService.class
                .getMethod("download", FileInfo.class).getReturnType();
        Object downloader = mock(downloaderType, invocation -> {
            if ("outputStream".equals(invocation.getMethod().getName())) {
                OutputStream output = invocation.getArgument(0);
                output.write(sourceBytes);
            }
            return null;
        });
        when(storageService.download(any(FileInfo.class))).thenAnswer(invocation -> downloader);
        DmsFileWatermarkService watermarkService = mock(DmsFileWatermarkService.class);
        when(watermarkService.loadAndApply(any(), any(DmsFileDownloadTicket.class)))
                .thenAnswer(invocation -> {
                    DmsImageWatermarkService.SourceReader reader = invocation.getArgument(0);
                    DmsFileDownloadTicket parsed = invocation.getArgument(1);
                    assertEquals(VERSION_ID, parsed.getFileVersionId());
                    assertArrayEquals(sourceBytes, reader.read());
                    return watermarkedBytes;
                });
        DmsFileDownloadStorageService service = new DmsFileDownloadStorageService(storageService,
                ticket -> JsonUtil.getObjectToString(payload), watermarkService, mock(DmsDownloadPdfApi.class));
        HttpServletResponse response = mock(HttpServletResponse.class);
        ByteArrayOutputStream responseBody = new ByteArrayOutputStream();
        when(response.getOutputStream()).thenReturn(new ServletOutputStream() {
            @Override
            public boolean isReady() {
                return true;
            }

            @Override
            public void setWriteListener(WriteListener writeListener) {
            }

            @Override
            public void write(int value) {
                responseBody.write(value);
            }
        });

        service.stream(VERSION_ID, "ticket", response);

        assertArrayEquals(watermarkedBytes, responseBody.toByteArray());
        verify(response).setContentLengthLong(watermarkedBytes.length);
        org.mockito.ArgumentCaptor<String> disposition =
                org.mockito.ArgumentCaptor.forClass(String.class);
        verify(response).setHeader(org.mockito.ArgumentMatchers.eq(
                        org.springframework.http.HttpHeaders.CONTENT_DISPOSITION),
                disposition.capture());
        assertTrue(disposition.getValue().startsWith("attachment;"));
        verify(watermarkService).loadAndApply(any(), any(DmsFileDownloadTicket.class));
    }

    @Test
    public void dynamicallyWatermarksPngAndReturnsImageAttachmentHeaders() throws Exception {
        byte[] sourceBytes = new byte[]{(byte) 0x89, 0x50, 0x4e, 0x47, 1};
        byte[] watermarkedBytes = new byte[]{(byte) 0x89, 0x50, 0x4e, 0x47, 2, 3};
        DmsFileDownloadTicket payload = payload(60_000L);
        payload.setFileName("diagram.png");
        payload.setMimeType("image/png");
        payload.setSizeBytes((long) sourceBytes.length);
        payload.setObjectPath("2026/08/24/image/");
        payload.setObjectName("diagram-v1.png");
        payload.setWatermarks(Collections.singletonList(new DmsWatermarkSnapshot()));
        FileStorageService storageService = storage(payload);
        Class<?> downloaderType = FileStorageService.class
                .getMethod("download", FileInfo.class).getReturnType();
        Object downloader = mock(downloaderType, invocation -> {
            if ("outputStream".equals(invocation.getMethod().getName())) {
                ((OutputStream) invocation.getArgument(0)).write(sourceBytes);
            }
            return null;
        });
        when(storageService.download(any(FileInfo.class))).thenAnswer(invocation -> downloader);
        DmsFileWatermarkService watermarkService = mock(DmsFileWatermarkService.class);
        when(watermarkService.loadAndApply(any(), any(DmsFileDownloadTicket.class)))
                .thenAnswer(invocation -> {
                    DmsImageWatermarkService.SourceReader reader = invocation.getArgument(0);
                    DmsFileDownloadTicket parsed = invocation.getArgument(1);
                    assertEquals(VERSION_ID, parsed.getFileVersionId());
                    assertArrayEquals(sourceBytes, reader.read());
                    return watermarkedBytes;
                });
        DmsFileDownloadStorageService service = new DmsFileDownloadStorageService(storageService,
                ticket -> JsonUtil.getObjectToString(payload), watermarkService, mock(DmsDownloadPdfApi.class));
        org.springframework.mock.web.MockHttpServletResponse response =
                new org.springframework.mock.web.MockHttpServletResponse();

        service.stream(VERSION_ID, "ticket", response);

        assertArrayEquals(watermarkedBytes, response.getContentAsByteArray());
        assertEquals("image/png", response.getContentType());
        assertEquals(watermarkedBytes.length, response.getContentLength());
        assertEquals("no-store", response.getHeader("Cache-Control"));
        org.springframework.http.ContentDisposition disposition = org.springframework.http.ContentDisposition
                .parse(response.getHeader("Content-Disposition"));
        assertEquals("attachment", disposition.getType());
        assertEquals("diagram.png", disposition.getFilename());
        verify(watermarkService).loadAndApply(any(), any(DmsFileDownloadTicket.class));
    }

    @Test
    public void watermarkFailureDoesNotWriteOriginalPngToDownloadResponse() throws Exception {
        byte[] sourceBytes = new byte[]{(byte) 0x89, 0x50, 0x4e, 0x47, 1};
        DmsFileDownloadTicket payload = payload(60_000L);
        payload.setFileName("diagram.png");
        payload.setMimeType("image/png");
        payload.setSizeBytes((long) sourceBytes.length);
        payload.setWatermarks(Collections.singletonList(new DmsWatermarkSnapshot()));
        FileStorageService storageService = storage(payload);
        Class<?> downloaderType = FileStorageService.class
                .getMethod("download", FileInfo.class).getReturnType();
        Object downloader = mock(downloaderType, invocation -> {
            if ("outputStream".equals(invocation.getMethod().getName())) {
                ((OutputStream) invocation.getArgument(0)).write(sourceBytes);
            }
            return null;
        });
        when(storageService.download(any(FileInfo.class))).thenAnswer(invocation -> downloader);
        DmsFileWatermarkService watermarkService = mock(DmsFileWatermarkService.class);
        when(watermarkService.loadAndApply(any(), any(DmsFileDownloadTicket.class)))
                .thenAnswer(invocation -> {
                    DmsImageWatermarkService.SourceReader reader = invocation.getArgument(0);
                    assertArrayEquals(sourceBytes, reader.read());
                    throw new DataException("图片水印生成失败");
                });
        DmsFileDownloadStorageService service = new DmsFileDownloadStorageService(storageService,
                ticket -> JsonUtil.getObjectToString(payload), watermarkService,
                mock(DmsDownloadPdfApi.class));
        org.springframework.mock.web.MockHttpServletResponse response =
                new org.springframework.mock.web.MockHttpServletResponse();

        try {
            service.stream(VERSION_ID, "ticket", response);
            fail("expected image watermark failure");
        } catch (DataException expected) {
            assertEquals("图片水印生成失败", expected.getMessage());
        }

        assertEquals(0, response.getContentAsByteArray().length);
        assertNull(response.getContentType());
        assertNull(response.getHeader("Content-Disposition"));
    }

    private DmsFileDownloadStorageService service(DmsFileDownloadTicket payload) {
        String json = JsonUtil.getObjectToString(payload);
        return new DmsFileDownloadStorageService(mock(FileStorageService.class), ticket -> json,
                mock(DmsFileWatermarkService.class), mock(DmsDownloadPdfApi.class));
    }

    @Test
    public void pdfDownloadUsesSameTicketAndReturnsPdfAttachmentMetadata() throws Exception {
        DmsFileDownloadTicket payload = payload(60_000L);
        payload.setFileName("质量手册.V2.DOCX");
        byte[] pdfBytes = "%PDF-1.7 converted".getBytes(java.nio.charset.StandardCharsets.UTF_8);
        DmsDownloadPdfApi converter = mock(DmsDownloadPdfApi.class);
        ActionResult<byte[]> converted = new ActionResult<>();
        converted.setCode(200);
        converted.setData(pdfBytes);
        when(converter.render(new DmsDownloadPdfRequest(VERSION_ID, "download-ticket")))
                .thenReturn(converted);
        FileStorageService storage = storage(payload);
        DmsFileWatermarkService watermarks = mock(DmsFileWatermarkService.class);
        DmsFileDownloadStorageService service = new DmsFileDownloadStorageService(storage,
                ticket -> JsonUtil.getObjectToString(payload), watermarks, converter);
        org.springframework.mock.web.MockHttpServletResponse response =
                new org.springframework.mock.web.MockHttpServletResponse();

        service.stream(VERSION_ID, "download-ticket", "pdf", response);

        assertArrayEquals(pdfBytes, response.getContentAsByteArray());
        assertEquals("application/pdf", response.getContentType());
        assertEquals(pdfBytes.length, response.getContentLength());
        assertEquals("no-store", response.getHeader("Cache-Control"));
        org.springframework.http.ContentDisposition disposition = org.springframework.http.ContentDisposition
                .parse(response.getHeader("Content-Disposition"));
        assertEquals("attachment", disposition.getType());
        assertEquals("质量手册.V2.pdf", disposition.getFilename());
        verify(storage, never()).download(any(FileInfo.class));
        org.mockito.Mockito.verifyNoInteractions(watermarks);
    }

    @Test
    public void pdfDownloadUsesExistingPersistentPdfBeforeConverter() throws Exception {
        byte[] pdfBytes = "%PDF-1.7 persisted".getBytes(java.nio.charset.StandardCharsets.UTF_8);
        DmsFileDownloadTicket payload = payload(60_000L);
        DmsPersistentPdfSource pdf = new DmsPersistentPdfSource();
        pdf.setObjectKey("dms-derived/pdf/018f0000/persisted.pdf");
        pdf.setSizeBytes((long) pdfBytes.length);
        payload.setPdfSource(pdf);
        FileStorageService storage = storage(payload);
        when(storage.exists(any(FileInfo.class))).thenReturn(true);
        Class<?> downloaderType = FileStorageService.class
                .getMethod("download", FileInfo.class).getReturnType();
        Object downloader = mock(downloaderType, invocation -> {
            if ("outputStream".equals(invocation.getMethod().getName())) {
                ((OutputStream) invocation.getArgument(0)).write(pdfBytes);
            }
            return null;
        });
        when(storage.download(any(FileInfo.class))).thenAnswer(invocation -> downloader);
        DmsDownloadPdfApi converter = mock(DmsDownloadPdfApi.class);
        DmsFileDownloadStorageService service = new DmsFileDownloadStorageService(storage,
                ticket -> JsonUtil.getObjectToString(payload), mock(DmsFileWatermarkService.class), converter);
        org.springframework.mock.web.MockHttpServletResponse response =
                new org.springframework.mock.web.MockHttpServletResponse();

        service.stream(VERSION_ID, "ticket", "pdf", response);

        assertArrayEquals(pdfBytes, response.getContentAsByteArray());
        org.mockito.Mockito.verifyNoInteractions(converter);
    }

    @Test
    public void missingPersistentPdfFallsBackToConverter() throws Exception {
        byte[] convertedBytes = "%PDF-1.7 converted".getBytes(java.nio.charset.StandardCharsets.UTF_8);
        DmsFileDownloadTicket payload = payload(60_000L);
        DmsPersistentPdfSource pdf = new DmsPersistentPdfSource();
        pdf.setObjectKey("dms-derived/pdf/018f0000/missing.pdf");
        pdf.setSizeBytes(123L);
        pdf.setSourceChecksumSha256("a".repeat(64));
        payload.setPdfSource(pdf);
        FileStorageService storage = storage(payload);
        when(storage.exists(any(FileInfo.class))).thenReturn(false);
        DmsDownloadPdfApi converter = mock(DmsDownloadPdfApi.class);
        ActionResult<byte[]> result = new ActionResult<>();
        result.setCode(200);
        result.setData(convertedBytes);
        when(converter.render(any())).thenReturn(result);
        DmsPersistentPdfRecoveryReporter reporter = mock(DmsPersistentPdfRecoveryReporter.class);
        DmsFileDownloadStorageService service = new DmsFileDownloadStorageService(storage,
                ticket -> JsonUtil.getObjectToString(payload), mock(DmsFileWatermarkService.class),
                converter, reporter);
        org.springframework.mock.web.MockHttpServletResponse response =
                new org.springframework.mock.web.MockHttpServletResponse();

        service.stream(VERSION_ID, "ticket", "pdf", response);

        assertArrayEquals(convertedBytes, response.getContentAsByteArray());
        verify(converter).render(new DmsDownloadPdfRequest(VERSION_ID, "ticket"));
        verify(reporter).report(payload, "持久化 PDF 对象不存在");
    }

    @Test
    public void conversionFailureDoesNotReturnOriginalOrCommitPdfHeaders() {
        DmsFileDownloadTicket payload = payload(60_000L);
        FileStorageService storage = storage(payload);
        DmsDownloadPdfApi converter = mock(DmsDownloadPdfApi.class);
        ActionResult<byte[]> failed = new ActionResult<>();
        failed.setCode(400);
        failed.setMsg("指定页水印生成失败");
        when(converter.render(any())).thenReturn(failed);
        DmsFileDownloadStorageService service = new DmsFileDownloadStorageService(storage,
                ticket -> JsonUtil.getObjectToString(payload), mock(DmsFileWatermarkService.class), converter);
        org.springframework.mock.web.MockHttpServletResponse response =
                new org.springframework.mock.web.MockHttpServletResponse();
        try {
            service.stream(VERSION_ID, "ticket", "pdf", response);
            fail("expected conversion error");
        } catch (DataException expected) {
            assertEquals("指定页水印生成失败", expected.getMessage());
        }
        assertEquals(0, response.getContentAsByteArray().length);
        assertEquals(null, response.getHeader("Content-Disposition"));
        verify(storage, never()).download(any(FileInfo.class));
    }

    @Test
    public void rejectsUnsupportedFormatAndSourcesBeforeConversion() {
        DmsDownloadPdfApi converter = mock(DmsDownloadPdfApi.class);
        FileStorageService storage = mock(FileStorageService.class);
        DmsFileDownloadTicket payload = payload(60_000L);
        for (String[] input : new String[][]{{"quality.docx", "xlsx"}, {"quality.txt", "pdf"}}) {
            payload.setFileName(input[0]);
            DmsFileDownloadStorageService service = new DmsFileDownloadStorageService(storage,
                    ticket -> JsonUtil.getObjectToString(payload), mock(DmsFileWatermarkService.class), converter);
            try {
                service.stream(VERSION_ID, "ticket", input[1], mock(HttpServletResponse.class));
                fail("expected unsupported format");
            } catch (DataException expected) {
                assertTrue(expected.getMessage().contains("支持"));
            }
        }
        org.mockito.Mockito.verifyNoInteractions(storage, converter);
    }

    @Test
    public void omittedFormatStreamsOriginalBytesWithoutConversion() throws Exception {
        DmsFileDownloadTicket payload = payload(60_000L);
        byte[] original = new byte[]{80, 75, 3, 4};
        payload.setSizeBytes((long) original.length);
        assertOriginalStream(payload, original, null);
        payload.setFileName("existing.pdf");
        payload.setMimeType("application/pdf");
        assertOriginalStream(payload, original, "pdf");
    }

    private void assertOriginalStream(DmsFileDownloadTicket payload, byte[] original, String format) throws Exception {
        FileStorageService storage = storage(payload);
        Class<?> downloaderType = FileStorageService.class.getMethod("download", FileInfo.class).getReturnType();
        Object downloader = mock(downloaderType, invocation -> {
            if ("outputStream".equals(invocation.getMethod().getName())) {
                ((OutputStream) invocation.getArgument(0)).write(original);
            }
            return null;
        });
        when(storage.download(any(FileInfo.class))).thenAnswer(invocation -> downloader);
        DmsDownloadPdfApi converter = mock(DmsDownloadPdfApi.class);
        DmsFileDownloadStorageService service = new DmsFileDownloadStorageService(storage,
                ticket -> JsonUtil.getObjectToString(payload), mock(DmsFileWatermarkService.class), converter);
        org.springframework.mock.web.MockHttpServletResponse response =
                new org.springframework.mock.web.MockHttpServletResponse();
        service.stream(VERSION_ID, "ticket", format, response);
        assertArrayEquals(original, response.getContentAsByteArray());
        assertEquals(payload.getMimeType(), response.getContentType());
        assertEquals(payload.getFileName(), org.springframework.http.ContentDisposition
                .parse(response.getHeader("Content-Disposition")).getFilename());
        org.mockito.Mockito.verifyNoInteractions(converter);
    }

    private FileStorageService storage(DmsFileDownloadTicket payload) {
        FileStorageService service = mock(FileStorageService.class);
        MinioFileStorage storage = mock(MinioFileStorage.class);
        when(storage.getBucketName()).thenReturn(payload.getBucketName());
        when(service.getFileStorageVerify(payload.getStoragePlatform())).thenReturn(storage);
        return service;
    }

    private DmsFileDownloadTicket payload(long expiresInMillis) {
        DmsFileDownloadTicket payload = new DmsFileDownloadTicket();
        payload.setScope(DmsFileDownloadTicket.SCOPE);
        payload.setTenantId("tenant-1");
        payload.setUserId("user-1");
        payload.setFileVersionId(VERSION_ID);
        payload.setFileName("quality-manual.docx");
        payload.setMimeType("application/vnd.openxmlformats-officedocument.wordprocessingml.document");
        payload.setSizeBytes(2048L);
        payload.setStoragePlatform("seaweedfs-1");
        payload.setBucketName("jnpf-dms");
        payload.setBasePath("dms/");
        payload.setObjectPath("2026/08/24/document/");
        payload.setObjectName("quality-manual-v1.docx");
        payload.setExpiresAt(System.currentTimeMillis() + expiresInMillis);
        return payload;
    }
}