package com.example.service;

import com.example.exception.GeminiClientException;
import com.example.service.base.GeminiClientService;
import com.google.genai.Client;
import com.google.genai.errors.GenAiIOException;
import com.google.genai.types.Content;
import com.google.genai.types.GenerateContentConfig;
import com.google.genai.types.GenerateContentResponse;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Answers;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import java.io.IOException;

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.ArgumentMatchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class)
class GeminiClientServiceTest {


@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Client geminiClient;

@InjectMocks
private GeminiClientService geminiClientService;

private String prompt;
private Float temperature;
private Integer maxOutputTokens;
private String modelName;
private Float top_P;

@BeforeEach
void setUp() {
        prompt = "Test prompt";
        temperature = 0.5f;
        maxOutputTokens = 100;
        modelName = "gemini-test-model";
        top_P=0.85f;

}

@Test
void generateContent_whenApiSucceeds_returnsGeneratedText() throws GeminiClientException {
        // Arrange
        String expectedText = "This is the generated content.";
        GenerateContentResponse mockResponse = mock(GenerateContentResponse.class);
        when(mockResponse.text()).thenReturn(expectedText);
        when(geminiClient.models.generateContent(anyString(), any(Content.class), any(GenerateContentConfig.class)))
                .thenReturn(mockResponse);

        String actualText = geminiClientService.generateContent(prompt, temperature, maxOutputTokens, modelName,top_P);
        assertEquals(expectedText, actualText);
}

@Test
void generateContent_whenApiResponseIsNull_throwsGeminiClientException() {
        // Arrange
        when(geminiClient.models.generateContent(anyString(), any(Content.class), any(GenerateContentConfig.class)))
                .thenReturn(null);

        GeminiClientException exception = assertThrows(GeminiClientException.class, () ->
                geminiClientService.generateContent(prompt, temperature, maxOutputTokens, modelName,top_P)
        );

        assertEquals("No content generated or unexpected response structure.", exception.getMessage());
}

@Test
void generateContent_whenResponseTextIsNull_throwsGeminiClientException() {
        GenerateContentResponse mockResponse = mock(GenerateContentResponse.class);
        when(mockResponse.text()).thenReturn(null);
        when(geminiClient.models.generateContent(anyString(), any(Content.class), any(GenerateContentConfig.class)))
                .thenReturn(mockResponse);

        GeminiClientException exception = assertThrows(GeminiClientException.class, () ->
                geminiClientService.generateContent(prompt, temperature, maxOutputTokens, modelName,top_P)
        );

        assertEquals("No content generated or unexpected response structure.", exception.getMessage());
}

@Test
void generateContent_whenGenAiIOExceptionOccurs_throwsGeminiClientException() {
        // Arrange
        String errorMessage = "Network issue";
        when(geminiClient.models.generateContent(anyString(), any(Content.class), any(GenerateContentConfig.class)))
                .thenThrow(new GenAiIOException(errorMessage, new IOException()));

        GeminiClientException exception = assertThrows(GeminiClientException.class, () ->
                geminiClientService.generateContent(prompt, temperature, maxOutputTokens, modelName,top_P)
        );

        assertTrue(exception.getMessage().startsWith("An API communication issue occurred:"));
        assertTrue(exception.getMessage().contains(errorMessage));
}

@Test
void generateContent_whenUnexpectedExceptionOccurs_throwsGeminiClientException() {
        when(geminiClient.models.generateContent(anyString(), any(Content.class), any(GenerateContentConfig.class)))
                .thenThrow(new RuntimeException("Something went wrong"));

        GeminiClientException exception = assertThrows(GeminiClientException.class, () ->
                geminiClientService.generateContent(prompt, temperature, maxOutputTokens, modelName,top_P)
        );

        assertEquals("An unexpected issue occurred during content generation.", exception.getMessage());
}
}