# Historical models are snapshots of your models at migration time
# They are automatically generated and stored in migration files

# Example: Current model definition
class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    created_at = models.DateTimeField(auto_now_add=True)
    status = models.CharField(max_length=20, default='draft')

# Historical model in migration (automatically generated)
class Migration(migrations.Migration):
    dependencies = [
        ('auth', '0012_alter_user_first_name_max_length'),
        ('blog', '0001_initial'),
    ]
    
    operations = [
        migrations.AddField(
            model_name='post',
            name='status',
            field=models.CharField(default='draft', max_length=20),
        ),
    ]

# Accessing historical models in data migrations
def populate_post_status(apps, schema_editor):
    """Data migration using historical model"""
    
    # Get historical model - represents Post at this migration's time
    Post = apps.get_model('blog', 'Post')
    
    # This Post model only has fields that existed at this migration
    # It won't have fields added in later migrations
    
    for post in Post.objects.all():
        # Safe to access: title, content, author, created_at, status
        # NOT safe to access: fields added in later migrations
        
        if not post.status:  # status field was just added
            post.status = 'published' if post.created_at else 'draft'
            post.save()

# Historical model state representation
class HistoricalModelExplorer:
    """Explore historical model states"""
    
    @staticmethod
    def get_model_state_at_migration(app_label, model_name, migration_name):
        """Get model state at specific migration"""
        
        from django.db.migrations.loader import MigrationLoader
        from django.db.migrations.state import ProjectState
        
        loader = MigrationLoader(connection)
        
        # Get state at specific migration
        migration_key = (app_label, migration_name)
        state = loader.project_state(migration_key)
        
        # Get model state
        model_key = (app_label, model_name.lower())
        
        if model_key in state.models:
            model_state = state.models[model_key]
            
            return {
                'model_name': model_state.name,
                'app_label': model_state.app_label,
                'fields': {
                    name: {
                        'type': field.__class__.__name__,
                        'max_length': getattr(field, 'max_length', None),
                        'null': getattr(field, 'null', False),
                        'blank': getattr(field, 'blank', False),
                        'default': getattr(field, 'default', None),
                    }
                    for name, field in model_state.fields.items()
                },
                'options': model_state.options,
                'managers': list(model_state.managers.keys()),
            }
        
        return None
    
    @staticmethod
    def compare_model_states(app_label, model_name, migration1, migration2):
        """Compare model states between two migrations"""
        
        state1 = HistoricalModelExplorer.get_model_state_at_migration(
            app_label, model_name, migration1
        )
        state2 = HistoricalModelExplorer.get_model_state_at_migration(
            app_label, model_name, migration2
        )
        
        if not state1 or not state2:
            return None
        
        differences = {
            'added_fields': [],
            'removed_fields': [],
            'modified_fields': [],
            'option_changes': {}
        }
        
        # Compare fields
        fields1 = set(state1['fields'].keys())
        fields2 = set(state2['fields'].keys())
        
        differences['added_fields'] = list(fields2 - fields1)
        differences['removed_fields'] = list(fields1 - fields2)
        
        # Compare modified fields
        common_fields = fields1 & fields2
        for field_name in common_fields:
            field1 = state1['fields'][field_name]
            field2 = state2['fields'][field_name]
            
            field_changes = []
            
            for attr in ['type', 'max_length', 'null', 'blank', 'default']:
                if field1.get(attr) != field2.get(attr):
                    field_changes.append({
                        'attribute': attr,
                        'from': field1.get(attr),
                        'to': field2.get(attr)
                    })
            
            if field_changes:
                differences['modified_fields'].append({
                    'field': field_name,
                    'changes': field_changes
                })
        
        # Compare options
        for option, value1 in state1['options'].items():
            value2 = state2['options'].get(option)
            if value1 != value2:
                differences['option_changes'][option] = {
                    'from': value1,
                    'to': value2
                }
        
        return differences

