# Basic migration rollback commands

# Rollback to a specific migration
# python manage.py migrate blog 0003

# Rollback all migrations for an app
# python manage.py migrate blog zero

# Show what would be rolled back without applying
# python manage.py migrate blog 0003 --plan

# Example migration with proper reverse operations
class Migration(migrations.Migration):
    """Migration with reversible operations"""
    
    dependencies = [
        ('blog', '0003_add_tags'),
    ]
    
    operations = [
        # Reversible: AddField automatically generates RemoveField for reverse
        migrations.AddField(
            model_name='post',
            name='view_count',
            field=models.PositiveIntegerField(default=0),
        ),
        
        # Reversible: AlterField can be reversed to previous state
        migrations.AlterField(
            model_name='post',
            name='title',
            field=models.CharField(max_length=300),  # Changed from 200
        ),
        
        # Reversible: AddIndex automatically generates RemoveIndex for reverse
        migrations.AddIndex(
            model_name='post',
            index=models.Index(fields=['view_count'], name='blog_post_view_count_idx'),
        ),
    ]

# Migration with custom reverse operations
class Migration(migrations.Migration):
    """Migration with custom reverse logic"""
    
    dependencies = [
        ('blog', '0004_add_view_count'),
    ]
    
    operations = [
        # Custom SQL with explicit reverse
        migrations.RunSQL(
            sql="CREATE INDEX CONCURRENTLY idx_post_title_gin ON blog_post USING gin(to_tsvector('english', title));",
            reverse_sql="DROP INDEX IF EXISTS idx_post_title_gin;",
        ),
        
        # Python operation with custom reverse
        migrations.RunPython(
            code=populate_post_slugs,
            reverse_code=clear_post_slugs,
        ),
    ]

def populate_post_slugs(apps, schema_editor):
    """Forward operation: populate slug fields"""
    Post = apps.get_model('blog', 'Post')
    
    for post in Post.objects.filter(slug__isnull=True):
        post.slug = slugify(post.title)
        post.save()

def clear_post_slugs(apps, schema_editor):
    """Reverse operation: clear slug fields"""
    Post = apps.get_model('blog', 'Post')
    
    # Clear slugs that were auto-generated
    Post.objects.filter(slug__isnull=False).update(slug=None)

# Non-reversible operations
class Migration(migrations.Migration):
    """Migration with non-reversible operations"""
    
    dependencies = [
        ('blog', '0005_populate_slugs'),
    ]
    
    operations = [
        # This operation cannot be reversed safely
        migrations.RemoveField(
            model_name='post',
            name='old_content_field',
        ),
        
        # Custom operation marked as irreversible
        migrations.RunPython(
            code=migrate_complex_data,
            reverse_code=migrations.RunPython.noop,  # No reverse operation
        ),
        
        # SQL operation without reverse
        migrations.RunSQL(
            sql="DROP TABLE IF EXISTS legacy_table;",
            # No reverse_sql provided - irreversible
        ),
    ]

def migrate_complex_data(apps, schema_editor):
    """Complex data migration that cannot be easily reversed"""
    Post = apps.get_model('blog', 'Post')
    
    # Complex transformation that loses original data structure
    for post in Post.objects.all():
        # Transform data in a way that original cannot be recovered
        post.content = transform_content_irreversibly(post.content)
        post.save()

