"""Check every returned factual claim against the independent raw-source oracle.

Gold bindings define required coverage; this check also rejects false extras.
It does not use graph construction, query predictions or expected gold values.
"""
from __future__ import annotations

from functools import lru_cache
from .source_oracle import load_source_oracle, norm


@lru_cache(maxsize=1)
def default_oracle():
    return load_source_oracle()


def claim_issues(claim: dict, oracle: dict, *, published_only: bool = True) -> list[str]:
    names = {norm(name): name for name in oracle['people']}
    name = names.get(norm(claim.get('person')))
    if name is None:
        return ['unknown_person']
    person = oracle['people'][name]
    issues = []
    if claim.get('start_year') is not None and claim['start_year'] != person.get('start_year'):
        issues.append('unsupported_start_year')
    path = claim.get('document_path')
    documents = [p for p in person.get('documents', []) if path is None or p == path]
    if path and not documents:
        issues.append('document_belongs_to_other_person')
    documents = [p for p in documents if not published_only or oracle['documents'][p].get('published', True)]
    if path and not documents:
        issues.append('missing_or_unpublished_source')
    if claim.get('source_url') and not any(oracle['documents'][p]['source_url'] == claim['source_url'] for p in documents):
        issues.append('incorrect_source_url')
    metadata = {k: claim[k] for k in ['keyword','category','document_author'] if claim.get(k) is not None}
    def supported(p, k, value):
        d=oracle['documents'][p]
        values = d['tags'] if k=='keyword' else d['categories'] if k=='category' else [d['author']]
        return norm(value) in {norm(v) for v in values}
    if metadata and not any(all(supported(p,k,v) for k,v in metadata.items()) for p in documents):
        issues.append('unsupported_metadata_on_document')
    academic = {k: claim[k] for k in ['title','year','academic_type','academic_kind'] if claim.get(k) is not None}
    if academic and not any(
        all(norm(record.get(k)) == norm(v) for k,v in academic.items())
        and (not path or record['document_path']==path)
        for record in person.get('academics', [])
    ):
        issues.append('unsupported_academic_record')
    return issues


def validate_returned_facts(result: dict, oracle: dict) -> dict:
    failures = []
    published_only = result.get('constraints', {}).get('published_only', True)
    for index, row in enumerate(result.get('facts', [])):
        kind=row.get('fact_type') if isinstance(row, dict) else None
        claims=[]; issues=[]
        if kind in {'person_thesis','person_work'}:
            claims=[{**row,'academic_kind':'Thesis' if kind=='person_thesis' else 'Work',
                     'academic_type':row.get('thesis_type') if kind=='person_thesis' else row.get('work_type')}]
        elif kind in {'person_keyword','person_category','person_document_author','person_start_year','person_academic_year'}:
            claims=[row]
        elif kind in {'shared_keyword','shared_category','shared_document_author'}:
            field={'shared_keyword':'keyword','shared_category':'category','shared_document_author':'document_author'}[kind]
            claims=[{'person':row.get(side+'_person'),field:row.get(field),
                     'document_path':row.get(side+'_document_path'),'source_url':row.get(side+'_source_url')}
                    for side in ['left','right']]
        elif kind in {'academic_year_comparison','start_year_comparison'}:
            names={norm(n):n for n in oracle['people']}
            people=[names.get(norm(n)) for n in row.get('people', [])]
            if not people or any(n is None for n in people):
                issues.append('invalid_comparison_people')
            elif kind=='academic_year_comparison':
                sets=[{r['year'] for r in oracle['people'][n]['academics'] if r.get('year') is not None} for n in people]
                years=sorted(set.intersection(*sets))
                if row.get('shared_years')!=years or row.get('same_academic_year') != bool(years):
                    issues.append('incorrect_shared_academic_years')
            else:
                years={oracle['people'][n].get('start_year') for n in people}
                same=len(years)==1 and None not in years
                expected={norm(n):oracle['people'][n].get('start_year') for n in people}
                actual={norm(n):year for n,year in row.get('start_years',{}).items()}
                if actual != expected:
                    issues.append('incorrect_individual_start_years')
                if row.get('same_start_year') != same or row.get('shared_start_year') != (next(iter(years)) if same else None):
                    issues.append('incorrect_shared_start_year')
        else:
            issues.append('unsupported_fact_type')
        for claim in claims:
            issues.extend(claim_issues(claim,oracle,published_only=published_only))
        if issues:
            failures.append({'fact_index':index,'fact_type':kind,'issues':sorted(set(issues))})
    return {'source_checked':True,'all_facts_supported':not failures,'unsupported_facts':failures}