package com.tourguide.modules.user.service;

import com.tourguide.modules.operation.entity.OperationCity;
import com.tourguide.modules.operation.entity.OperationScenicSpot;
import com.tourguide.modules.operation.mapper.OperationCityMapper;
import com.tourguide.modules.operation.mapper.OperationScenicSpotMapper;
import com.tourguide.modules.user.dto.GuideScenicConfigResponse;
import com.tourguide.modules.user.entity.GuideScenicConfig;
import com.tourguide.modules.user.entity.GuideUser;
import com.tourguide.modules.user.mapper.GuideAutoDisableConfigMapper;
import com.tourguide.modules.user.mapper.GuideApplicationMapper;
import com.tourguide.modules.user.mapper.GuideScenicConfigMapper;
import com.tourguide.modules.user.mapper.GuideTeamMapper;
import com.tourguide.modules.user.mapper.GuideTeamScenicConfigMapper;
import com.tourguide.modules.user.mapper.GuideUserMapper;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.springframework.security.crypto.password.PasswordEncoder;

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

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

class GuideUserScenicConfigServiceTest {
    private GuideUserMapper userMapper;
    private GuideScenicConfigMapper scenicConfigMapper;
    private GuideTeamScenicConfigMapper teamScenicConfigMapper;
    private OperationScenicSpotMapper scenicSpotMapper;
    private OperationCityMapper cityMapper;
    private GuideUserService service;

    @BeforeEach
    void setUp() {
        userMapper = mock(GuideUserMapper.class);
        scenicConfigMapper = mock(GuideScenicConfigMapper.class);
        teamScenicConfigMapper = mock(GuideTeamScenicConfigMapper.class);
        scenicSpotMapper = mock(OperationScenicSpotMapper.class);
        cityMapper = mock(OperationCityMapper.class);
        service = new GuideUserService(
                userMapper,
                mock(GuideTeamMapper.class),
                mock(GuideApplicationMapper.class),
                teamScenicConfigMapper,
                scenicConfigMapper,
                mock(GuideAutoDisableConfigMapper.class),
                scenicSpotMapper,
                cityMapper,
                mock(PasswordEncoder.class));

        GuideUser guide = new GuideUser();
        guide.setId(12L);
        when(userMapper.selectById(12L)).thenReturn(guide);
    }

    @Test
    void addScenicConfigShouldUseEnabledOperationScenicData() {
        OperationScenicSpot scenicSpot = new OperationScenicSpot();
        scenicSpot.setId(21L);
        scenicSpot.setScenicName("青城山景区");
        scenicSpot.setCityId(31L);
        scenicSpot.setStatus(1);
        when(scenicSpotMapper.selectById(21L)).thenReturn(scenicSpot);

        OperationCity city = new OperationCity();
        city.setId(31L);
        city.setCityName("成都市");
        when(cityMapper.selectById(31L)).thenReturn(city);
        when(scenicConfigMapper.selectList(any())).thenAnswer(invocation -> {
            GuideScenicConfig saved = new GuideScenicConfig();
            saved.setId(41L);
            saved.setGuideId(12L);
            saved.setScenicName("青城山景区");
            saved.setCityName("成都市");
            return Collections.singletonList(saved);
        });

        List<GuideScenicConfigResponse> result = service.addScenicConfig(12L, 21L);

        ArgumentCaptor<GuideScenicConfig> captor = ArgumentCaptor.forClass(GuideScenicConfig.class);
        verify(scenicConfigMapper).upsert(captor.capture());
        assertThat(captor.getValue().getGuideId()).isEqualTo(12L);
        assertThat(captor.getValue().getScenicName()).isEqualTo("青城山景区");
        assertThat(captor.getValue().getCityName()).isEqualTo("成都市");
        assertThat(result).hasSize(1);
    }

    @Test
    void addScenicConfigShouldRejectDisabledScenicSpot() {
        OperationScenicSpot scenicSpot = new OperationScenicSpot();
        scenicSpot.setId(21L);
        scenicSpot.setStatus(0);
        when(scenicSpotMapper.selectById(21L)).thenReturn(scenicSpot);

        assertThatThrownBy(() -> service.addScenicConfig(12L, 21L))
                .hasMessage("景区不存在或未启用");
        verify(scenicConfigMapper, never()).upsert(any(GuideScenicConfig.class));
    }

    @Test
    void addScenicConfigShouldRejectScenicOutsideGuidesTeam() {
        GuideUser guide = new GuideUser();
        guide.setId(12L);
        guide.setTeamId(51L);
        when(userMapper.selectById(12L)).thenReturn(guide);

        OperationScenicSpot scenicSpot = new OperationScenicSpot();
        scenicSpot.setId(21L);
        scenicSpot.setScenicName("青城山景区");
        scenicSpot.setCityId(31L);
        scenicSpot.setStatus(1);
        when(scenicSpotMapper.selectById(21L)).thenReturn(scenicSpot);

        OperationCity city = new OperationCity();
        city.setId(31L);
        city.setCityName("成都市");
        when(cityMapper.selectById(31L)).thenReturn(city);

        assertThatThrownBy(() -> service.addScenicConfig(12L, 21L))
                .isInstanceOf(com.tourguide.common.exception.BusinessException.class)
                .hasMessage("只能配置所属讲解队下的景区");
        verify(scenicConfigMapper, never()).upsert(any(GuideScenicConfig.class));
    }

    @Test
    void deleteScenicConfigShouldRejectAnotherGuidesConfig() {
        GuideScenicConfig config = new GuideScenicConfig();
        config.setId(41L);
        config.setGuideId(99L);
        when(scenicConfigMapper.selectById(41L)).thenReturn(config);

        assertThatThrownBy(() -> service.deleteScenicConfig(12L, 41L))
                .hasMessage("导游景区配置不存在");
        verify(scenicConfigMapper, never()).deleteById(41L);
    }
}