import pytest
from unittest.mock import patch, MagicMock, AsyncMock
import sys
import os

# Dodanie katalogu nadrzędnego do ścieżki dla importów
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))

from src.openai_utils import summarize_text


@pytest.mark.asyncio
async def test_summarize_text_success():
    # Przygotowanie mocka dla odpowiedzi OpenAI
    mock_choice = MagicMock()
    mock_message = MagicMock()
    
    mock_message.content = "To jest przykładowe streszczenie filmu."
    mock_choice.message = mock_message
    
    mock_response = MagicMock()
    mock_response.choices = [mock_choice]
    
    # Testowy tekst transkrypcji
    test_transcript = "To jest przykładowa transkrypcja filmu YouTube, " \
                     "która zostanie wysłana do API OpenAI w celu streszczenia. " \
                     "Zawiera kilka zdań o różnej tematyce."
    
    # Test funkcji z mockiem
    with patch('src.openai_utils.client.chat.completions.create', 
              new=AsyncMock(return_value=mock_response)) as mock_create:
        result = await summarize_text(test_transcript)
        
        # Sprawdzenie wyników
        assert result == "To jest przykładowe streszczenie filmu."
        assert mock_create.called
        
        # Sprawdzenie czy parametry zostały przekazane poprawnie
        call_args = mock_create.call_args[1]
        assert call_args['model'] == "gpt-3.5-turbo"
        assert call_args['temperature'] == 0.5
        assert call_args['max_tokens'] == 150
        
        # Sprawdzenie wiadomości
        messages = call_args['messages']
        assert len(messages) == 2
        assert messages[0]['role'] == "system"
        assert messages[1]['role'] == "user"
        assert test_transcript in messages[1]['content']  # Sprawdzenie czy transkrypcja jest w prompcie


@pytest.mark.asyncio
async def test_summarize_text_with_transcript_from_youtube():
    # Przygotowanie mocka dla odpowiedzi OpenAI
    mock_choice = MagicMock()
    mock_message = MagicMock()
    
    mock_message.content = "Film przedstawia dyskusję na temat sztucznej inteligencji i jej zastosowań w życiu codziennym."
    mock_choice.message = mock_message
    
    mock_response = MagicMock()
    mock_response.choices = [mock_choice]
    
    # Przykładowa transkrypcja z YouTube
    youtube_transcript = "To jest przykładowa transkrypcja z YouTube. " \
                        "Zawiera dyskusję o sztucznej inteligencji. " \
                        "Przedstawia różne zastosowania AI w codziennym życiu."
    
    # Test funkcji
    with patch('src.openai_utils.client.chat.completions.create', 
              new=AsyncMock(return_value=mock_response)) as mock_create:
        result = await summarize_text(youtube_transcript)
        
        # Sprawdzenie wyników
        assert result == "Film przedstawia dyskusję na temat sztucznej inteligencji i jej zastosowań w życiu codziennym."
        assert mock_create.called


@pytest.mark.asyncio
async def test_summarize_empty_text():
    # Test funkcji z pustym tekstem
    with patch('src.openai_utils.client.chat.completions.create') as mock_create:
        result = await summarize_text("")
        
        # Sprawdzenie wyników
        assert result is None
        assert not mock_create.called


@pytest.mark.asyncio
async def test_summarize_text_api_error():
    # Symulacja błędu API
    with patch('src.openai_utils.client.chat.completions.create', 
              new=AsyncMock(side_effect=Exception("API Error"))) as mock_create:
        # Test funkcji
        result = await summarize_text("Jakiś tekst transkrypcji")
        
        # Sprawdzenie wyników
        assert result is None
        assert mock_create.called


@pytest.mark.asyncio
async def test_summarize_text_prompt_format():
    # Przygotowanie mocka
    mock_choice = MagicMock()
    mock_message = MagicMock()
    
    mock_message.content = "Streszczenie"
    mock_choice.message = mock_message
    
    mock_response = MagicMock()
    mock_response.choices = [mock_choice]
    
    # Testowy tekst
    test_transcript = "Testowa transkrypcja"
    
    # Przygotowanie spy do przechwycenia argumentów
    with patch('src.openai_utils.client.chat.completions.create', 
              new=AsyncMock(return_value=mock_response)) as mock_create:
        # Test funkcji
        await summarize_text(test_transcript)
        
        # Sprawdzenie czy został wywołany
        assert mock_create.called
        
        # Pobranie argumentów wywołania
        call_args = mock_create.call_args[1]
        messages = call_args['messages']
        
        # Sprawdzenie czy prompt zawiera odpowiedni format
        user_prompt = messages[1]['content']
        assert "Streść poniższy transkrypt filmu z YouTube" in user_prompt
        assert "Transkrypt:" in user_prompt
        assert test_transcript in user_prompt