class RollbackSafetyAnalyzer:
    """Analyze migration rollback safety"""
    
    def __init__(self):
        from django.db.migrations.loader import MigrationLoader
        self.loader = MigrationLoader(connection)
    
    def analyze_rollback_safety(self, app_label, target_migration):
        """Analyze safety of rolling back to a specific migration"""
        
        current_state = self.loader.project_state()
        target_key = (app_label, target_migration)
        
        if target_key not in self.loader.graph.nodes:
            return {
                'safe': False,
                'error': f"Migration {app_label}.{target_migration} not found"
            }
        
        # Get rollback plan
        from django.db.migrations.executor import MigrationExecutor
        executor = MigrationExecutor(connection)
        
        try:
            plan = executor.migration_plan([target_key])
        except Exception as e:
            return {
                'safe': False,
                'error': f"Cannot create rollback plan: {e}"
            }
        
        safety_analysis = {
            'safe': True,
            'warnings': [],
            'data_loss_risk': False,
            'irreversible_operations': [],
            'affected_tables': set(),
            'rollback_plan': []
        }
        
        # Analyze each migration in rollback plan
        for migration, backwards in plan:
            if not backwards:
                continue  # Skip forward migrations
            
            migration_analysis = self._analyze_migration_rollback(migration)
            
            safety_analysis['rollback_plan'].append({
                'migration': f"{migration.app_label}.{migration.name}",
                'analysis': migration_analysis
            })
            
            # Aggregate risks
            if not migration_analysis['reversible']:
                safety_analysis['safe'] = False
                safety_analysis['irreversible_operations'].extend(
                    migration_analysis['irreversible_operations']
                )
            
            if migration_analysis['data_loss_risk']:
                safety_analysis['data_loss_risk'] = True
            
            safety_analysis['warnings'].extend(migration_analysis['warnings'])
            safety_analysis['affected_tables'].update(migration_analysis['affected_tables'])
        
        return safety_analysis
    
    def _analyze_migration_rollback(self, migration):
        """Analyze rollback safety for a single migration"""
        
        analysis = {
            'reversible': True,
            'data_loss_risk': False,
            'warnings': [],
            'irreversible_operations': [],
            'affected_tables': set()
        }
        
        for operation in migration.operations:
            op_analysis = self._analyze_operation_rollback(operation)
            
            if not op_analysis['reversible']:
                analysis['reversible'] = False
                analysis['irreversible_operations'].append(op_analysis)
            
            if op_analysis['data_loss_risk']:
                analysis['data_loss_risk'] = True
            
            analysis['warnings'].extend(op_analysis['warnings'])
            analysis['affected_tables'].update(op_analysis['affected_tables'])
        
        return analysis
    
    def _analyze_operation_rollback(self, operation):
        """Analyze rollback safety for a single operation"""
        
        op_name = operation.__class__.__name__
        
        analysis = {
            'operation': op_name,
            'reversible': True,
            'data_loss_risk': False,
            'warnings': [],
            'affected_tables': set()
        }
        
        # Analyze specific operation types
        if op_name == 'CreateModel':
            analysis['data_loss_risk'] = True
            analysis['warnings'].append(
                f"Rolling back CreateModel will delete all data in {operation.name} table"
            )
            analysis['affected_tables'].add(operation.name.lower())
        
        elif op_name == 'DeleteModel':
            analysis['reversible'] = True  # DeleteModel rollback recreates table
            analysis['warnings'].append(
                f"Rolling back DeleteModel will recreate {operation.name} table (data already lost)"
            )
        
        elif op_name == 'AddField':
            analysis['data_loss_risk'] = True
            analysis['warnings'].append(
                f"Rolling back AddField will delete data in {operation.name} field"
            )
            if hasattr(operation, 'model_name'):
                analysis['affected_tables'].add(operation.model_name.lower())
        
        elif op_name == 'RemoveField':
            analysis['reversible'] = True  # RemoveField rollback recreates field
            analysis['warnings'].append(
                f"Rolling back RemoveField will recreate {operation.name} field (data already lost)"
            )
        
        elif op_name == 'AlterField':
            analysis['warnings'].append(
                f"Rolling back AlterField may cause data compatibility issues for {operation.name}"
            )
            if hasattr(operation, 'model_name'):
                analysis['affected_tables'].add(operation.model_name.lower())
        
        elif op_name == 'RunSQL':
            if not hasattr(operation, 'reverse_sql') or not operation.reverse_sql:
                analysis['reversible'] = False
                analysis['irreversible_operations'].append(
                    f"RunSQL operation without reverse_sql"
                )
            else:
                analysis['warnings'].append(
                    "Custom SQL rollback - verify reverse_sql is correct"
                )
        
        elif op_name == 'RunPython':
            if (not hasattr(operation, 'reverse_code') or 
                operation.reverse_code == migrations.RunPython.noop):
                analysis['reversible'] = False
                analysis['irreversible_operations'].append(
                    f"RunPython operation without reverse_code"
                )
            else:
                analysis['warnings'].append(
                    "Custom Python rollback - verify reverse_code is correct"
                )
        
        return analysis
    
    def suggest_rollback_strategy(self, app_label, target_migration):
        """Suggest strategy for safe rollback"""
        
        safety_analysis = self.analyze_rollback_safety(app_label, target_migration)
        
        strategy = {
            'recommended_approach': 'direct_rollback',
            'steps': [],
            'prerequisites': [],
            'risks': [],
            'alternatives': []
        }
        
        if not safety_analysis['safe']:
            strategy['recommended_approach'] = 'manual_rollback'
            strategy['steps'].extend([
                "1. Create database backup",
                "2. Review irreversible operations manually",
                "3. Create custom rollback migration if needed",
                "4. Test rollback on copy of production data"
            ])
        
        elif safety_analysis['data_loss_risk']:
            strategy['recommended_approach'] = 'backup_and_rollback'
            strategy['prerequisites'].append("Create database backup")
            strategy['steps'].extend([
                "1. Backup database",
                "2. Export affected data if needed",
                "3. Perform rollback",
                "4. Verify data integrity"
            ])
        
        else:
            strategy['steps'].extend([
                f"1. Run: python manage.py migrate {app_label} {target_migration}",
                "2. Verify application functionality",
                "3. Check for any data inconsistencies"
            ])
        
        # Add risks from analysis
        strategy['risks'] = safety_analysis['warnings']
        
        # Add alternative approaches
        if safety_analysis['irreversible_operations']:
            strategy['alternatives'].extend([
                "Create new forward migration to undo changes",
                "Restore from backup instead of rollback",
                "Manual database modifications"
            ])
        
        return strategy

