"""Optional real Cypher regressions; all fixtures are rolled back."""
from __future__ import annotations

import os
import uuid

import pytest

from tools.graphrag import graph_search as gs
from tools.graphrag.graph_db import create_neo4j_driver, get_neo4j_settings

pytestmark = pytest.mark.skipif(os.getenv('RUN_NEO4J_TESTS') != '1', reason='Set RUN_NEO4J_TESTS=1 for isolated Neo4j regressions.')


@pytest.fixture
def graph(monkeypatch):
    scope = 'regression-' + uuid.uuid4().hex
    monkeypatch.setattr(gs, 'GRAPH_SCOPE', scope)
    category = 'regcat-' + uuid.uuid4().hex
    settings = get_neo4j_settings()
    with create_neo4j_driver(settings) as driver, driver.session(database=settings.database) as session:
        tx = session.begin_transaction()
        try:
            for suffix, name, year, tag in [('a', 'Alena Nová', 2024, 'alpha'),
                                             ('b', 'Boris Iný', 2024, 'beta'),
                                             ('c', 'Cyril Malý', 2025, 'alpha')]:
                tx.run('CREATE (p:Person {id:$id, name:$name, source_document:$path, graph_scope:$scope}) '
                       'CREATE (d:Document {path:$path, source_url:$url, graph_scope:$scope}) '
                       'CREATE (t:Thesis {id:$thesis, title:$title, year:$year, thesis_type:"bachelor_thesis", graph_scope:$scope}) '
                       'MERGE (k:Keyword {id:$keyword, name:$tag, graph_scope:$scope}) '
                       'CREATE (p)-[:HAS_DOCUMENT]->(d)-[:HAS_KEYWORD]->(k) '
                       'CREATE (p)-[:AUTHORED]->(t)-[:EVIDENCED_BY]->(d)',
                       id=scope+suffix, name=name, path=scope+'/'+suffix+'.md',
                       url='https://example.test/'+suffix, scope=scope, thesis=scope+'th'+suffix,
                       title='Výskum '+suffix, year=year, keyword=scope+tag, tag=tag).consume()
            tx.run('MATCH (p:Person {id:$person})-[:HAS_DOCUMENT]->(d) '
                   'CREATE (c:Category {name:$category, graph_scope:$scope}) '
                   'CREATE (a:DocumentAuthor {id:$author, name:"Autor Správny", graph_scope:$scope}) '
                   'CREATE (d)-[:IN_CATEGORY]->(c) CREATE (a)-[:AUTHORED_DOCUMENT]->(d) '
                   'CREATE (child:Document {path:$child, graph_scope:$scope}) '
                   'CREATE (wrong:DocumentAuthor {id:$wrong, name:"Autor Iný", graph_scope:$scope}) '
                   'CREATE (p)-[:HAS_DOCUMENT]->(child)<-[:AUTHORED_DOCUMENT]-(wrong)',
                   person=scope+'a', category=category, scope=scope, author=scope+'author',
                   child=scope+'/child.md', wrong=scope+'wrong').consume()
            yield tx, category
        finally:
            tx.rollback()


def test_real_keyword_year_conjunction(graph):
    tx, _ = graph
    result = gs.search_graph_with_session(tx,
        'Ktorá z osôb Alena Nová a Boris Iný má kľúčové slovo alpha a jej práca je v roku 2024?')
    assert {r['person'] for r in result['facts'] if r['fact_type'] == 'person_thesis'} == {'Alena Nová'}
    assert {r['person'] for r in result['facts'] if r['fact_type'] == 'person_keyword'} == {'Alena Nová'}


def test_real_count_and_rejected_candidate_provenance(graph):
    tx, _ = graph
    result = gs.search_graph_with_session(tx,
        'Z kandidátov Alena Nová, Boris Iný, Cyril Malý vyber osoby s prácou v roku 2024. Koľko ich je?')
    assert result['aggregation'] == {'count': 2, 'people': ['Alena Nová', 'Boris Iný'], 'candidate_count': 3, 'complete': True}
    assert 'https://example.test/c' in {r['source_url'] for r in result['documents']}


def test_real_author_and_category_must_share_document(graph):
    tx, category = graph
    result = gs.search_graph_with_session(tx, f'Ktorý autor dokumentu je pri osobe Alena Nová spojený s kategóriou {category}?')
    authors = [r['document_author'] for r in result['facts'] if r['fact_type'] == 'person_document_author']
    assert authors == ['Autor Správny']


def test_real_shared_year_does_not_invent_intersection(graph):
    tx, _ = graph
    result = gs.search_graph_with_session(tx, 'V ktorom rovnakom roku je práca pri osobách Alena Nová a Cyril Malý?')
    assert not any(r['fact_type'] in {'person_thesis', 'person_work'} for r in result['facts'])
    assert next(r for r in result['facts'] if r['fact_type'] == 'academic_year_comparison')['shared_years'] == []


def test_real_shared_keyword_uses_requested_keyword(graph):
    tx, _ = graph
    result = gs.search_graph_with_session(tx,
        'Sú osoby Alena Nová a Cyril Malý prepojené cez kľúčové slovo alpha? Uveď spoločné kľúčové slovo.')
    assert [r['keyword'] for r in result['facts'] if r['fact_type'] == 'shared_keyword'] == ['alpha']


def test_real_unknown_keyword_is_not_a_global_listing(graph):
    tx, _ = graph
    result = gs.search_graph_with_session(tx, 'Aký názov práce má Alena Nová, ak má kľúčové slovo missingtag?')
    assert result['facts'] == []


@pytest.mark.parametrize('question', [
    'V ktorom rovnakom roku je práca pri osobách Alena Nová a Boris Iný?',
    'Aký rok práce spája osoby Alena Nová a Boris Iný?',
])
def test_real_shared_year_paraphrases_have_same_answer(graph, question):
    tx, _ = graph
    result = gs.search_graph_with_session(tx, question)
    assert next(r for r in result['facts'] if r['fact_type'] == 'academic_year_comparison')['shared_years'] == [2024]
    assert {r['year'] for r in result['facts'] if r['fact_type'] == 'person_thesis'} == {2024}


def test_real_title_and_keyword_are_both_returned(graph):
    tx, _ = graph
    result = gs.search_graph_with_session(tx,
        'Aký je názov práce osoby Alena Nová, ak jej dokument obsahuje kľúčové slovo alpha?')
    assert [(r['person'], r['title']) for r in result['facts'] if r['fact_type'] == 'person_thesis'] == [('Alena Nová', 'Výskum a')]
    assert [r['keyword'] for r in result['facts'] if r['fact_type'] == 'person_keyword'] == ['alpha']


def test_real_count_is_not_cut_off_by_presentation_limit(graph):
    tx, _ = graph
    result = gs.search_graph_with_session(tx,
        'Z kandidátov Alena Nová, Boris Iný, Cyril Malý vyber osoby s prácou v roku 2024. Koľko ich je?', limit=1)
    assert result['aggregation']['count'] == 2
    assert len(result['facts']) == 1
    assert result['truncated']