class HistoricalModelPatterns:
    """Common patterns for working with historical models"""
    
    @staticmethod
    def safe_field_access_pattern():
        """Pattern for safely accessing fields in historical models"""
        
        def safe_data_migration(apps, schema_editor):
            """Safely access fields that might not exist"""
            
            Post = apps.get_model('blog', 'Post')
            
            # Get the first post to inspect available fields
            sample_post = Post.objects.first()
            
            if sample_post:
                # Check if field exists before accessing
                available_fields = [f.name for f in sample_post._meta.fields]
                
                for post in Post.objects.all():
                    # Safe field access
                    if 'slug' in available_fields:
                        if not post.slug:
                            post.slug = slugify(post.title)
                    
                    if 'view_count' in available_fields:
                        if post.view_count is None:
                            post.view_count = 0
                    
                    # Always safe to access fields that existed at migration time
                    post.updated_at = timezone.now()
                    post.save()
        
        return safe_data_migration
    
    @staticmethod
    def relationship_handling_pattern():
        """Pattern for handling relationships in historical models"""
        
        def handle_relationships(apps, schema_editor):
            """Handle foreign keys and many-to-many relationships"""
            
            Post = apps.get_model('blog', 'Post')
            Category = apps.get_model('blog', 'Category')
            Tag = apps.get_model('blog', 'Tag')
            User = apps.get_model('auth', 'User')
            
            # Create default category if needed
            default_category, created = Category.objects.get_or_create(
                name='Uncategorized',
                defaults={'description': 'Default category for posts'}
            )
            
            # Handle posts without categories
            posts_without_category = Post.objects.filter(category__isnull=True)
            posts_without_category.update(category=default_category)
            
            # Handle many-to-many relationships
            for post in Post.objects.filter(tags__isnull=True):
                # Create default tag
                default_tag, created = Tag.objects.get_or_create(
                    name='general',
                    defaults={'slug': 'general'}
                )
                
                # Add tag to post (historical M2M handling)
                post.tags.add(default_tag)
            
            # Handle user relationships safely
            try:
                # Get system user or create one
                system_user = User.objects.get(username='system')
            except User.DoesNotExist:
                system_user = User.objects.create_user(
                    username='system',
                    email='system@example.com',
                    first_name='System',
                    last_name='User'
                )
            
            # Assign system user to posts without authors
            Post.objects.filter(author__isnull=True).update(author=system_user)
        
        return handle_relationships
    
    @staticmethod
    def bulk_operations_pattern():
        """Pattern for efficient bulk operations with historical models"""
        
        def bulk_data_migration(apps, schema_editor):
            """Perform bulk operations efficiently"""
            
            Post = apps.get_model('blog', 'Post')
            
            # Bulk update - more efficient than individual saves
            Post.objects.filter(status='').update(status='draft')
            
            # Bulk create for new records
            posts_to_create = []
            
            for i in range(100):
                posts_to_create.append(Post(
                    title=f'Sample Post {i}',
                    content=f'Content for post {i}',
                    status='draft'
                ))
            
            # Use bulk_create for efficiency
            Post.objects.bulk_create(posts_to_create, batch_size=50)
            
            # For complex updates, use bulk_update (Django 2.2+)
            posts_to_update = []
            
            for post in Post.objects.filter(slug__isnull=True):
                post.slug = slugify(post.title)
                posts_to_update.append(post)
            
            # Bulk update with specific fields
            Post.objects.bulk_update(posts_to_update, ['slug'], batch_size=100)
        
        return bulk_data_migration
    
    @staticmethod
    def conditional_migration_pattern():
        """Pattern for conditional data migrations"""
        
        def conditional_data_migration(apps, schema_editor):
            """Perform migration based on existing data conditions"""
            
            Post = apps.get_model('blog', 'Post')
            
            # Check if migration is needed
            posts_needing_update = Post.objects.filter(
                status__isnull=True
            ).count()
            
            if posts_needing_update == 0:
                print("No posts need status update, skipping migration")
                return
            
            print(f"Updating status for {posts_needing_update} posts")
            
            # Conditional logic based on existing data
            for post in Post.objects.filter(status__isnull=True):
                # Determine status based on existing data
                if hasattr(post, 'published_at') and post.published_at:
                    post.status = 'published'
                elif hasattr(post, 'created_at'):
                    # Published if created more than a week ago
                    week_ago = timezone.now() - timedelta(days=7)
                    if post.created_at < week_ago:
                        post.status = 'published'
                    else:
                        post.status = 'draft'
                else:
                    post.status = 'draft'
                
                post.save()
        
        return conditional_data_migration

