package jnpf.bizcommon.onlyoffice.service.impl;

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.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.AtomicReference;

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 OnlyOfficeTemplatePublishFenceServiceTest {

    private OnlyOfficeSessionMapper mapper;
    private OnlyOfficeTemplatePublishFenceService service;

    @Before
    public void setUp() {
        TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""),
                OnlyOfficeSessionEntity.class);
        mapper = mock(OnlyOfficeSessionMapper.class);
        service = new OnlyOfficeTemplatePublishFenceService(mapper);
    }

    @Test
    public void idleSessionCanBeAtomicallyClaimedForPublishing() {
        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", "template-1", "template.docx", "annex");

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

    @Test
    public void missingSessionIsInsertedDirectlyAsPublishing() {
        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", "template-1", "template.docx", "annex");

        assertEquals("tenant-1", inserted.get().getTenantId());
        assertEquals("template-1", inserted.get().getBizDataId());
        assertEquals("template.docx", inserted.get().getFileId());
        assertEquals("annex", inserted.get().getFileType());
        assertEquals(Integer.valueOf(OnlyOfficeSessionEntity.SessionStatus.PUBLISHING),
                inserted.get().getSessionStatus());
        assertEquals(token, inserted.get().getPublishToken());
        assertNull(inserted.get().getLockUserId());
    }

    @Test
    public void editingSavingFailedAndPublishingSessionsRejectPublishFence() {
        int[] blocked = {
                OnlyOfficeSessionEntity.SessionStatus.EDITING,
                OnlyOfficeSessionEntity.SessionStatus.SAVING,
                OnlyOfficeSessionEntity.SessionStatus.SAVE_FAILED,
                OnlyOfficeSessionEntity.SessionStatus.PUBLISHING
        };
        for (int status : blocked) {
            when(mapper.selectOne(any())).thenReturn(session(status));
            expectDataException(() -> service.acquire(
                    "tenant-1", "template-1", "template.docx", "annex"));
        }
        verify(mapper, never()).update(isNull(), any());
    }

    @Test
    public void concurrentInsertConflictIsRereadAndRejectedWithoutSecondRow() {
        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", "template-1", "template.docx", "annex"));
    }

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

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

        release.get().getSqlSegment();
        assertTrue(release.get().getParamNameValuePairs().containsValue("token-1"));
        assertTrue(release.get().getParamNameValuePairs().containsValue(
                OnlyOfficeSessionEntity.SessionStatus.PUBLISHING));
        assertTrue(release.get().getSqlSet().contains("session_status"));
        assertTrue(release.get().getSqlSet().contains("publish_token"));

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

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

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