"""Integration tests for analysis session endpoints."""

import pytest


@pytest.mark.integration
class TestAnalysisIntegration:
    """Integration tests for analysis session management."""

    def test_create_session_success(self, client, auth_headers, clean_test_sessions):
        """Test creating analysis session with real DB API."""
        session_data = {
            "environment": "ift",
            "api_mode": "bench",
            "request": [
                {"body": "Test question 1", "with_docs": True},
                {"body": "Test question 2", "with_docs": False}
            ],
            "response": {
                "answers": [
                    {"answer": "Test answer 1", "docs": []},
                    {"answer": "Test answer 2", "docs": []}
                ]
            },
            "annotations": {
                "duration_ms": 1234,
                "model": "test-model",
                "test_run": True
            }
        }

        response = client.post(
            "/api/v1/analysis/sessions",
            json=session_data,
            headers=auth_headers
        )

        assert response.status_code == 201

        data = response.json()
        assert "session_id" in data
        assert "user_id" in data
        assert data["environment"] == "ift"
        assert data["api_mode"] == "bench"
        assert len(data["request"]) == 2
        assert "created_at" in data
        assert "updated_at" in data

    def test_get_sessions_list(self, client, auth_headers, clean_test_sessions):
        """Test getting list of sessions."""
        # Create test sessions
        for env in ["ift", "psi", "prod"]:
            session_data = {
                "environment": env,
                "api_mode": "bench",
                "request": [{"body": f"Question for {env}"}],
                "response": {"answer": f"Answer for {env}"},
                "annotations": {}
            }
            client.post(
                "/api/v1/analysis/sessions",
                json=session_data,
                headers=auth_headers
            )

        # Get all sessions
        response = client.get("/api/v1/analysis/sessions", headers=auth_headers)

        assert response.status_code == 200

        data = response.json()
        assert "sessions" in data
        assert "total" in data
        assert data["total"] >= 3
        assert len(data["sessions"]) >= 3

        # Verify session structure
        for session in data["sessions"]:
            assert "session_id" in session
            assert "environment" in session
            assert "created_at" in session
            assert session["environment"] in ["ift", "psi", "prod"]

    def test_get_sessions_with_filter(self, client, auth_headers, clean_test_sessions):
        """Test filtering sessions by environment."""
        # Create sessions for different environments
        for env in ["ift", "psi"]:
            for i in range(2):
                session_data = {
                    "environment": env,
                    "api_mode": "bench",
                    "request": [{"body": f"Question {i}"}],
                    "response": {},
                    "annotations": {}
                }
                client.post(
                    "/api/v1/analysis/sessions",
                    json=session_data,
                    headers=auth_headers
                )

        # Filter by IFT
        response = client.get(
            "/api/v1/analysis/sessions?environment=ift",
            headers=auth_headers
        )

        assert response.status_code == 200

        data = response.json()
        assert data["total"] >= 2

        # All returned sessions should be IFT
        for session in data["sessions"]:
            assert session["environment"] == "ift"

    def test_get_sessions_pagination(self, client, auth_headers, clean_test_sessions):
        """Test session pagination."""
        # Create 5 test sessions
        for i in range(5):
            session_data = {
                "environment": "ift",
                "api_mode": "bench",
                "request": [{"body": f"Question {i}"}],
                "response": {},
                "annotations": {}
            }
            client.post(
                "/api/v1/analysis/sessions",
                json=session_data,
                headers=auth_headers
            )

        # Get first 3
        response = client.get(
            "/api/v1/analysis/sessions?limit=3&offset=0",
            headers=auth_headers
        )

        assert response.status_code == 200
        data = response.json()
        assert len(data["sessions"]) <= 3

        # Get next 3
        response = client.get(
            "/api/v1/analysis/sessions?limit=3&offset=3",
            headers=auth_headers
        )

        assert response.status_code == 200

    def test_get_session_by_id(self, client, auth_headers, clean_test_sessions):
        """Test getting specific session by ID."""
        # Create session
        session_data = {
            "environment": "psi",
            "api_mode": "backend",
            "request": [
                {"body": "Detailed question", "with_docs": True}
            ],
            "response": {
                "answer": "Detailed answer",
                "confidence": 0.95
            },
            "annotations": {
                "duration_ms": 5678,
                "tokens_used": 1234
            }
        }

        create_response = client.post(
            "/api/v1/analysis/sessions",
            json=session_data,
            headers=auth_headers
        )

        assert create_response.status_code == 201
        session_id = create_response.json()["session_id"]

        # Get session by ID
        get_response = client.get(
            f"/api/v1/analysis/sessions/{session_id}",
            headers=auth_headers
        )

        assert get_response.status_code == 200

        data = get_response.json()
        assert data["session_id"] == session_id
        assert data["environment"] == "psi"
        assert data["api_mode"] == "backend"
        assert data["request"][0]["body"] == "Detailed question"
        assert data["response"]["answer"] == "Detailed answer"
        assert data["annotations"]["duration_ms"] == 5678

    def test_delete_session(self, client, auth_headers, clean_test_sessions):
        """Test deleting a session."""
        # Create session
        session_data = {
            "environment": "prod",
            "api_mode": "bench",
            "request": [{"body": "To be deleted"}],
            "response": {},
            "annotations": {}
        }

        create_response = client.post(
            "/api/v1/analysis/sessions",
            json=session_data,
            headers=auth_headers
        )

        assert create_response.status_code == 201
        session_id = create_response.json()["session_id"]

        # Delete session
        delete_response = client.delete(
            f"/api/v1/analysis/sessions/{session_id}",
            headers=auth_headers
        )

        assert delete_response.status_code == 204

        # Verify deletion
        get_response = client.get(
            f"/api/v1/analysis/sessions/{session_id}",
            headers=auth_headers
        )

        assert get_response.status_code == 404

    def test_delete_nonexistent_session(self, client, auth_headers):
        """Test deleting non-existent session."""
        fake_session_id = "00000000-0000-0000-0000-000000000000"

        response = client.delete(
            f"/api/v1/analysis/sessions/{fake_session_id}",
            headers=auth_headers
        )

        assert response.status_code == 404

    def test_create_session_invalid_environment(self, client, auth_headers):
        """Test creating session with invalid environment."""
        session_data = {
            "environment": "invalid",  # Invalid
            "api_mode": "bench",
            "request": [],
            "response": {},
            "annotations": {}
        }

        response = client.post(
            "/api/v1/analysis/sessions",
            json=session_data,
            headers=auth_headers
        )

        # Should fail validation (either FastAPI or DB API)
        assert response.status_code in [400, 422]

    def test_sessions_require_authentication(self, client):
        """Test that session endpoints require authentication."""
        # Create without auth
        response = client.post(
            "/api/v1/analysis/sessions",
            json={"environment": "ift", "api_mode": "bench", "request": [], "response": {}, "annotations": {}}
        )
        assert response.status_code == 401

        # List without auth
        response = client.get("/api/v1/analysis/sessions")
        assert response.status_code == 401

        # Get by ID without auth
        response = client.get("/api/v1/analysis/sessions/some-id")
        assert response.status_code == 401

        # Delete without auth
        response = client.delete("/api/v1/analysis/sessions/some-id")
        assert response.status_code == 401

    def test_create_multiple_sessions_same_user(self, client, auth_headers, clean_test_sessions):
        """Test creating multiple sessions for same user."""
        session_ids = []

        for i in range(3):
            session_data = {
                "environment": "ift",
                "api_mode": "bench",
                "request": [{"body": f"Question {i}"}],
                "response": {"answer": f"Answer {i}"},
                "annotations": {"iteration": i}
            }

            response = client.post(
                "/api/v1/analysis/sessions",
                json=session_data,
                headers=auth_headers
            )

            assert response.status_code == 201
            session_ids.append(response.json()["session_id"])

        # Verify all sessions exist
        list_response = client.get("/api/v1/analysis/sessions", headers=auth_headers)
        assert list_response.status_code == 200
        assert list_response.json()["total"] >= 3

        # Verify each session is unique
        assert len(set(session_ids)) == 3

    def test_session_data_integrity(self, client, auth_headers, clean_test_sessions):
        """Test that session data is stored and retrieved without corruption."""
        complex_data = {
            "environment": "psi",
            "api_mode": "backend",
            "request": [
                {
                    "body": "Complex question with special chars: Привет! 你好 こんにちは",
                    "with_docs": True,
                    "metadata": {
                        "source": "test",
                        "priority": 1,
                        "tags": ["integration", "test", "unicode"]
                    }
                }
            ],
            "response": {
                "answer": "Complex answer with nested data",
                "confidence": 0.98,
                "sources": [
                    {"doc_id": "doc1", "relevance": 0.95},
                    {"doc_id": "doc2", "relevance": 0.87}
                ],
                "metadata": {
                    "model": "gpt-4",
                    "temperature": 0.7,
                    "tokens": {"prompt": 100, "completion": 200}
                }
            },
            "annotations": {
                "test_type": "integration",
                "special_chars": "!@#$%^&*()",
                "unicode": "Тест 测试 テスト",
                "nested": {
                    "level1": {
                        "level2": {
                            "value": "deep nested value"
                        }
                    }
                }
            }
        }

        # Create session
        create_response = client.post(
            "/api/v1/analysis/sessions",
            json=complex_data,
            headers=auth_headers
        )

        assert create_response.status_code == 201
        session_id = create_response.json()["session_id"]

        # Retrieve and verify
        get_response = client.get(
            f"/api/v1/analysis/sessions/{session_id}",
            headers=auth_headers
        )

        assert get_response.status_code == 200
        retrieved_data = get_response.json()

        # Verify complex data integrity
        assert "Привет" in retrieved_data["request"][0]["body"]
        assert retrieved_data["response"]["sources"][0]["doc_id"] == "doc1"
        assert retrieved_data["annotations"]["nested"]["level1"]["level2"]["value"] == "deep nested value"