class SafeRollbackPatterns:
    """Patterns for safe migration rollbacks"""
    
    @staticmethod
    def create_data_preservation_migration():
        """Create migration that preserves data during rollback"""
        
        class Migration(migrations.Migration):
            dependencies = [
                ('blog', '0006_complex_changes'),
            ]
            
            operations = [
                # Step 1: Create backup table before making changes
                migrations.RunSQL(
                    sql="CREATE TABLE blog_post_backup AS SELECT * FROM blog_post;",
                    reverse_sql="DROP TABLE IF EXISTS blog_post_backup;",
                ),
                
                # Step 2: Make the actual changes
                migrations.AddField(
                    model_name='post',
                    name='new_field',
                    field=models.CharField(max_length=100, null=True),
                ),
                
                # Step 3: Populate new field
                migrations.RunPython(
                    code=populate_new_field,
                    reverse_code=restore_from_backup,
                ),
                
                # Step 4: Clean up backup table (optional)
                migrations.RunSQL(
                    sql="-- Keep backup table for safety",
                    reverse_sql="-- Backup table will be dropped by step 1 reverse",
                ),
            ]
    
    @staticmethod
    def two_phase_rollback_migration():
        """Two-phase migration for safer rollbacks"""
        
        # Phase 1: Prepare for rollback
        class PreparationMigration(migrations.Migration):
            dependencies = [
                ('blog', '0007_data_preservation'),
            ]
            
            operations = [
                # Add new field as nullable first
                migrations.AddField(
                    model_name='post',
                    name='status_new',
                    field=models.CharField(max_length=20, null=True),
                ),
                
                # Copy data to new field
                migrations.RunPython(
                    code=copy_status_to_new_field,
                    reverse_code=clear_new_status_field,
                ),
            ]
        
        # Phase 2: Complete the change
        class CompletionMigration(migrations.Migration):
            dependencies = [
                ('blog', '0008_preparation'),
            ]
            
            operations = [
                # Remove old field
                migrations.RemoveField(
                    model_name='post',
                    name='status',
                ),
                
                # Rename new field to final name
                migrations.RenameField(
                    model_name='post',
                    old_name='status_new',
                    new_name='status',
                ),
                
                # Make field non-nullable
                migrations.AlterField(
                    model_name='post',
                    name='status',
                    field=models.CharField(max_length=20),
                ),
            ]
    
    @staticmethod
    def conditional_rollback_migration():
        """Migration with conditional rollback behavior"""
        
        def smart_rollback(apps, schema_editor):
            """Rollback that preserves data when possible"""
            
            Post = apps.get_model('blog', 'Post')
            
            # Check if we can preserve data
            posts_with_new_data = Post.objects.filter(
                new_field__isnull=False
            ).count()
            
            if posts_with_new_data > 0:
                # Create backup before rollback
                backup_data = list(Post.objects.values(
                    'id', 'new_field'
                ))
                
                # Store backup in cache or temporary table
                from django.core.cache import cache
                cache.set('rollback_backup_new_field', backup_data, timeout=3600)
                
                print(f"Backed up {len(backup_data)} records before rollback")
            
            # Clear the field for safe rollback
            Post.objects.update(new_field=None)
        
        class Migration(migrations.Migration):
            dependencies = [
                ('blog', '0009_completion'),
            ]
            
            operations = [
                migrations.RunPython(
                    code=populate_advanced_field,
                    reverse_code=smart_rollback,
                ),
            ]

