package jnpf.bizcommon.onlyoffice.service.impl;

import cn.hutool.crypto.digest.DigestUtil;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import jnpf.bizcommon.onlyoffice.entity.OnlyOfficeProperties;
import jnpf.bizcommon.onlyoffice.entity.OnlyOfficeSessionEntity;
import jnpf.bizcommon.onlyoffice.mapper.OnlyOfficeSessionMapper;
import jnpf.exception.DataException;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.Before;
import org.junit.Test;
import org.springframework.dao.DuplicateKeyException;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.Date;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
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.ArgumentMatchers.isNull;
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 OnlyOfficeRecordRevisionFenceServiceTest {

    private OnlyOfficeSessionMapper mapper;
    private OnlyOfficeFreezeCancellationStore cancellationStore;
    private OnlyOfficeRecordRevisionFenceService service;
    private OnlyOfficeProperties properties;

    @Before
    public void setUp() {
        TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""),
                OnlyOfficeSessionEntity.class);
        mapper = mock(OnlyOfficeSessionMapper.class);
        cancellationStore = mock(OnlyOfficeFreezeCancellationStore.class);
        properties = new OnlyOfficeProperties();
        properties.setLockTimeoutMinutes(30);
        service = new OnlyOfficeRecordRevisionFenceService(mapper, cancellationStore, properties);
    }

    @Test
    public void idleRecordSessionCanBeAtomicallyClaimedForRetirement() {
        OnlyOfficeSessionEntity existing = session(OnlyOfficeSessionEntity.SessionStatus.IDLE);
        when(mapper.selectOne(any())).thenReturn(existing);
        AtomicReference<UpdateWrapper<OnlyOfficeSessionEntity>> update = new AtomicReference<>();
        when(mapper.update(isNull(), any())).thenAnswer(invocation -> {
            update.set(invocation.getArgument(1));
            return 1;
        });

        String token = service.acquire("tenant-1", "record-1", "record.docx", "annex");

        assertNotNull(token);
        assertFalse(token.trim().isEmpty());
        update.get().getSqlSegment();
        assertTrue(update.get().getParamNameValuePairs().containsValue(
                OnlyOfficeSessionEntity.SessionStatus.IDLE));
        assertTrue(update.get().getParamNameValuePairs().containsValue(token));
        assertTrue(update.get().getSqlSet().contains("session_status"));
        assertTrue(update.get().getSqlSet().contains("publish_token"));
    }

    @Test
    public void missingSessionIsInsertedDirectlyAsRetiring() {
        when(mapper.selectOne(any())).thenReturn(null);
        AtomicReference<OnlyOfficeSessionEntity> inserted = new AtomicReference<>();
        when(mapper.insert(any(OnlyOfficeSessionEntity.class))).thenAnswer(invocation -> {
            inserted.set(invocation.getArgument(0));
            return 1;
        });

        String token = service.acquire("tenant-1", "record-1", "record.docx", "annex");

        assertEquals("tenant-1", inserted.get().getTenantId());
        assertEquals("record-1", inserted.get().getBizDataId());
        assertEquals("eln.record", inserted.get().getBizModule());
        assertEquals(Integer.valueOf(OnlyOfficeSessionEntity.SessionStatus.RECORD_RETIRING),
                inserted.get().getSessionStatus());
        assertEquals(token, inserted.get().getPublishToken());
        assertNull(inserted.get().getLockUserId());
    }

    @Test
    public void callerOperationCanRetryAcquireWithoutReplacingItsExistingFence() {
        OnlyOfficeSessionEntity existing = session(OnlyOfficeSessionEntity.SessionStatus.RECORD_RETIRING);
        existing.setBizModule("eln.record");
        existing.setBizDataId("record-1");
        existing.setPublishToken("freeze:operation-1");
        when(mapper.selectOne(any())).thenReturn(existing);

        String token = service.acquireForOperation(
                "tenant-1", "record-1", "record.docx", "annex", "operation-1");

        assertEquals("freeze:operation-1", token);
        verify(mapper, never()).update(isNull(), any());
        verify(mapper, never()).insert(any(OnlyOfficeSessionEntity.class));
    }

    @Test
    public void releaseBeforeAcquirePersistsCancellationAndPreventsLateFence() {
        AtomicReference<OnlyOfficeSessionEntity> inserted = new AtomicReference<>();
        when(mapper.selectOne(any())).thenAnswer(invocation -> inserted.get());
        when(mapper.insert(any(OnlyOfficeSessionEntity.class))).thenAnswer(invocation -> {
            inserted.set(invocation.getArgument(0));
            return 1;
        });
        when(mapper.update(isNull(), any())).thenReturn(0);

        assertTrue(service.release("tenant-1", "record-1", "record.docx", "annex",
                "freeze:operation-1"));
        assertEquals(Integer.valueOf(OnlyOfficeSessionEntity.SessionStatus.IDLE),
                inserted.get().getSessionStatus());
        assertEquals("cancelled:freeze:operation-1", inserted.get().getPublishToken());
        expectDataException(() -> service.acquireForOperation(
                "tenant-1", "record-1", "record.docx", "annex", "operation-1"));
    }

    @Test
    public void releaseLosesIdleCasThenReleasesFenceWonByConcurrentAcquire() {
        OnlyOfficeSessionEntity idle = session(OnlyOfficeSessionEntity.SessionStatus.IDLE);
        OnlyOfficeSessionEntity retiring = session(OnlyOfficeSessionEntity.SessionStatus.RECORD_RETIRING);
        retiring.setPublishToken("freeze:operation-1");
        when(mapper.selectOne(any())).thenReturn(idle, retiring);
        AtomicInteger updates = new AtomicInteger();
        when(mapper.update(isNull(), any())).thenAnswer(invocation -> updates.incrementAndGet() == 3 ? 1 : 0);

        assertTrue(service.release("tenant-1", "record-1", "record.docx", "annex",
                "freeze:operation-1"));
        assertEquals(3, updates.get());
    }

    @Test
    public void cancellationStoreBlocksLateAcquireAfterAnotherSessionBecomesIdle() {
        OnlyOfficeSessionEntity editing = session(OnlyOfficeSessionEntity.SessionStatus.EDITING);
        when(mapper.selectOne(any())).thenReturn(editing);
        when(mapper.update(isNull(), any())).thenReturn(0);

        assertTrue(service.release("tenant-1", "record-1", "record.docx", "annex",
                "freeze:operation-1"));
        verify(cancellationStore).cancel("tenant-1", "record-1", "record.docx",
                "annex", "freeze:operation-1");

        when(cancellationStore.isCancelled("tenant-1", "record-1", "record.docx",
                "annex", "freeze:operation-1")).thenReturn(true);
        expectDataException(() -> service.acquireForOperation(
                "tenant-1", "record-1", "record.docx", "annex", "operation-1"));
    }

    @Test
    public void cancellationArrivingAfterIdleCasReleasesTheJustAcquiredFence() {
        when(mapper.selectOne(any())).thenReturn(session(OnlyOfficeSessionEntity.SessionStatus.IDLE));
        when(mapper.update(isNull(), any())).thenReturn(1);
        when(cancellationStore.isCancelled("tenant-1", "record-1", "record.docx",
                "annex", "freeze:operation-1")).thenReturn(false, false, true);

        expectDataException(() -> service.acquireForOperation(
                "tenant-1", "record-1", "record.docx", "annex", "operation-1"));

        org.mockito.Mockito.verify(mapper, org.mockito.Mockito.times(2)).update(isNull(), any());
    }

    @Test
    public void nonIdleSessionsRejectRevisionFence() {
        OnlyOfficeSessionEntity activeEditing = session(OnlyOfficeSessionEntity.SessionStatus.EDITING);
        activeEditing.setLockUserId("user-1");
        activeEditing.setLockHeartbeat(new Date());
        int[] blocked = {
                OnlyOfficeSessionEntity.SessionStatus.SAVING,
                OnlyOfficeSessionEntity.SessionStatus.SAVE_FAILED,
                OnlyOfficeSessionEntity.SessionStatus.PUBLISHING,
                OnlyOfficeSessionEntity.SessionStatus.RECORD_RETIRING,
                OnlyOfficeSessionEntity.SessionStatus.RECORD_HISTORICAL
        };
        when(mapper.selectOne(any())).thenReturn(activeEditing);
        expectDataException(() -> service.acquire(
                "tenant-1", "record-1", "record.docx", "annex"));
        for (int status : blocked) {
            when(mapper.selectOne(any())).thenReturn(session(status));
            expectDataException(() -> service.acquire(
                    "tenant-1", "record-1", "record.docx", "annex"));
        }
        verify(mapper, never()).update(isNull(), any());
    }

    @Test
    public void expiredEditingSessionCanBeAtomicallyClaimedForRetirement() {
        OnlyOfficeSessionEntity expired = session(OnlyOfficeSessionEntity.SessionStatus.EDITING);
        expired.setLockUserId("user-1");
        expired.setLockHeartbeat(new Date(System.currentTimeMillis() - 31L * 60L * 1000L));
        when(mapper.selectOne(any())).thenReturn(expired);
        AtomicReference<UpdateWrapper<OnlyOfficeSessionEntity>> update = new AtomicReference<>();
        when(mapper.update(isNull(), any())).thenAnswer(invocation -> {
            update.set(invocation.getArgument(1));
            return 1;
        });

        String token = service.acquire("tenant-1", "record-1", "record.docx", "annex");

        assertNotNull(token);
        update.get().getSqlSegment();
        assertTrue(update.get().getParamNameValuePairs().containsValue(
                OnlyOfficeSessionEntity.SessionStatus.EDITING));
        assertTrue(update.get().getSqlSet().contains("session_status"));
        assertTrue(update.get().getSqlSet().contains("lock_heartbeat"));
    }

    @Test
    public void concurrentFirstOpenIsRereadAndRejected() {
        when(mapper.selectOne(any())).thenReturn(null,
                session(OnlyOfficeSessionEntity.SessionStatus.EDITING));
        when(mapper.insert(any(OnlyOfficeSessionEntity.class)))
                .thenThrow(new DuplicateKeyException("duplicate file"));

        expectDataException(() -> service.acquire(
                "tenant-1", "record-1", "record.docx", "annex"));
    }

    @Test
    public void completeAndReleaseRequireTheExactRetiringToken() {
        AtomicReference<UpdateWrapper<OnlyOfficeSessionEntity>> finish = new AtomicReference<>();
        when(mapper.update(isNull(), any())).thenAnswer(invocation -> {
            finish.set(invocation.getArgument(1));
            return 1;
        });

        assertTrue(service.complete(
                "tenant-1", "record-1", "record.docx", "annex", "token-1"));
        finish.get().getSqlSegment();
        assertTrue(finish.get().getParamNameValuePairs().containsValue("token-1"));
        assertTrue(finish.get().getParamNameValuePairs().containsValue(
                OnlyOfficeSessionEntity.SessionStatus.RECORD_RETIRING));
        assertTrue(finish.get().getSqlSet().contains("session_status"));
        assertTrue(finish.get().getSqlSet().contains("publish_token"));

        assertTrue(service.release(
                "tenant-1", "record-1", "record.docx", "annex", "token-2"));

        when(mapper.update(isNull(), any(Wrapper.class))).thenReturn(0);
        assertFalse(service.complete(
                "tenant-1", "record-1", "record.docx", "annex", "old-token"));
    }

    @Test
    public void documentUpdateReleaseRotatesTheOnlyOfficeDocumentKey() {
        OnlyOfficeSessionEntity existing = session(
                OnlyOfficeSessionEntity.SessionStatus.RECORD_RETIRING);
        existing.setPublishToken("token-1");
        when(mapper.selectOne(any())).thenReturn(existing);
        AtomicReference<UpdateWrapper<OnlyOfficeSessionEntity>> update =
                new AtomicReference<>();
        when(mapper.update(isNull(), any())).thenAnswer(invocation -> {
            update.set(invocation.getArgument(1));
            return 1;
        });

        assertTrue(service.releaseAfterDocumentUpdate(
                "tenant-1", "record-1", "record.docx", "annex", "token-1"));

        update.get().getSqlSegment();
        assertTrue(update.get().getSqlSet().contains("version_no"));
        assertTrue(update.get().getSqlSet().contains("doc_key"));
        assertTrue(update.get().getSqlSet().contains("last_save_time"));
        assertTrue(update.get().getParamNameValuePairs().containsValue(2));
        assertTrue(update.get().getParamNameValuePairs().containsValue(
                DigestUtil.md5Hex("record.docx_2")));
        assertTrue(update.get().getParamNameValuePairs().containsValue(
                OnlyOfficeSessionEntity.SessionStatus.IDLE));
    }

    private static OnlyOfficeSessionEntity session(int status) {
        OnlyOfficeSessionEntity session = new OnlyOfficeSessionEntity();
        session.setId("session-1");
        session.setTenantId("tenant-1");
        session.setFileId("record.docx");
        session.setFileType("annex");
        session.setBizModule("eln.record");
        session.setBizDataId("record-1");
        session.setDocKey("doc-key-1");
        session.setVersionNo(1);
        session.setVersion(3);
        session.setSessionStatus(status);
        return session;
    }

    private static void expectDataException(Runnable action) {
        try {
            action.run();
            fail("预期抛出 DataException");
        } catch (DataException expected) {
            assertFalse(expected.getMessage().trim().isEmpty());
        }
    }
}