# Advanced historical model techniques
class AdvancedHistoricalModelTechniques:
    """Advanced techniques for working with historical models"""
    
    @staticmethod
    def cross_app_historical_models():
        """Work with historical models across multiple apps"""
        
        def cross_app_migration(apps, schema_editor):
            """Migrate data across multiple apps using historical models"""
            
            # Get models from different apps
            Post = apps.get_model('blog', 'Post')
            Comment = apps.get_model('comments', 'Comment')
            UserProfile = apps.get_model('accounts', 'UserProfile')
            User = apps.get_model('auth', 'User')
            
            # Migrate data between apps
            for post in Post.objects.all():
                # Update user profile based on post data
                try:
                    profile = UserProfile.objects.get(user=post.author)
                    profile.post_count = F('post_count') + 1
                    profile.save()
                except UserProfile.DoesNotExist:
                    # Create profile if it doesn't exist
                    UserProfile.objects.create(
                        user=post.author,
                        post_count=1
                    )
                
                # Migrate comments
                for comment in Comment.objects.filter(post=post):
                    if not hasattr(comment, 'approved'):
                        # Assume old comments are approved
                        comment.approved = True
                        comment.save()
        
        return cross_app_migration
    
    @staticmethod
    def version_aware_migrations():
        """Create migrations that are aware of Django/app versions"""
        
        def version_aware_migration(apps, schema_editor):
            """Migration that behaves differently based on versions"""
            
            import django
            
            Post = apps.get_model('blog', 'Post')
            
            # Different behavior based on Django version
            if django.VERSION >= (3, 2):
                # Use newer Django features
                Post.objects.bulk_update(
                    [post for post in Post.objects.all()],
                    ['updated_at'],
                    batch_size=1000
                )
            else:
                # Fallback for older Django versions
                for post in Post.objects.all():
                    post.updated_at = timezone.now()
                    post.save()
            
            # Check for app-specific features
            try:
                # Try to use a feature that might not exist in older versions
                Post.objects.filter(status='draft').update(
                    status='published',
                    published_at=timezone.now()
                )
            except Exception as e:
                # Fallback for older app versions
                print(f"Using fallback migration approach: {e}")
                
                for post in Post.objects.filter(status='draft'):
                    post.status = 'published'
                    if hasattr(post, 'published_at'):
                        post.published_at = timezone.now()
                    post.save()
        
        return version_aware_migration
    
    @staticmethod
    def historical_model_introspection():
        """Introspect historical models to understand their structure"""
        
        def introspective_migration(apps, schema_editor):
            """Migration that adapts based on model structure"""
            
            Post = apps.get_model('blog', 'Post')
            
            # Get model metadata
            model_meta = Post._meta
            
            # Inspect available fields
            field_names = [field.name for field in model_meta.fields]
            
            print(f"Available fields in Post model: {field_names}")
            
            # Adapt migration based on available fields
            migration_actions = []
            
            if 'slug' in field_names:
                migration_actions.append('populate_slugs')
            
            if 'view_count' in field_names:
                migration_actions.append('initialize_view_counts')
            
            if 'tags' in [field.name for field in model_meta.many_to_many]:
                migration_actions.append('assign_default_tags')
            
            # Execute appropriate actions
            for action in migration_actions:
                if action == 'populate_slugs':
                    for post in Post.objects.filter(slug__isnull=True):
                        post.slug = slugify(post.title)
                        post.save()
                
                elif action == 'initialize_view_counts':
                    Post.objects.filter(view_count__isnull=True).update(
                        view_count=0
                    )
                
                elif action == 'assign_default_tags':
                    Tag = apps.get_model('blog', 'Tag')
                    default_tag, created = Tag.objects.get_or_create(
                        name='general'
                    )
                    
                    for post in Post.objects.filter(tags__isnull=True):
                        post.tags.add(default_tag)
        
        return introspective_migration

