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.PlatformQualificationPublishStatusRequest;
import com.tcm.training.admin.system.dto.PlatformQualificationSaveRequest;
import com.tcm.training.admin.system.entity.PlatformQualification;
import com.tcm.training.admin.system.mapper.PlatformQualificationMapper;
import com.tcm.training.admin.system.vo.PlatformQualificationDetailVO;
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.time.LocalDateTime;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
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 PlatformQualificationAppServiceTest {

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

    @Mock
    private PlatformQualificationMapper platformQualificationMapper;

    @InjectMocks
    private PlatformQualificationAppService platformQualificationAppService;

    @Captor
    private ArgumentCaptor<PlatformQualification> platformQualificationCaptor;

    @Test
    void createShouldPersistRichTextQualification() {
        doAnswer(invocation -> {
            PlatformQualification item = invocation.getArgument(0);
            item.setId(1L);
            return 1;
        }).when(platformQualificationMapper).insert(any(PlatformQualification.class));

        PlatformQualification persisted = new PlatformQualification();
        persisted.setId(1L);
        persisted.setQualificationName("增值电信业务经营许可证");
        persisted.setQualificationType(PlatformQualification.TYPE_RICH_TEXT);
        persisted.setRecordNumber("1654156");
        persisted.setContentHtml("<p>资质内容</p>");
        persisted.setSort(99);
        persisted.setPublishEnabled(1);
        persisted.setCreatedAt(LocalDateTime.of(2026, 3, 26, 21, 10, 0));
        when(platformQualificationMapper.selectOne(any())).thenReturn(persisted);

        PlatformQualificationSaveRequest request = new PlatformQualificationSaveRequest();
        request.setQualificationName("  增值电信业务经营许可证  ");
        request.setQualificationType("rich_text");
        request.setRecordNumber(" 1654156 ");
        request.setContentHtml("<p>资质内容</p>");
        request.setSort(99);
        request.setPublishEnabled(true);

        PlatformQualificationDetailVO result = platformQualificationAppService.create(request);

        verify(platformQualificationMapper).insert(platformQualificationCaptor.capture());
        assertEquals("增值电信业务经营许可证", platformQualificationCaptor.getValue().getQualificationName());
        assertEquals("1654156", platformQualificationCaptor.getValue().getRecordNumber());
        assertEquals("<p>资质内容</p>", platformQualificationCaptor.getValue().getContentHtml());
        assertNull(platformQualificationCaptor.getValue().getLinkUrl());
        assertEquals("增值电信业务经营许可证", result.getQualificationName());
    }

    @Test
    void createShouldPersistLinkQualification() {
        doAnswer(invocation -> {
            PlatformQualification item = invocation.getArgument(0);
            item.setId(2L);
            return 1;
        }).when(platformQualificationMapper).insert(any(PlatformQualification.class));

        PlatformQualification persisted = new PlatformQualification();
        persisted.setId(2L);
        persisted.setQualificationName("营业执照");
        persisted.setQualificationType(PlatformQualification.TYPE_LINK);
        persisted.setRecordNumber("ICP-2026");
        persisted.setLinkUrl("https://example.com/license");
        persisted.setSort(10);
        persisted.setPublishEnabled(0);
        when(platformQualificationMapper.selectOne(any())).thenReturn(persisted);

        PlatformQualificationSaveRequest request = new PlatformQualificationSaveRequest();
        request.setQualificationName("营业执照");
        request.setQualificationType("LINK");
        request.setRecordNumber("ICP-2026");
        request.setLinkUrl(" https://example.com/license ");
        request.setSort(10);
        request.setPublishEnabled(false);

        platformQualificationAppService.create(request);

        verify(platformQualificationMapper).insert(platformQualificationCaptor.capture());
        assertEquals(PlatformQualification.TYPE_LINK, platformQualificationCaptor.getValue().getQualificationType());
        assertEquals("https://example.com/license", platformQualificationCaptor.getValue().getLinkUrl());
        assertNull(platformQualificationCaptor.getValue().getContentHtml());
    }

    @Test
    void createShouldRejectBlankRichTextContent() {
        PlatformQualificationSaveRequest request = new PlatformQualificationSaveRequest();
        request.setQualificationName("活动资质");
        request.setQualificationType("RICH_TEXT");
        request.setRecordNumber("A-001");
        request.setContentHtml("<p><br/></p>");
        request.setSort(1);
        request.setPublishEnabled(true);

        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
                () -> platformQualificationAppService.create(request));

        assertEquals("请输入资质内容", exception.getMessage());
    }

    @Test
    void createShouldRejectEmptyLinkUrl() {
        PlatformQualificationSaveRequest request = new PlatformQualificationSaveRequest();
        request.setQualificationName("活动资质");
        request.setQualificationType("LINK");
        request.setRecordNumber("A-001");
        request.setLinkUrl("   ");
        request.setSort(1);
        request.setPublishEnabled(true);

        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
                () -> platformQualificationAppService.create(request));

        assertEquals("请输入跳转链接", exception.getMessage());
    }

    @Test
    void patchPublishStatusShouldUpdateFlag() {
        PlatformQualification persisted = new PlatformQualification();
        persisted.setId(3L);
        persisted.setQualificationName("备案资质");
        persisted.setQualificationType(PlatformQualification.TYPE_LINK);
        persisted.setRecordNumber("A-002");
        persisted.setLinkUrl("https://example.com");
        persisted.setSort(2);
        persisted.setPublishEnabled(0);
        when(platformQualificationMapper.selectOne(any())).thenReturn(persisted);

        PlatformQualificationPublishStatusRequest request = new PlatformQualificationPublishStatusRequest();
        request.setPublishEnabled(true);

        platformQualificationAppService.patchPublishStatus(3L, request);

        verify(platformQualificationMapper).updateById(platformQualificationCaptor.capture());
        assertEquals(Integer.valueOf(1), platformQualificationCaptor.getValue().getPublishEnabled());
    }
}