package com.tcm.training.admin.system.service;

import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.tcm.training.admin.system.dto.AgreementContentSaveRequest;
import com.tcm.training.admin.system.entity.AgreementContent;
import com.tcm.training.admin.system.mapper.AgreementContentMapper;
import com.tcm.training.admin.system.vo.AgreementContentItemVO;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import java.util.Collections;
import java.util.List;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class)
class AgreementContentAppServiceTest {

    @BeforeAll
    static void initLambdaCache() {
        MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
        TableInfoHelper.initTableInfo(assistant, AgreementContent.class);
    }

    @Mock
    private AgreementContentMapper agreementContentMapper;

    @InjectMocks
    private AgreementContentAppService agreementContentAppService;

    @Captor
    private ArgumentCaptor<AgreementContent> agreementContentCaptor;

    @Test
    void listShouldAlwaysReturnThreeAgreements() {
        AgreementContent record = new AgreementContent();
        record.setAgreementType(AgreementContent.TYPE_PRIVACY_POLICY);
        record.setContentHtml("<p>隐私协议内容</p>");
        when(agreementContentMapper.selectList(any())).thenReturn(Collections.singletonList(record));

        List<AgreementContentItemVO> result = agreementContentAppService.list();

        assertEquals(3, result.size());
        assertEquals(AgreementContent.TYPE_USER_AGREEMENT, result.get(0).getAgreementType());
        assertEquals("", result.get(0).getContentHtml());
        assertEquals(AgreementContent.TYPE_PRIVACY_POLICY, result.get(1).getAgreementType());
        assertEquals("<p>隐私协议内容</p>", result.get(1).getContentHtml());
        assertEquals(AgreementContent.TYPE_INVITE_CODE_INSTRUCTIONS, result.get(2).getAgreementType());
    }

    @Test
    void saveShouldInsertWhenAgreementDoesNotExist() {
        when(agreementContentMapper.selectOne(any())).thenReturn(null);
        doAnswer(invocation -> {
            AgreementContent record = invocation.getArgument(0);
            record.setId(1L);
            return 1;
        }).when(agreementContentMapper).insert(any(AgreementContent.class));

        AgreementContentSaveRequest request = new AgreementContentSaveRequest();
        request.setContentHtml("<p>用户协议内容</p>");

        AgreementContentItemVO result = agreementContentAppService.save("user_agreement", request);

        verify(agreementContentMapper).insert(agreementContentCaptor.capture());
        assertEquals(AgreementContent.TYPE_USER_AGREEMENT, agreementContentCaptor.getValue().getAgreementType());
        assertEquals("<p>用户协议内容</p>", agreementContentCaptor.getValue().getContentHtml());
        assertEquals("用户协议", result.getAgreementName());
    }

    @Test
    void saveShouldUpdateWhenAgreementExists() {
        AgreementContent record = new AgreementContent();
        record.setId(2L);
        record.setAgreementType(AgreementContent.TYPE_PRIVACY_POLICY);
        record.setContentHtml("<p>旧内容</p>");
        when(agreementContentMapper.selectOne(any())).thenReturn(record);

        AgreementContentSaveRequest request = new AgreementContentSaveRequest();
        request.setContentHtml("<p>新内容</p>");

        agreementContentAppService.save(AgreementContent.TYPE_PRIVACY_POLICY, request);

        verify(agreementContentMapper).updateById(agreementContentCaptor.capture());
        assertEquals("<p>新内容</p>", agreementContentCaptor.getValue().getContentHtml());
    }

    @Test
    void saveShouldRejectBlankContent() {
        AgreementContentSaveRequest request = new AgreementContentSaveRequest();
        request.setContentHtml("<p><br/></p>");

        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
                () -> agreementContentAppService.save(AgreementContent.TYPE_USER_AGREEMENT, request));

        assertEquals("请输入协议内容", exception.getMessage());
    }

    @Test
    void saveShouldRejectIllegalAgreementType() {
        AgreementContentSaveRequest request = new AgreementContentSaveRequest();
        request.setContentHtml("<p>内容</p>");

        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
                () -> agreementContentAppService.save("UNKNOWN", request));

        assertEquals("协议类型不合法", exception.getMessage());
    }
}