import asyncio
from uuid import uuid4

from app.infra.db.postgresql.analysis import AnalysisRepository


class _FakeCursor:
    def __init__(self):
        self.calls = []

    async def __aenter__(self):
        return self

    async def __aexit__(self, exc_type, exc, tb):
        return False

    async def execute(self, query, params):
        self.calls.append((str(query), params))

    async def fetchall(self):
        return []


class _FakeConnection:
    def __init__(self):
        self.cursor_instance = _FakeCursor()

    def cursor(self):
        return self.cursor_instance


def test_list_results_uses_typed_comparison_when_result_type_is_present():
    conn = _FakeConnection()
    run_id = uuid4()

    asyncio.run(
        AnalysisRepository.list_results(conn, run_id, "leakage_identification")
    )

    query, params = conn.cursor_instance.calls[0]
    assert "result_type = %s" in query
    assert "%s IS NULL" not in query
    assert params == (run_id, "leakage_identification", 100, 0)


def test_list_results_omits_result_type_filter_when_not_requested():
    conn = _FakeConnection()
    run_id = uuid4()

    asyncio.run(AnalysisRepository.list_results(conn, run_id))

    query, params = conn.cursor_instance.calls[0]
    assert "result_type = %s" not in query
    assert params == (run_id, 100, 0)


def test_list_runs_and_results_apply_explicit_page_bounds():
    conn = _FakeConnection()
    run_id = uuid4()

    asyncio.run(AnalysisRepository.list_runs(conn, limit=25, offset=50))
    asyncio.run(
        AnalysisRepository.list_results(conn, run_id, limit=40, offset=80)
    )

    run_query, run_params = conn.cursor_instance.calls[0]
    result_query, result_params = conn.cursor_instance.calls[1]
    assert "LIMIT %s OFFSET %s" in run_query
    assert run_params == (25, 50)
    assert "LIMIT %s OFFSET %s" in result_query
    assert result_params == (run_id, 40, 80)


def test_list_recent_runs_is_bounded_and_orders_newest_first():
    conn = _FakeConnection()

    asyncio.run(AnalysisRepository.list_recent_runs(conn, limit=25))

    query, params = conn.cursor_instance.calls[0]
    assert "ORDER BY created_at DESC, run_id" in query
    assert "LIMIT %s" in query
    assert params == (25,)


def test_list_recent_results_bounds_latest_rows_then_restores_display_order():
    conn = _FakeConnection()
    run_id = uuid4()

    asyncio.run(AnalysisRepository.list_recent_results(conn, run_id, limit=25))

    query, params = conn.cursor_instance.calls[0]
    assert "ORDER BY created_at DESC, result_id DESC" in query
    assert "ORDER BY created_at, result_id" in query
    assert params == (run_id, 25)


def test_list_run_summaries_is_bounded_and_checks_for_results():
    conn = _FakeConnection()

    asyncio.run(AnalysisRepository.list_run_summaries(conn, limit=11, offset=20))

    query, params = conn.cursor_instance.calls[0]
    assert "EXISTS" in query
    assert "analysis.results" in query
    assert "ORDER BY r.created_at DESC, r.run_id" in query
    assert params == (11, 20)