#!/usr/bin/env python3
"""
Basic Quality Validation - Community Edition
AI Agentic Data Stack Framework - 3-Dimensional Quality Framework

This script demonstrates the core quality validation capabilities
available in the Community Edition:
- Completeness: Data availability validation
- Accuracy: Format and type checking  
- Consistency: Cross-reference validation
"""

import pandas as pd
import numpy as np
import re
from datetime import datetime
from typing import Dict, List, Any
from dataclasses import dataclass

@dataclass
class QualityResult:
    """Quality validation result"""
    dimension: str
    metric: str
    score: float
    threshold: float
    passed: bool
    details: str

class CommunityQualityFramework:
    """
    3-Dimensional Quality Framework for Community Edition
    
    Dimensions:
    1. Completeness - Data availability and coverage
    2. Accuracy - Data correctness and format validation  
    3. Consistency - Cross-system alignment and referential integrity
    """
    
    def __init__(self):
        self.quality_thresholds = {
            'completeness': {
                'customer_id': 100.0,
                'email': 95.0,
                'first_name': 90.0,
                'last_name': 90.0
            },
            'accuracy': {
                'email_format': 95.0,
                'customer_id_format': 100.0,
                'date_format': 95.0
            },
            'consistency': {
                'customer_id_unique': 100.0,
                'email_unique': 99.0
            }
        }
    
    def validate_customer_data(self, df: pd.DataFrame) -> Dict[str, Any]:
        """
        Validate customer data using 3-dimensional quality framework
        
        Args:
            df: Customer data DataFrame
            
        Returns:
            Dictionary with quality results and recommendations
        """
        print("🔍 Starting 3-Dimensional Quality Validation...")
        
        results = []
        
        # Dimension 1: Completeness
        completeness_results = self._validate_completeness(df)
        results.extend(completeness_results)
        
        # Dimension 2: Accuracy
        accuracy_results = self._validate_accuracy(df)
        results.extend(accuracy_results)
        
        # Dimension 3: Consistency
        consistency_results = self._validate_consistency(df)
        results.extend(consistency_results)
        
        # Calculate overall scores
        overall_score = self._calculate_overall_score(results)
        recommendations = self._generate_recommendations(results)
        
        return {
            'overall_score': overall_score,
            'dimension_scores': self._get_dimension_scores(results),
            'detailed_results': results,
            'recommendations': recommendations,
            'total_records': len(df),
            'validation_timestamp': datetime.now().isoformat()
        }
    
    def _validate_completeness(self, df: pd.DataFrame) -> List[QualityResult]:
        """Validate data completeness"""
        print("📊 Validating Completeness...")
        
        results = []
        
        for column, threshold in self.quality_thresholds['completeness'].items():
            if column in df.columns:
                # Calculate completeness percentage
                non_null_count = df[column].notna().sum()
                total_count = len(df)
                completeness_score = (non_null_count / total_count) * 100
                
                passed = completeness_score >= threshold
                
                result = QualityResult(
                    dimension='completeness',
                    metric=f'{column}_completeness',
                    score=completeness_score,
                    threshold=threshold,
                    passed=passed,
                    details=f'{non_null_count}/{total_count} records have non-null {column}'
                )
                results.append(result)
                
                print(f"   {column}: {completeness_score:.1f}% ({'✓' if passed else '✗'})")
        
        return results
    
    def _validate_accuracy(self, df: pd.DataFrame) -> List[QualityResult]:
        """Validate data accuracy"""
        print("🎯 Validating Accuracy...")
        
        results = []
        
        # Email format validation
        if 'email' in df.columns:
            email_pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
            valid_emails = df['email'].dropna().apply(
                lambda x: bool(re.match(email_pattern, str(x)))
            )
            accuracy_score = (valid_emails.sum() / len(valid_emails)) * 100
            threshold = self.quality_thresholds['accuracy']['email_format']
            
            passed = accuracy_score >= threshold
            
            result = QualityResult(
                dimension='accuracy',
                metric='email_format_accuracy',
                score=accuracy_score,
                threshold=threshold,
                passed=passed,
                details=f'{valid_emails.sum()}/{len(valid_emails)} emails have valid format'
            )
            results.append(result)
            
            print(f"   Email format: {accuracy_score:.1f}% ({'✓' if passed else '✗'})")
        
        # Customer ID format validation
        if 'customer_id' in df.columns:
            customer_id_pattern = r'^CUST_\d{6}$'
            valid_ids = df['customer_id'].dropna().apply(
                lambda x: bool(re.match(customer_id_pattern, str(x)))
            )
            accuracy_score = (valid_ids.sum() / len(valid_ids)) * 100
            threshold = self.quality_thresholds['accuracy']['customer_id_format']
            
            passed = accuracy_score >= threshold
            
            result = QualityResult(
                dimension='accuracy',
                metric='customer_id_format_accuracy',
                score=accuracy_score,
                threshold=threshold,
                passed=passed,
                details=f'{valid_ids.sum()}/{len(valid_ids)} customer IDs have valid format'
            )
            results.append(result)
            
            print(f"   Customer ID format: {accuracy_score:.1f}% ({'✓' if passed else '✗'})")
        
        return results
    
    def _validate_consistency(self, df: pd.DataFrame) -> List[QualityResult]:
        """Validate data consistency"""
        print("🔄 Validating Consistency...")
        
        results = []
        
        # Customer ID uniqueness
        if 'customer_id' in df.columns:
            unique_count = df['customer_id'].nunique()
            total_count = len(df['customer_id'].dropna())
            uniqueness_score = (unique_count / total_count) * 100 if total_count > 0 else 0
            threshold = self.quality_thresholds['consistency']['customer_id_unique']
            
            passed = uniqueness_score >= threshold
            
            result = QualityResult(
                dimension='consistency',
                metric='customer_id_uniqueness',
                score=uniqueness_score,
                threshold=threshold,
                passed=passed,
                details=f'{unique_count}/{total_count} customer IDs are unique'
            )
            results.append(result)
            
            print(f"   Customer ID uniqueness: {uniqueness_score:.1f}% ({'✓' if passed else '✗'})")
        
        # Email uniqueness
        if 'email' in df.columns:
            unique_count = df['email'].nunique()
            total_count = len(df['email'].dropna())
            uniqueness_score = (unique_count / total_count) * 100 if total_count > 0 else 0
            threshold = self.quality_thresholds['consistency']['email_unique']
            
            passed = uniqueness_score >= threshold
            
            result = QualityResult(
                dimension='consistency',
                metric='email_uniqueness',
                score=uniqueness_score,
                threshold=threshold,
                passed=passed,
                details=f'{unique_count}/{total_count} emails are unique'
            )
            results.append(result)
            
            print(f"   Email uniqueness: {uniqueness_score:.1f}% ({'✓' if passed else '✗'})")
        
        return results
    
    def _calculate_overall_score(self, results: List[QualityResult]) -> float:
        """Calculate overall quality score"""
        if not results:
            return 0.0
        
        total_score = sum(result.score for result in results)
        return total_score / len(results)
    
    def _get_dimension_scores(self, results: List[QualityResult]) -> Dict[str, float]:
        """Get scores by dimension"""
        dimension_scores = {}
        
        for dimension in ['completeness', 'accuracy', 'consistency']:
            dimension_results = [r for r in results if r.dimension == dimension]
            if dimension_results:
                score = sum(r.score for r in dimension_results) / len(dimension_results)
                dimension_scores[dimension] = score
            else:
                dimension_scores[dimension] = 0.0
        
        return dimension_scores
    
    def _generate_recommendations(self, results: List[QualityResult]) -> List[str]:
        """Generate quality improvement recommendations"""
        recommendations = []
        
        failed_results = [r for r in results if not r.passed]
        
        if not failed_results:
            recommendations.append("✅ All quality checks passed! Data meets community standards.")
            return recommendations
        
        for result in failed_results:
            if result.dimension == 'completeness':
                recommendations.append(f"📊 Improve {result.metric}: Current {result.score:.1f}% < {result.threshold}% threshold")
            elif result.dimension == 'accuracy':
                recommendations.append(f"🎯 Fix {result.metric}: Current {result.score:.1f}% < {result.threshold}% threshold")
            elif result.dimension == 'consistency':
                recommendations.append(f"🔄 Address {result.metric}: Current {result.score:.1f}% < {result.threshold}% threshold")
        
        # General recommendations
        recommendations.append("💡 Consider implementing automated data validation in your pipeline")
        recommendations.append("📈 Monitor quality metrics regularly to maintain standards")
        
        return recommendations