def populate_new_field(apps, schema_editor):
    """Populate new field with data"""
    Post = apps.get_model('blog', 'Post')
    
    for post in Post.objects.all():
        post.new_field = f"generated_{post.id}"
        post.save()

def restore_from_backup(apps, schema_editor):
    """Restore data from backup table"""
    from django.db import connection
    
    with connection.cursor() as cursor:
        # Restore from backup table
        cursor.execute("""
            UPDATE blog_post 
            SET title = backup.title,
                content = backup.content
            FROM blog_post_backup backup
            WHERE blog_post.id = backup.id
        """)

def copy_status_to_new_field(apps, schema_editor):
    """Copy status to new field"""
    Post = apps.get_model('blog', 'Post')
    
    Post.objects.update(status_new=F('status'))

def clear_new_status_field(apps, schema_editor):
    """Clear new status field"""
    Post = apps.get_model('blog', 'Post')
    
    Post.objects.update(status_new=None)

def populate_advanced_field(apps, schema_editor):
    """Populate advanced field"""
    Post = apps.get_model('blog', 'Post')
    
    for post in Post.objects.all():
        post.advanced_field = calculate_advanced_value(post)
        post.save()

def calculate_advanced_value(post):
    """Calculate advanced value for post"""
    return f"advanced_{post.id}_{len(post.title)}"