# Historical model debugging and troubleshooting
class HistoricalModelDebugging:
    """Debug issues with historical models"""
    
    @staticmethod
    def debug_historical_model_state():
        """Debug historical model state issues"""
        
        def debug_migration(apps, schema_editor):
            """Debug migration with detailed logging"""
            
            import logging
            
            logger = logging.getLogger(__name__)
            
            try:
                Post = apps.get_model('blog', 'Post')
                
                # Log model information
                logger.info(f"Post model: {Post}")
                logger.info(f"Post._meta: {Post._meta}")
                logger.info(f"Available fields: {[f.name for f in Post._meta.fields]}")
                
                # Test field access
                sample_post = Post.objects.first()
                
                if sample_post:
                    logger.info(f"Sample post ID: {sample_post.id}")
                    
                    # Try accessing each field
                    for field in Post._meta.fields:
                        try:
                            value = getattr(sample_post, field.name)
                            logger.info(f"Field {field.name}: {value}")
                        except Exception as e:
                            logger.error(f"Error accessing field {field.name}: {e}")
                
                # Perform actual migration
                for post in Post.objects.all():
                    # Your migration logic here
                    pass
                
            except Exception as e:
                logger.error(f"Migration failed: {e}")
                
                # Log additional debugging information
                logger.error(f"Available apps: {list(apps.all_models.keys())}")
                
                if 'blog' in apps.all_models:
                    logger.error(f"Blog models: {list(apps.all_models['blog'].keys())}")
                
                raise
        
        return debug_migration
    
    @staticmethod
    def validate_historical_model_consistency():
        """Validate consistency of historical models"""
        
        def validation_migration(apps, schema_editor):
            """Validate model state before proceeding"""
            
            validation_errors = []
            
            try:
                Post = apps.get_model('blog', 'Post')
                
                # Validate required fields exist
                required_fields = ['title', 'content']
                available_fields = [f.name for f in Post._meta.fields]
                
                for field in required_fields:
                    if field not in available_fields:
                        validation_errors.append(
                            f"Required field '{field}' not found in Post model"
                        )
                
                # Validate data consistency
                if Post.objects.exists():
                    # Check for null values in required fields
                    for field in required_fields:
                        if field in available_fields:
                            null_count = Post.objects.filter(**{f"{field}__isnull": True}).count()
                            
                            if null_count > 0:
                                validation_errors.append(
                                    f"Found {null_count} posts with null {field}"
                                )
                
                # Validate relationships
                if 'author' in available_fields:
                    orphaned_posts = Post.objects.filter(author__isnull=True).count()
                    
                    if orphaned_posts > 0:
                        validation_errors.append(
                            f"Found {orphaned_posts} posts without authors"
                        )
                
                if validation_errors:
                    error_message = "Validation failed:\n" + "\n".join(validation_errors)
                    raise ValueError(error_message)
                
                print("Historical model validation passed")
                
            except Exception as e:
                print(f"Validation error: {e}")
                raise
        
        return validation_migration

