#!/usr/bin/env python3
"""
RateRight Contract Workflow Diagnostics
Complete analysis of the contract system workflow
"""

import sys
import os
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

from app import create_app
from app.models import Contract, User, Job, Application, Review, Payment
from app.extensions import db
from datetime import datetime
import json

def diagnose_contract_workflow():
    """Complete diagnostics of contract workflow"""
    print("🔧 RATERIGHT CONTRACT WORKFLOW DIAGNOSTICS")
    print("=" * 60)
    
    app = create_app()
    with app.app_context():
        
        # 1. DATABASE SCHEMA ANALYSIS
        print("\n📊 1. DATABASE SCHEMA ANALYSIS")
        print("-" * 40)
        
        try:
            # Check Contract table structure
            from sqlalchemy import inspect
            inspector = inspect(db.engine)
            
            if 'contracts' in inspector.get_table_names():
                contract_columns = inspector.get_columns('contracts')
                print("✅ Contract table exists")
                print(f"📋 Contract columns ({len(contract_columns)}):")
                for col in contract_columns:
                    print(f"   • {col['name']} ({col['type']})")
                
                # Check for rating fields
                rating_fields = ['contractor_rated', 'worker_rated', 'completion_status', 'payment_status']
                missing_fields = []
                existing_fields = [col['name'] for col in contract_columns]
                
                for field in rating_fields:
                    if field in existing_fields:
                        print(f"   ✅ {field} - Present")
                    else:
                        missing_fields.append(field)
                        print(f"   ❌ {field} - Missing")
                
                if missing_fields:
                    print(f"⚠️  Missing critical fields: {missing_fields}")
                else:
                    print("✅ All critical rating fields present")
                    
            else:
                print("❌ Contract table does not exist!")
                return
                
        except Exception as e:
            print(f"❌ Database schema error: {e}")
            return
        
        # 2. CONTRACT MODEL ANALYSIS
        print("\n🏗️  2. CONTRACT MODEL ANALYSIS")
        print("-" * 40)
        
        try:
            # Test Contract model instantiation
            test_contract = Contract()
            print("✅ Contract model can be instantiated")
            
            # Check model methods
            methods = ['is_fully_signed', 'get_next_step', 'can_sign', 'sign_contract', 
                      'is_mutual_rating_complete', 'get_rating_status_for_user']
            
            for method in methods:
                if hasattr(Contract, method):
                    print(f"   ✅ {method}() - Available")
                else:
                    print(f"   ❌ {method}() - Missing")
                    
            # Check relationships
            if hasattr(Contract, 'job'):
                print("   ✅ job relationship - Available")
            else:
                print("   ❌ job relationship - Missing")
                
            if hasattr(Contract, 'reviews'):
                print("   ✅ reviews relationship - Available")
            else:
                print("   ❌ reviews relationship - Missing")
                
        except Exception as e:
            print(f"❌ Contract model error: {e}")
        
        # 3. CONTRACT DATA ANALYSIS
        print("\n📋 3. CONTRACT DATA ANALYSIS")
        print("-" * 40)
        
        try:
            total_contracts = Contract.query.count()
            print(f"📊 Total contracts: {total_contracts}")
            
            if total_contracts > 0:
                # Status distribution
                statuses = db.session.query(Contract.status, db.func.count(Contract.id)).group_by(Contract.status).all()
                print("📈 Contract status distribution:")
                for status, count in statuses:
                    print(f"   • {status}: {count}")
                
                # Completion status distribution
                completion_statuses = db.session.query(Contract.completion_status, db.func.count(Contract.id)).group_by(Contract.completion_status).all()
                print("📈 Completion status distribution:")
                for status, count in completion_statuses:
                    print(f"   • {status}: {count}")
                
                # Rating completion analysis
                rated_contracts = Contract.query.filter(
                    Contract.contractor_rated == True,
                    Contract.worker_rated == True
                ).count()
                
                pending_ratings = Contract.query.filter(
                    Contract.status == 'pending_rating'
                ).count()
                
                print(f"⭐ Fully rated contracts: {rated_contracts}")
                print(f"⏳ Pending ratings: {pending_ratings}")
                
                # Get sample contract for workflow testing
                sample_contract = Contract.query.first()
                if sample_contract:
                    print(f"\n🔍 Sample contract analysis (ID: {sample_contract.id}):")
                    print(f"   Status: {sample_contract.status}")
                    print(f"   Completion: {sample_contract.completion_status}")
                    print(f"   Payment: {sample_contract.payment_status}")
                    print(f"   Contractor rated: {sample_contract.contractor_rated}")
                    print(f"   Worker rated: {sample_contract.worker_rated}")
                    print(f"   Next step: {sample_contract.get_next_step()}")
                    
            else:
                print("⚠️  No contracts found in database")
                
        except Exception as e:
            print(f"❌ Contract data analysis error: {e}")
        
        # 4. WORKFLOW ROUTES ANALYSIS
        print("\n🌐 4. WORKFLOW ROUTES ANALYSIS")
        print("-" * 40)
        
        try:
            # Check if contract routes are registered
            routes = []
            for rule in app.url_map.iter_rules():
                if 'contract' in rule.rule.lower():
                    routes.append(rule.rule)
            
            print(f"🔗 Contract-related routes ({len(routes)}):")
            for route in sorted(routes):
                print(f"   • {route}")
            
            # Check specific endpoints
            critical_endpoints = [
                '/contracts',
                '/contracts/<int:contract_id>',
                '/contracts/<int:contract_id>/rate',
                '/api/marketplace/contracts/<int:contract_id>/rate',
                '/api/marketplace/contracts/<int:contract_id>/review-completion'
            ]
            
            print("\n🎯 Critical endpoints check:")
            for endpoint in critical_endpoints:
                found = any(endpoint in route for route in routes)
                if found:
                    print(f"   ✅ {endpoint}")
                else:
                    print(f"   ❌ {endpoint}")
                    
        except Exception as e:
            print(f"❌ Routes analysis error: {e}")
        
        # 5. API ENDPOINTS TESTING
        print("\n🔌 5. API ENDPOINTS TESTING")
        print("-" * 40)
        
        try:
            # Test with Flask test client
            with app.test_client() as client:
                
                # Test contracts list
                response = client.get('/contracts')
                print(f"GET /contracts: {response.status_code}")
                
                # Test API rate endpoint (should return 404 for non-existent contract)
                response = client.get('/api/marketplace/contracts/999/rate')
                print(f"GET /api/marketplace/contracts/999/rate: {response.status_code}")
                
                # Test completion review endpoint
                response = client.post('/api/marketplace/contracts/999/review-completion')
                print(f"POST /api/marketplace/contracts/999/review-completion: {response.status_code}")
                
        except Exception as e:
            print(f"❌ API testing error: {e}")
        
        # 6. WORKFLOW STATE MACHINE ANALYSIS
        print("\n🔄 6. WORKFLOW STATE MACHINE ANALYSIS")
        print("-" * 40)
        
        try:
            print("📋 Contract workflow states:")
            workflow_states = [
                'pending_agreement',
                'contractor_signed', 
                'worker_signed',
                'active',
                'pending_completion_review',
                'pending_rating',
                'completed',
                'cancelled',
                'disputed'
            ]
            
            for state in workflow_states:
                count = Contract.query.filter_by(status=state).count()
                print(f"   • {state}: {count} contracts")
            
            print("\n📋 Completion workflow states:")
            completion_states = [
                'not_started',
                'in_progress', 
                'worker_completed',
                'contractor_approved',
                'pending_rating',
                'completed'
            ]
            
            for state in completion_states:
                count = Contract.query.filter_by(completion_status=state).count()
                print(f"   • {state}: {count} contracts")
                
        except Exception as e:
            print(f"❌ Workflow analysis error: {e}")
        
        # 7. TEMPLATE FILES ANALYSIS
        print("\n📄 7. TEMPLATE FILES ANALYSIS")
        print("-" * 40)
        
        template_files = [
            'app/templates/contracts/list.html',
            'app/templates/contracts/review.html', 
            'app/templates/contracts/rate.html',
            'app/templates/contracts/closeout.html'
        ]
        
        for template in template_files:
            if os.path.exists(template):
                print(f"   ✅ {template}")
            else:
                print(f"   ❌ {template}")
        
        # 8. JAVASCRIPT FUNCTIONALITY ANALYSIS
        print("\n📜 8. JAVASCRIPT FUNCTIONALITY ANALYSIS")
        print("-" * 40)
        
        # Check if rate.html has proper JavaScript
        rate_template = 'app/templates/contracts/rate.html'
        if os.path.exists(rate_template):
            with open(rate_template, 'r') as f:
                content = f.read()
                
            js_functions = ['submitRating', 'fetch', 'approveCompletion', 'disputeCompletion']
            for func in js_functions:
                if func in content:
                    print(f"   ✅ {func}() function found")
                else:
                    print(f"   ❌ {func}() function missing")
        else:
            print("   ❌ rate.html template missing")
        
        # 9. REVIEW MODEL INTEGRATION
        print("\n⭐ 9. REVIEW MODEL INTEGRATION")
        print("-" * 40)
        
        try:
            # Check Review model
            total_reviews = Review.query.count() if 'reviews' in inspector.get_table_names() else 0
            print(f"📊 Total reviews: {total_reviews}")
            
            if total_reviews > 0:
                # Rating distribution
                avg_ratings = db.session.query(db.func.avg(Review.rating)).scalar()
                print(f"📈 Average rating: {avg_ratings:.2f}" if avg_ratings else "No ratings")
                
        except Exception as e:
            print(f"⚠️  Review model error: {e}")
        
        # 10. RECOMMENDATIONS
        print("\n💡 10. DIAGNOSTICS SUMMARY & RECOMMENDATIONS")
        print("-" * 40)
        
        issues = []
        recommendations = []
        
        # Check for common issues
        if total_contracts == 0:
            issues.append("No test contracts in database")
            recommendations.append("Create test contracts for testing workflow")
        
        if not os.path.exists('app/templates/contracts/rate.html'):
            issues.append("Rating template missing")
            recommendations.append("Create rating template")
        
        if pending_ratings > 0:
            recommendations.append(f"Process {pending_ratings} pending ratings")
        
        if '/api/marketplace/contracts' not in str(routes):
            issues.append("API endpoints missing")
            recommendations.append("Register contract API blueprint")
        
        print(f"🔍 Issues found: {len(issues)}")
        for issue in issues:
            print(f"   ❌ {issue}")
        
        print(f"\n💡 Recommendations: {len(recommendations)}")
        for rec in recommendations:
            print(f"   💡 {rec}")
        
        print("\n" + "=" * 60)
        print("✅ CONTRACT WORKFLOW DIAGNOSTICS COMPLETE")
        return True

if __name__ == "__main__":
    diagnose_contract_workflow()