def demo_quality_validation():
    """Demonstrate quality validation with sample data"""
    
    print("🚀 AI Agentic Data Stack Framework - Community Edition")
    print("3-Dimensional Quality Validation Demo\n")
    
    # Create sample customer data with quality issues
    sample_data = {
        'customer_id': [
            'CUST_000001', 'CUST_000002', 'CUST_000003', 'CUST_000004', 
            'INVALID_ID', 'CUST_000006', None, 'CUST_000008'
        ],
        'email': [
            'john@example.com', 'jane@test.com', 'invalid-email', 
            'bob@company.co.uk', 'mary@site.org', None, 
            'duplicate@test.com', 'duplicate@test.com'
        ],
        'first_name': [
            'John', 'Jane', 'Alice', 'Bob', 'Mary', 'David', None, 'Sarah'
        ],
        'last_name': [
            'Doe', 'Smith', 'Johnson', 'Brown', None, 'Wilson', 'Davis', 'Miller'
        ],
        'registration_date': [
            '2023-01-15', '2023-02-20', '2023-03-10', '2023-04-05',
            '2023-05-12', '2023-06-18', '2023-07-22', '2023-08-30'
        ]
    }
    
    df = pd.DataFrame(sample_data)
    
    print(f"📋 Sample Dataset: {len(df)} customer records")
    print(f"   Columns: {list(df.columns)}\n")
    
    # Initialize quality framework
    quality_framework = CommunityQualityFramework()
    
    # Run validation
    results = quality_framework.validate_customer_data(df)
    
    # Display results
    print("\n" + "="*60)
    print("📈 QUALITY VALIDATION RESULTS")
    print("="*60)
    
    print(f"\n🎯 Overall Quality Score: {results['overall_score']:.1f}%")
    
    print(f"\n📊 Dimension Scores:")
    for dimension, score in results['dimension_scores'].items():
        print(f"   {dimension.title()}: {score:.1f}%")
    
    print(f"\n💡 Recommendations:")
    for i, rec in enumerate(results['recommendations'], 1):
        print(f"   {i}. {rec}")
    
    print(f"\n📋 Validation Details:")
    for result in results['detailed_results']:
        status = "✅ PASS" if result.passed else "❌ FAIL"
        print(f"   {result.metric}: {result.score:.1f}% (threshold: {result.threshold}%) - {status}")
    
    print("\n" + "="*60)
    print("🌟 Community Edition Features Demonstrated:")
    print("   ✅ 3-Dimensional Quality Framework")
    print("   ✅ Automated Validation and Scoring")
    print("   ✅ Actionable Recommendations")
    print("   ✅ Production-Ready Quality Checks")
    
    print("\n🏢 Enterprise Edition Adds:")
    print("   • 7-Dimensional Quality Framework")
    print("   • ML-Enhanced Anomaly Detection")
    print("   • Real-time Quality Monitoring")
    print("   • Predictive Quality Analytics")
    print("   • Professional Support & Training")
    
    print("\n📞 Contact: enterprise@agenticdata.com")
    print("="*60)

if __name__ == "__main__":
    demo_quality_validation()