package com.waterquality.service;

import com.waterquality.entity.WaterQualityStation;
import com.waterquality.repository.WaterQualityStationRepository;
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 java.time.LocalDateTime;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;

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

@ExtendWith(MockitoExtension.class)
public class WaterQualityServiceTest {
    
    @Mock
    private WaterQualityStationRepository stationRepository;
    
    @InjectMocks
    private WaterQualityServiceImpl waterQualityService;
    
    private WaterQualityStation station;
    
    @BeforeEach
    void setUp() {
        station = new WaterQualityStation();
        station.setId(1L);
        station.setStationName("测试站点");
        station.setLocation("精河县");
        station.setStationType("WQ-01");
        station.setDescription("测试站点描述");
        station.setIsActive(true);
        station.setCreatedAt(LocalDateTime.now());
        station.setUpdatedAt(LocalDateTime.now());
    }
    
    @Test
    void createStation_ShouldCreateSuccessfully() {
        when(stationRepository.save(any(WaterQualityStation.class))).thenReturn(station);
        
        WaterQualityStation result = waterQualityService.createStation(station);
        
        assertNotNull(result);
        assertEquals("测试站点", result.getStationName());
        verify(stationRepository, times(1)).save(any(WaterQualityStation.class));
    }
    
    @Test
    void createStation_ShouldThrowExceptionWhenStationTypeIsNull() {
        station.setStationType(null);
        
        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
            waterQualityService.createStation(station);
        });
        
        assertEquals("Station type is required", exception.getMessage());
        verify(stationRepository, never()).save(any(WaterQualityStation.class));
    }
    
    @Test
    void updateStation_ShouldUpdateSuccessfully() {
        when(stationRepository.findById(1L)).thenReturn(Optional.of(station));
        when(stationRepository.save(any(WaterQualityStation.class))).thenReturn(station);
        
        station.setStationName("更新后的站点名称");
        WaterQualityStation result = waterQualityService.updateStation(1L, station);
        
        assertNotNull(result);
        assertEquals("更新后的站点名称", result.getStationName());
        verify(stationRepository, times(1)).findById(1L);
        verify(stationRepository, times(1)).save(any(WaterQualityStation.class));
    }
    
    @Test
    void updateStation_ShouldThrowExceptionWhenStationNotFound() {
        when(stationRepository.findById(1L)).thenReturn(Optional.empty());
        
        RuntimeException exception = assertThrows(RuntimeException.class, () -> {
            waterQualityService.updateStation(1L, station);
        });
        
        assertEquals("Station not found: 1", exception.getMessage());
        verify(stationRepository, times(1)).findById(1L);
        verify(stationRepository, never()).save(any(WaterQualityStation.class));
    }
    
    @Test
    void deleteStation_ShouldDeleteSuccessfully() {
        when(stationRepository.findById(1L)).thenReturn(Optional.of(station));
        
        waterQualityService.deleteStation(1L);
        
        assertFalse(station.getIsActive());
        verify(stationRepository, times(1)).findById(1L);
        verify(stationRepository, times(1)).save(any(WaterQualityStation.class));
    }
    
    @Test
    void getAllActiveStations_ShouldReturnActiveStations() {
        List<WaterQualityStation> activeStations = Arrays.asList(station);
        when(stationRepository.findByIsActiveTrue()).thenReturn(activeStations);
        
        List<WaterQualityStation> result = waterQualityService.getAllActiveStations();
        
        assertEquals(1, result.size());
        assertEquals("测试站点", result.get(0).getStationName());
        verify(stationRepository, times(1)).findByIsActiveTrue();
    }
    
    @Test
    void getStationsByType_ShouldReturnStationsByType() {
        when(stationRepository.findByStationType("WQ-01")).thenReturn(Arrays.asList(station));
        
        List<WaterQualityStation> result = waterQualityService.getStationsByType("WQ-01");
        
        assertEquals(1, result.size());
        assertEquals("WQ-01", result.get(0).getStationType());
        verify(stationRepository, times(1)).findByStationType("WQ-01");
    }
    
    @Test
    void getStationById_ShouldReturnStation() {
        when(stationRepository.findById(1L)).thenReturn(Optional.of(station));
        
        WaterQualityStation result = waterQualityService.getStationById(1L);
        
        assertNotNull(result);
        assertEquals("测试站点", result.getStationName());
        verify(stationRepository, times(1)).findById(1L);
    }
    
    @Test
    void getStationById_ShouldThrowExceptionWhenNotFound() {
        when(stationRepository.findById(1L)).thenReturn(Optional.empty());
        
        RuntimeException exception = assertThrows(RuntimeException.class, () -> {
            waterQualityService.getStationById(1L);
        });
        
        assertEquals("Station not found: 1", exception.getMessage());
        verify(stationRepository, times(1)).findById(1L);
    }
    
    @Test
    void searchStations_ShouldReturnStationsByLocation() {
        when(stationRepository.findByLocationContaining("精河")).thenReturn(Arrays.asList(station));
        
        List<WaterQualityStation> result = waterQualityService.searchStations("精河");
        
        assertEquals(1, result.size());
        assertEquals("精河县", result.get(0).getLocation());
        verify(stationRepository, times(1)).findByLocationContaining("精河");
    }
}