class RollbackRecoveryManager:
    """Manage recovery from failed rollbacks"""
    
    @staticmethod
    def create_rollback_checkpoint():
        """Create checkpoint before rollback"""
        
        from django.core.management import call_command
        from datetime import datetime
        import json
        
        checkpoint_data = {
            'timestamp': datetime.now().isoformat(),
            'migration_state': {},
            'data_snapshots': {}
        }
        
        # Capture current migration state
        from django.db.migrations.loader import MigrationLoader
        loader = MigrationLoader(connection)
        
        for app_label in loader.migrated_apps:
            app_migrations = []
            
            for migration_key in loader.graph.nodes:
                if migration_key[0] == app_label:
                    is_applied = migration_key in loader.applied_migrations
                    if is_applied:
                        app_migrations.append(migration_key[1])
            
            checkpoint_data['migration_state'][app_label] = app_migrations
        
        # Save checkpoint
        checkpoint_file = f"rollback_checkpoint_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
        
        with open(checkpoint_file, 'w') as f:
            json.dump(checkpoint_data, f, indent=2)
        
        return checkpoint_file
    
    @staticmethod
    def recover_from_failed_rollback(checkpoint_file):
        """Recover from failed rollback using checkpoint"""
        
        import json
        from django.core.management import call_command
        
        # Load checkpoint data
        with open(checkpoint_file, 'r') as f:
            checkpoint_data = json.load(f)
        
        recovery_plan = {
            'steps': [],
            'manual_actions': [],
            'verification_steps': []
        }
        
        # Analyze current state vs checkpoint
        from django.db.migrations.loader import MigrationLoader
        loader = MigrationLoader(connection)
        
        for app_label, expected_migrations in checkpoint_data['migration_state'].items():
            current_migrations = []
            
            for migration_key in loader.applied_migrations:
                if migration_key[0] == app_label:
                    current_migrations.append(migration_key[1])
            
            # Find missing migrations
            missing_migrations = set(expected_migrations) - set(current_migrations)
            extra_migrations = set(current_migrations) - set(expected_migrations)
            
            if missing_migrations:
                for migration in sorted(missing_migrations):
                    recovery_plan['steps'].append(
                        f"python manage.py migrate {app_label} {migration}"
                    )
            
            if extra_migrations:
                recovery_plan['manual_actions'].append(
                    f"Review extra migrations in {app_label}: {extra_migrations}"
                )
        
        # Add verification steps
        recovery_plan['verification_steps'].extend([
            "python manage.py check",
            "python manage.py showmigrations",
            "Verify application functionality",
            "Check data integrity"
        ])
        
        return recovery_plan
    
    @staticmethod
    def create_emergency_rollback_script(app_label, target_migration):
        """Create emergency rollback script"""
        
        script_content = f'''#!/bin/bash
# Emergency rollback script for {app_label} to {target_migration}
# Generated on {datetime.now().isoformat()}

set -e

echo "Starting emergency rollback..."

# Create backup
echo "Creating database backup..."
python manage.py dbbackup --compress

# Check current migration state
echo "Current migration state:"
python manage.py showmigrations {app_label}

# Perform rollback
echo "Rolling back to {target_migration}..."
python manage.py migrate {app_label} {target_migration}

# Verify rollback
echo "Verifying rollback..."
python manage.py check
python manage.py showmigrations {app_label}

echo "Emergency rollback completed!"
echo "Please verify application functionality manually."
'''
        
        script_filename = f"emergency_rollback_{app_label}_{target_migration}.sh"
        
        with open(script_filename, 'w') as f:
            f.write(script_content)
        
        # Make script executable
        import os
        os.chmod(script_filename, 0o755)
        
        return script_filename

# Advanced rollback scenarios
class AdvancedRollbackScenarios:
    """Handle complex rollback scenarios"""
    
    @staticmethod
    def rollback_with_data_migration():
        """Rollback that includes data migration"""
        
        def rollback_with_data_preservation(apps, schema_editor):
            """Preserve critical data during rollback"""
            
            Post = apps.get_model('blog', 'Post')
            
            # Export critical data before rollback
            critical_data = []
            
            for post in Post.objects.all():
                if hasattr(post, 'critical_field') and post.critical_field:
                    critical_data.append({
                        'post_id': post.id,
                        'critical_value': post.critical_field
                    })
            
            # Store in a safe location
            if critical_data:
                from django.core.cache import cache
                cache.set('rollback_critical_data', critical_data, timeout=86400)
                
                print(f"Preserved {len(critical_data)} critical data records")
        
        return rollback_with_data_preservation
    
    @staticmethod
    def partial_rollback_strategy():
        """Strategy for partial rollbacks"""
        
        def selective_rollback(apps, schema_editor):
            """Rollback only specific changes"""
            
            # This allows rolling back specific parts of a migration
            # while preserving others
            
            Post = apps.get_model('blog', 'Post')
            
            # Rollback field changes but preserve data
            posts_to_update = Post.objects.filter(
                # Condition for selective rollback
                status='migrated'
            )
            
            for post in posts_to_update:
                # Reverse specific changes
                post.status = 'original'
                # Keep other changes intact
                post.save()
        
        return selective_rollback
    
    @staticmethod
    def cross_app_rollback_coordination():
        """Coordinate rollbacks across multiple apps"""
        
        def coordinated_rollback(apps, schema_editor):
            """Rollback changes across multiple related apps"""
            
            # Get models from different apps
            Post = apps.get_model('blog', 'Post')
            Comment = apps.get_model('comments', 'Comment')
            UserProfile = apps.get_model('accounts', 'UserProfile')
            
            # Coordinate rollback to maintain referential integrity
            
            # Step 1: Handle dependent data
            Comment.objects.filter(
                post__in=Post.objects.filter(status='to_rollback')
            ).update(status='archived')
            
            # Step 2: Rollback main changes
            Post.objects.filter(status='to_rollback').update(
                status='published'
            )
            
            # Step 3: Update related models
            UserProfile.objects.filter(
                user__post__status='published'
            ).update(post_count=F('post_count') + 1)
        
        return coordinated_rollback

