package com.water.config;

import com.water.common.core.exception.BusinessException;
import com.water.config.entity.Announcement;
import com.water.config.mapper.AnnouncementMapper;
import com.water.config.service.AnnouncementService;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;

@ExtendWith(MockitoExtension.class)
class AnnouncementServiceTest {

    @Mock
    private AnnouncementMapper announcementMapper;
    @InjectMocks
    private AnnouncementService announcementService;

    private Announcement draft;

    @BeforeEach
    void setUp() {
        draft = new Announcement();
        draft.setTitle("系统维护通知");
        draft.setContent("今晚22:00-次日06:00系统维护");
        draft.setType(2);
        draft.setChannels("[\"site\",\"sms\"]");
    }

    @Test
    void createAnnouncement_setsDraftStatus() {
        when(announcementMapper.insert(any())).thenReturn(1);

        Announcement result = announcementService.createAnnouncement(draft);

        assertEquals(0, result.getPublishStatus());
        verify(announcementMapper).insert(any(Announcement.class));
    }

    @Test
    void publish_draft_success() {
        Announcement existing = new Announcement();
        existing.setId(1L);
        existing.setPublishStatus(0);
        existing.setChannels("[\"site\"]");

        when(announcementMapper.selectById(1L)).thenReturn(existing);
        when(announcementMapper.updateById(any())).thenReturn(1);

        assertDoesNotThrow(() -> announcementService.publish(1L));
        verify(announcementMapper).updateById(argThat(a ->
                a.getPublishStatus() == 1 && a.getPublishTime() != null));
    }

    @Test
    void publish_alreadyPublished_throws() {
        Announcement existing = new Announcement();
        existing.setId(1L);
        existing.setPublishStatus(1);

        when(announcementMapper.selectById(1L)).thenReturn(existing);

        BusinessException ex = assertThrows(BusinessException.class,
                () -> announcementService.publish(1L));
        assertEquals("只有草稿状态的公告可以发布", ex.getMessage());
    }

    @Test
    void withdraw_notPublished_throws() {
        Announcement existing = new Announcement();
        existing.setId(1L);
        existing.setPublishStatus(0);

        when(announcementMapper.selectById(1L)).thenReturn(existing);

        BusinessException ex = assertThrows(BusinessException.class,
                () -> announcementService.withdraw(1L));
        assertEquals("只有已发布的公告可以撤回", ex.getMessage());
    }

    @Test
    void delete_published_throws() {
        Announcement existing = new Announcement();
        existing.setId(1L);
        existing.setPublishStatus(1);

        when(announcementMapper.selectById(1L)).thenReturn(existing);

        BusinessException ex = assertThrows(BusinessException.class,
                () -> announcementService.deleteAnnouncement(1L));
        assertEquals("已发布的公告不可删除，请先撤回", ex.getMessage());
    }

    @Test
    void getAnnouncementStats_aggregatesByStatus() {
        when(announcementMapper.selectCount(any())).thenReturn(5L);

        java.util.Map<String, Object> stats = announcementService.getAnnouncementStats();

        assertEquals(5L, stats.get("total"));
        assertEquals(5L, stats.get("draft"));
        assertEquals(5L, stats.get("published"));
        assertEquals(5L, stats.get("withdrawn"));
    }
}