#!/usr/bin/env python3
"""
Building Existence Validator - Catch AI Hallucinations

Detects properties where GPT-3.5 gave high scores for building-dependent
criteria (Guest Accommodation, Workshop, Rental Units) but KPI data shows
no building exists (bedrooms=0 or None, building_size=0 or None).

This catches AI hallucinations like property 104459931 (empty land scoring 5/5 for Guest).
"""

import pandas as pd
import json
from pathlib import Path

def validate_building_scores(df):
    """
    Check if building-dependent scores are realistic given KPI data

    Returns:
        list of dict: Properties with suspicious scores
    """
    issues = []

    # Building-dependent criteria that require an actual building
    building_criteria = {
        'Guest Accommodation': 'guest_accommodation',
        'Workshop': 'workshop',
        'Rental Units': 'rental_units'
    }

    for idx, row in df.iterrows():
        url = row['URL']

        # Check if we have building indicators
        bedrooms = row.get('bedrooms')
        building_size = row.get('building_size')

        # Determine if building exists based on KPIs
        has_building = False
        building_evidence = []

        if pd.notna(bedrooms) and bedrooms > 0:
            has_building = True
            building_evidence.append(f"{int(bedrooms)} bedrooms")

        if pd.notna(building_size) and building_size > 0:
            has_building = True
            building_evidence.append(f"{building_size:.0f} m² building")

        # If we have KPI data but no building indicators
        if (pd.notna(bedrooms) or pd.notna(building_size)) and not has_building:
            # Check building-dependent scores
            suspicious_scores = []

            for criterion_name, criterion_key in building_criteria.items():
                score = row.get(criterion_name)
                if pd.notna(score) and score >= 3:
                    suspicious_scores.append({
                        'criterion': criterion_name,
                        'score': int(score),
                        'expected': '1-2 (no building)'
                    })

            if suspicious_scores:
                issues.append({
                    'url': url,
                    'title': row.get('Titel', 'Untitled'),
                    'land_size': row.get('land_size'),
                    'bedrooms': bedrooms if pd.notna(bedrooms) else 'Unknown',
                    'building_size': building_size if pd.notna(building_size) else 'Unknown',
                    'suspicious_scores': suspicious_scores,
                    'severity': 'HIGH' if any(s['score'] >= 4 for s in suspicious_scores) else 'MEDIUM'
                })

    return issues

def generate_report(issues):
    """Generate human-readable report"""
    if not issues:
        print("✅ No building existence issues found!")
        print("All building-dependent scores appear reasonable.")
        return

    print(f"\n{'='*80}")
    print(f"🚨 BUILDING EXISTENCE VALIDATION REPORT")
    print(f"{'='*80}\n")

    high_severity = [i for i in issues if i['severity'] == 'HIGH']
    medium_severity = [i for i in issues if i['severity'] == 'MEDIUM']

    print(f"Found {len(issues)} properties with suspicious building-dependent scores:")
    print(f"  🔴 HIGH severity: {len(high_severity)} (scores 4-5 with no building)")
    print(f"  🟡 MEDIUM severity: {len(medium_severity)} (scores 3 with no building)")
    print()

    for issue in issues:
        severity_icon = '🔴' if issue['severity'] == 'HIGH' else '🟡'
        print(f"{severity_icon} {issue['severity']} - {issue['title'][:60]}")
        print(f"   URL: {issue['url']}")
        print(f"   Land: {issue['land_size']} m² | Bedrooms: {issue['bedrooms']} | Building: {issue['building_size']} m²")
        print(f"   Suspicious Scores:")
        for score_issue in issue['suspicious_scores']:
            print(f"      • {score_issue['criterion']}: {score_issue['score']}/5 (expected {score_issue['expected']})")
        print()

    print(f"\n{'='*80}")
    print(f"💡 RECOMMENDATION")
    print(f"{'='*80}\n")
    print("These properties likely have AI hallucinations. The GPT model scored them highly")
    print("for building-dependent criteria despite no evidence of buildings in the KPI data.\n")
    print("Actions:")
    print("  1. Review these properties manually")
    print("  2. KPI validation in parse_criteria.py should have corrected these")
    print("  3. Consider improving GPT prompt with explicit 'IF NO BUILDING: score=1' rules")
    print()

def save_report_json(issues, output_file='building_validation_issues.json'):
    """Save issues to JSON for programmatic access"""
    with open(output_file, 'w') as f:
        json.dump(issues, f, indent=2)
    print(f"💾 Saved detailed report to {output_file}")

def main():
    print("🔍 Building Existence Validator")
    print("=" * 80)
    print()

    # Load data
    try:
        df = pd.read_csv('analysis_output.csv')
        print(f"✓ Loaded {len(df)} properties from analysis_output.csv")
    except FileNotFoundError:
        print("❌ analysis_output.csv not found!")
        print("Run the analysis pipeline first.")
        return

    # Validate
    print("\n🔍 Checking for building existence issues...")
    issues = validate_building_scores(df)

    # Generate report
    generate_report(issues)

    # Save to JSON
    if issues:
        save_report_json(issues)

    print("\n✅ Validation complete!")

    return issues

if __name__ == '__main__':
    main()