class HistoricalModelBestPractices:
    """Best practices for working with historical models"""
    
    @staticmethod
    def create_robust_data_migration():
        """Create robust data migration using best practices"""
        
        def robust_migration(apps, schema_editor):
            """Robust data migration following best practices"""
            
            # 1. Always use apps.get_model() instead of importing models
            Post = apps.get_model('blog', 'Post')
            Category = apps.get_model('blog', 'Category')
            
            # 2. Check if migration is needed
            posts_to_migrate = Post.objects.filter(
                # Condition that identifies posts needing migration
                status__isnull=True
            ).count()
            
            if posts_to_migrate == 0:
                print("No posts need migration, skipping")
                return
            
            print(f"Migrating {posts_to_migrate} posts")
            
            # 3. Handle missing related objects gracefully
            default_category = None
            
            try:
                default_category = Category.objects.get(name='Default')
            except Category.DoesNotExist:
                default_category = Category.objects.create(
                    name='Default',
                    description='Default category for migrated posts'
                )
            
            # 4. Use transactions for data integrity
            from django.db import transaction
            
            with transaction.atomic():
                # 5. Process in batches for large datasets
                batch_size = 1000
                processed = 0
                
                while processed < posts_to_migrate:
                    batch = Post.objects.filter(
                        status__isnull=True
                    )[processed:processed + batch_size]
                    
                    posts_to_update = []
                    
                    for post in batch:
                        # 6. Validate data before processing
                        if not post.title:
                            print(f"Skipping post {post.id} - no title")
                            continue
                        
                        # 7. Set appropriate defaults
                        post.status = 'draft'
                        
                        if not hasattr(post, 'category') or not post.category:
                            post.category = default_category
                        
                        posts_to_update.append(post)
                    
                    # 8. Use bulk operations when possible
                    if posts_to_update:
                        Post.objects.bulk_update(
                            posts_to_update,
                            ['status', 'category'],
                            batch_size=batch_size
                        )
                    
                    processed += len(batch)
                    print(f"Processed {processed}/{posts_to_migrate} posts")
            
            print("Migration completed successfully")
        
        return robust_migration
    
    @staticmethod
    def create_reversible_data_migration():
        """Create reversible data migration"""
        
        def forward_migration(apps, schema_editor):
            """Forward data migration"""
            
            Post = apps.get_model('blog', 'Post')
            
            # Store original values for reversal
            from django.core.cache import cache
            
            original_values = []
            
            for post in Post.objects.filter(status='draft'):
                original_values.append({
                    'id': post.id,
                    'original_status': post.status
                })
                
                post.status = 'published'
                post.save()
            
            # Store for reversal (in production, use database table)
            cache.set('migration_original_values', original_values, timeout=86400)
        
        def reverse_migration(apps, schema_editor):
            """Reverse data migration"""
            
            Post = apps.get_model('blog', 'Post')
            
            # Restore original values
            from django.core.cache import cache
            
            original_values = cache.get('migration_original_values', [])
            
            for item in original_values:
                try:
                    post = Post.objects.get(id=item['id'])
                    post.status = item['original_status']
                    post.save()
                except Post.DoesNotExist:
                    print(f"Post {item['id']} no longer exists")
            
            # Clean up
            cache.delete('migration_original_values')
        
        return forward_migration, reverse_migration
    
    @staticmethod
    def handle_model_evolution():
        """Handle model evolution across migrations"""
        
        def evolution_aware_migration(apps, schema_editor):
            """Migration that handles model evolution"""
            
            Post = apps.get_model('blog', 'Post')
            
            # Get current model state
            model_fields = {field.name: field for field in Post._meta.fields}
            
            # Handle different model evolution scenarios
            
            # Scenario 1: Field was renamed
            if 'new_title' in model_fields and 'title' not in model_fields:
                # Field was renamed from 'title' to 'new_title'
                # This migration runs after the rename
                print("Detected title field rename")
            
            # Scenario 2: Field type changed
            if 'status' in model_fields:
                status_field = model_fields['status']
                
                if hasattr(status_field, 'choices') and status_field.choices:
                    # Status field now has choices - validate existing data
                    valid_choices = [choice[0] for choice in status_field.choices]
                    
                    invalid_posts = Post.objects.exclude(
                        status__in=valid_choices
                    )
                    
                    for post in invalid_posts:
                        print(f"Fixing invalid status '{post.status}' for post {post.id}")
                        post.status = 'draft'  # Default to draft
                        post.save()
            
            # Scenario 3: New required field added
            if 'slug' in model_fields:
                slug_field = model_fields['slug']
                
                if not slug_field.null and not slug_field.blank:
                    # Slug is required - populate for existing posts
                    posts_without_slug = Post.objects.filter(
                        slug__isnull=True
                    )
                    
                    for post in posts_without_slug:
                        post.slug = slugify(post.title) if hasattr(post, 'title') else f'post-{post.id}'
                        post.save()
        
        return evolution_aware_migration