class ProductionRollbackManager:
    """Manage rollbacks in production environments"""
    
    @staticmethod
    def validate_production_rollback(app_label, target_migration):
        """Validate rollback safety for production"""
        
        validation_results = {
            'safe_for_production': True,
            'blocking_issues': [],
            'warnings': [],
            'required_actions': [],
            'estimated_downtime': 'unknown'
        }
        
        # Check for data loss risks
        analyzer = RollbackSafetyAnalyzer()
        safety_analysis = analyzer.analyze_rollback_safety(app_label, target_migration)
        
        if safety_analysis['data_loss_risk']:
            validation_results['safe_for_production'] = False
            validation_results['blocking_issues'].append(
                "Rollback involves data loss - not safe for production"
            )
        
        if safety_analysis['irreversible_operations']:
            validation_results['safe_for_production'] = False
            validation_results['blocking_issues'].append(
                "Rollback contains irreversible operations"
            )
        
        # Check for high-impact operations
        if len(safety_analysis['affected_tables']) > 5:
            validation_results['warnings'].append(
                f"Rollback affects {len(safety_analysis['affected_tables'])} tables"
            )
            validation_results['estimated_downtime'] = 'high'
        
        # Add required actions for production
        validation_results['required_actions'].extend([
            "Create full database backup",
            "Schedule maintenance window",
            "Notify stakeholders",
            "Prepare rollback verification checklist",
            "Have rollforward plan ready"
        ])
        
        return validation_results
    
    @staticmethod
    def create_production_rollback_plan(app_label, target_migration):
        """Create comprehensive rollback plan for production"""
        
        plan = {
            'pre_rollback': [],
            'rollback_steps': [],
            'post_rollback': [],
            'verification': [],
            'rollforward_plan': [],
            'communication': []
        }
        
        # Pre-rollback steps
        plan['pre_rollback'].extend([
            "1. Announce maintenance window",
            "2. Create database backup",
            "3. Export critical data",
            "4. Stop application servers",
            "5. Verify backup integrity"
        ])
        
        # Rollback steps
        plan['rollback_steps'].extend([
            f"1. python manage.py migrate {app_label} {target_migration}",
            "2. Verify migration state",
            "3. Check database consistency",
            "4. Run application health checks"
        ])
        
        # Post-rollback steps
        plan['post_rollback'].extend([
            "1. Start application servers",
            "2. Verify application functionality",
            "3. Monitor error logs",
            "4. Check performance metrics",
            "5. Notify stakeholders of completion"
        ])
        
        # Verification checklist
        plan['verification'].extend([
            "Database schema matches expected state",
            "All application features work correctly",
            "No data corruption detected",
            "Performance metrics within normal range",
            "Error rates within acceptable limits"
        ])
        
        # Rollforward plan (in case rollback fails)
        plan['rollforward_plan'].extend([
            "1. Restore from backup if rollback fails",
            "2. Apply migrations forward to known good state",
            "3. Implement hotfix if needed",
            "4. Schedule proper fix for next maintenance window"
        ])
        
        return plan
    
    @staticmethod
    def monitor_rollback_progress():
        """Monitor rollback progress in production"""
        
        import time
        import psutil
        from django.db import connection
        
        monitoring_data = {
            'start_time': time.time(),
            'checkpoints': [],
            'performance_metrics': [],
            'error_log': []
        }
        
        def log_checkpoint(message):
            monitoring_data['checkpoints'].append({
                'timestamp': time.time(),
                'message': message,
                'elapsed': time.time() - monitoring_data['start_time']
            })
            print(f"[{time.time() - monitoring_data['start_time']:.1f}s] {message}")
        
        def log_performance():
            monitoring_data['performance_metrics'].append({
                'timestamp': time.time(),
                'cpu_percent': psutil.cpu_percent(),
                'memory_percent': psutil.virtual_memory().percent,
                'db_connections': len(connection.queries)
            })
        
        return log_checkpoint, log_performance, monitoring_data