visualize_results.py

"""
Visualization helper for LiabilityIQ results.
Creates simple text-based visualizations of claim processing results.
"""
import os
import json
import glob
from typing import List, Dict

try:
    import matplotlib.pyplot as plt
    MATPLOTLIB_AVAILABLE = True
except ImportError:
    MATPLOTLIB_AVAILABLE = False
    print("Note: matplotlib not available. Text-only visualizations will be used.")


def load_dossiers(output_dir: str = "output") -> List[Dict]:
    """Load all dossier markdown files and extract key metrics."""
    dossiers = []
    
    dossier_files = glob.glob(os.path.join(output_dir, "dossier_*.md"))
    
    for file_path in dossier_files:
        claim_id = os.path.basename(file_path).replace("dossier_", "").replace(".md", "")
        
        # Parse markdown to extract key metrics (simplified)
        with open(file_path, 'r', encoding='utf-8') as f:
            content = f.read()
            
            # Extract readiness index
            readiness_match = None
            for line in content.split('\n'):
                if 'Overall Readiness:' in line:
                    try:
                        readiness_str = line.split(':')[1].strip().split('/')[0]
                        readiness_match = float(readiness_str)
                        break
                    except:
                        pass
            
            # Extract confidence level
            confidence_match = "Unknown"
            for line in content.split('\n'):
                if 'Confidence Level:' in line:
                    confidence_match = line.split(':')[1].strip()
                    break
            
            # Count gaps, conflicts, risks
            gaps_count = content.count('### GAP-')
            conflicts_count = content.count('### CONF-')
            risks_count = content.count('### RISK-')
            
            dossiers.append({
                'claim_id': claim_id,
                'readiness_index': readiness_match or 0,
                'confidence_level': confidence_match,
                'gaps': gaps_count,
                'conflicts': conflicts_count,
                'risks': risks_count,
            })
    
    return dossiers


def print_summary_table(dossiers: List[Dict]):
    """Print a summary table of all claims."""
    print("\n" + "=" * 100)
    print("CLAIM PROCESSING SUMMARY")
    print("=" * 100)
    print(f"{'Claim ID':<15} {'Readiness':<12} {'Confidence':<12} {'Gaps':<8} {'Conflicts':<10} {'Risks':<8}")
    print("-" * 100)
    
    for dossier in dossiers:
        print(f"{dossier['claim_id']:<15} "
              f"{dossier['readiness_index']:>6.1f}/100   "
              f"{dossier['confidence_level']:<12} "
              f"{dossier['gaps']:<8} "
              f"{dossier['conflicts']:<10} "
              f"{dossier['risks']:<8}")
    
    print("=" * 100)
    
    # Summary statistics
    if dossiers:
        avg_readiness = sum(d['readiness_index'] for d in dossiers) / len(dossiers)
        total_gaps = sum(d['gaps'] for d in dossiers)
        total_conflicts = sum(d['conflicts'] for d in dossiers)
        total_risks = sum(d['risks'] for d in dossiers)
        
        print(f"\nSummary Statistics:")
        print(f"  Average Readiness Index: {avg_readiness:.1f}/100")
        print(f"  Total Gaps Identified: {total_gaps}")
        print(f"  Total Conflicts Detected: {total_conflicts}")
        print(f"  Total Risks Flagged: {total_risks}")
        print(f"  Claims Processed: {len(dossiers)}")


def create_readiness_chart(dossiers: List[Dict], output_path: str = "output/readiness_chart.png"):
    """Create a bar chart of readiness indices."""
    if not MATPLOTLIB_AVAILABLE:
        print("\nMatplotlib not available. Skipping chart generation.")
        return
    
    if not dossiers:
        print("No dossiers found to visualize.")
        return
    
    claim_ids = [d['claim_id'] for d in dossiers]
    readiness_scores = [d['readiness_index'] for d in dossiers]
    
    plt.figure(figsize=(10, 6))
    bars = plt.bar(claim_ids, readiness_scores, color=['green' if s >= 80 else 'orange' if s >= 60 else 'red' for s in readiness_scores])
    plt.xlabel('Claim ID')
    plt.ylabel('Readiness Index')
    plt.title('Claim Readiness Index Comparison')
    plt.ylim(0, 100)
    plt.grid(axis='y', alpha=0.3)
    
    # Add value labels on bars
    for bar, score in zip(bars, readiness_scores):
        plt.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 1,
                f'{score:.1f}', ha='center', va='bottom')
    
    # Add threshold lines
    plt.axhline(y=80, color='green', linestyle='--', alpha=0.5, label='High Threshold')
    plt.axhline(y=60, color='orange', linestyle='--', alpha=0.5, label='Medium Threshold')
    plt.legend()
    
    plt.tight_layout()
    plt.savefig(output_path, dpi=150)
    print(f"\nChart saved to: {output_path}")


def main():
    """Main visualization function."""
    print("=" * 100)
    print("LiabilityIQ - Results Visualization")
    print("=" * 100)
    
    # Load dossiers
    print("\nLoading dossiers from output directory...")
    dossiers = load_dossiers()
    
    if not dossiers:
        print("No dossiers found. Please run demo.py first to generate dossiers.")
        return
    
    print(f"Loaded {len(dossiers)} dossiers")
    
    # Print summary table
    print_summary_table(dossiers)
    
    # Create chart if matplotlib is available
    if MATPLOTLIB_AVAILABLE:
        create_readiness_chart(dossiers)
    
    print("\n" + "=" * 100)
    print("Visualization Complete!")
    print("=" * 100)


if __name__ == "__main__":
    main()