# Basic session concept
class SessionConcept:
    """Understanding how sessions work conceptually"""
    
    @staticmethod
    def session_lifecycle():
        """Complete session lifecycle"""
        
        lifecycle_steps = {
            'initialization': {
                'trigger': 'First request from new user',
                'action': 'Create new session object',
                'result': 'Unique session ID generated'
            },
            'identification': {
                'trigger': 'Session ID sent to client',
                'action': 'Store session ID in cookie',
                'result': 'Client can be identified on future requests'
            },
            'data_storage': {
                'trigger': 'Application needs to store user data',
                'action': 'Store data server-side with session ID',
                'result': 'Data persists across requests'
            },
            'retrieval': {
                'trigger': 'Subsequent requests from same user',
                'action': 'Load session data using session ID',
                'result': 'Application has access to user state'
            },
            'expiration': {
                'trigger': 'Session timeout or explicit logout',
                'action': 'Delete session data and invalidate ID',
                'result': 'User state is cleared'
            }
        }
        
        return lifecycle_steps
    
    @staticmethod
    def session_vs_cookies():
        """Compare sessions with cookies"""
        
        comparison = {
            'storage_location': {
                'sessions': 'Server-side (database, cache, files)',
                'cookies': 'Client-side (browser)'
            },
            'security': {
                'sessions': 'More secure - data not visible to client',
                'cookies': 'Less secure - data visible and modifiable'
            },
            'capacity': {
                'sessions': 'Large capacity (limited by server resources)',
                'cookies': 'Small capacity (4KB limit per cookie)'
            },
            'performance': {
                'sessions': 'Server overhead for storage and retrieval',
                'cookies': 'Network overhead for transmission'
            },
            'persistence': {
                'sessions': 'Depends on server configuration',
                'cookies': 'Can persist across browser sessions'
            },
            'scalability': {
                'sessions': 'Requires session sharing in multi-server setup',
                'cookies': 'No server-side storage requirements'
            }
        }
        
        return comparison

# Django session implementation
class DjangoSessionImplementation:
    """How Django implements sessions"""
    
    @staticmethod
    def session_middleware_flow():
        """How SessionMiddleware processes requests"""
        
        middleware_flow = """
        1. Request Processing:
           - Extract session ID from cookie
           - Load session data from backend
           - Create request.session object
           - Make session available to views
        
        2. View Processing:
           - Views can read/write session data
           - Changes tracked automatically
           - Session marked as modified if needed
        
        3. Response Processing:
           - Save session data to backend
           - Set/update session cookie if needed
           - Handle session expiration
           - Clean up temporary data
        """
        
        return middleware_flow
    
    @staticmethod
    def session_key_generation():
        """How Django generates session keys"""
        
        key_generation_process = {
            'algorithm': 'Random string generation',
            'length': '32 characters',
            'character_set': 'Alphanumeric (a-z, A-Z, 0-9)',
            'uniqueness': 'Checked against existing sessions',
            'security': 'Cryptographically secure random generator',
            'example': 'abc123def456ghi789jkl012mno345pqr'
        }
        
        return key_generation_process

# settings.py configuration for sessions
SESSION_CONFIGURATION = {
    # Session engine - where session data is stored
    'SESSION_ENGINE': 'django.contrib.sessions.backends.db',
    
    # Session cookie settings
    'SESSION_COOKIE_NAME': 'sessionid',
    'SESSION_COOKIE_AGE': 1209600,  # 2 weeks in seconds
    'SESSION_COOKIE_DOMAIN': None,
    'SESSION_COOKIE_SECURE': False,  # Set to True in production with HTTPS
    'SESSION_COOKIE_HTTPONLY': True,
    'SESSION_COOKIE_SAMESITE': 'Lax',
    'SESSION_COOKIE_PATH': '/',
    
    # Session behavior
    'SESSION_EXPIRE_AT_BROWSER_CLOSE': False,
    'SESSION_SAVE_EVERY_REQUEST': False,
    
    # Security
    'SESSION_SERIALIZER': 'django.contrib.sessions.serializers.JSONSerializer'
}

# Middleware configuration
MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',  # Required for sessions
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

# Required app for database sessions
INSTALLED_APPS = [
    'django.contrib.sessions',  # Required for session support
    # ... other apps
]

class SessionBackends:
    """Different session storage backends"""
    
    @staticmethod
    def database_backend():
        """Database session backend (default)"""
        
        config = {
            'engine': 'django.contrib.sessions.backends.db',
            'description': 'Store sessions in database table',
            'table': 'django_session',
            'pros': [
                'Persistent storage',
                'Reliable and consistent',
                'Good for most applications',
                'Supports complex data types'
            ],
            'cons': [
                'Database I/O overhead',
                'Requires periodic cleanup',
                'Can become bottleneck at scale'
            ],
            'setup': """
            # Run migrations to create session table
            python manage.py migrate
            
            # Optional: Create custom session model
            class CustomSession(AbstractBaseSession):
                account_id = models.IntegerField(null=True, db_index=True)
                
                @classmethod
                def get_session_store_class(cls):
                    return SessionStore
            """
        }
        
        return config
    
    @staticmethod
    def cache_backend():
        """Cache-based session backend"""
        
        config = {
            'engine': 'django.contrib.sessions.backends.cache',
            'description': 'Store sessions in cache system',
            'pros': [
                'Very fast access',
                'Automatic expiration',
                'No database overhead',
                'Memory efficient'
            ],
            'cons': [
                'Not persistent across restarts',
                'Can lose data if cache is full',
                'Requires cache configuration'
            ],
            'setup': """
            # Configure cache in settings.py
            CACHES = {
                'default': {
                    'BACKEND': 'django.core.cache.backends.redis.RedisCache',
                    'LOCATION': 'redis://127.0.0.1:6379/1',
                }
            }
            
            # Set session engine
            SESSION_ENGINE = 'django.contrib.sessions.backends.cache'
            SESSION_CACHE_ALIAS = 'default'
            """
        }
        
        return config
    
    @staticmethod
    def cached_db_backend():
        """Cached database backend (hybrid)"""
        
        config = {
            'engine': 'django.contrib.sessions.backends.cached_db',
            'description': 'Cache with database fallback',
            'pros': [
                'Fast cache access',
                'Database persistence',
                'Best of both worlds',
                'Fault tolerant'
            ],
            'cons': [
                'More complex setup',
                'Higher resource usage',
                'Potential cache/DB inconsistency'
            ],
            'setup': """
            # Requires both cache and database
            SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db'
            
            # Cache configuration
            CACHES = {
                'default': {
                    'BACKEND': 'django.core.cache.backends.redis.RedisCache',
                    'LOCATION': 'redis://127.0.0.1:6379/1',
                }
            }
            """
        }
        
        return config
    
    @staticmethod
    def file_backend():
        """File-based session backend"""
        
        config = {
            'engine': 'django.contrib.sessions.backends.file',
            'description': 'Store sessions as files on disk',
            'pros': [
                'Simple setup',
                'No database required',
                'Persistent storage',
                'Good for development'
            ],
            'cons': [
                'File system I/O overhead',
                'Requires file cleanup',
                'Not suitable for multiple servers'
            ],
            'setup': """
            SESSION_ENGINE = 'django.contrib.sessions.backends.file'
            SESSION_FILE_PATH = '/var/lib/django/sessions'  # Optional custom path
            
            # Ensure directory exists and is writable
            import os
            os.makedirs('/var/lib/django/sessions', exist_ok=True)
            """
        }
        
        return config
    
    @staticmethod
    def signed_cookies_backend():
        """Signed cookies backend (client-side storage)"""
        
        config = {
            'engine': 'django.contrib.sessions.backends.signed_cookies',
            'description': 'Store session data in signed cookies',
            'pros': [
                'No server-side storage',
                'Stateless application',
                'Scales horizontally',
                'Simple deployment'
            ],
            'cons': [
                'Limited data size (4KB)',
                'Data visible to client',
                'Network overhead',
                'Security considerations'
            ],
            'setup': """
            SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies'
            
            # Ensure SECRET_KEY is set and secure
            SECRET_KEY = 'your-secret-key-here'
            
            # Consider cookie security settings
            SESSION_COOKIE_HTTPONLY = True
            SESSION_COOKIE_SECURE = True  # HTTPS only
            """
        }
        
        return config

# Basic session usage in views
def session_examples(request):
    """Examples of basic session operations"""
    
    # Setting session data
    request.session['username'] = 'john_doe'
    request.session['preferences'] = {
        'theme': 'dark',
        'language': 'en',
        'notifications': True
    }
    
    # Getting session data
    username = request.session.get('username')
    theme = request.session.get('preferences', {}).get('theme', 'light')
    
    # Checking if key exists
    if 'username' in request.session:
        print(f"User {request.session['username']} is logged in")
    
    # Deleting session data
    if 'temporary_data' in request.session:
        del request.session['temporary_data']
    
    # Pop with default value
    last_page = request.session.pop('last_page', '/')
    
    # Clear all session data
    # request.session.clear()  # Keeps session ID
    # request.session.flush()  # Deletes session completely
    
    return HttpResponse("Session operations completed")

# Session modification tracking
def session_modification_examples(request):
    """Examples of session modification tracking"""
    
    # For mutable objects, you need to explicitly mark as modified
    cart = request.session.get('cart', [])
    cart.append({'product_id': 123, 'quantity': 1})
    
    # This is required for mutable objects
    request.session['cart'] = cart
    request.session.modified = True
    
    # Alternative: modify in place and mark as modified
    if 'preferences' not in request.session:
        request.session['preferences'] = {}
    
    request.session['preferences']['new_setting'] = 'value'
    request.session.modified = True
    
    # Or use setdefault for cleaner code
    preferences = request.session.setdefault('preferences', {})
    preferences['another_setting'] = 'another_value'
    request.session.modified = True
    
    return HttpResponse("Session modifications tracked")

# Session expiration and security
def session_security_examples(request):
    """Examples of session security operations"""
    
    # Set session expiry
    request.session.set_expiry(300)  # 5 minutes from now
    request.session.set_expiry(0)    # Expire when browser closes
    request.session.set_expiry(None) # Use global session timeout
    
    # Get session expiry
    expiry_age = request.session.get_expiry_age()
    expiry_date = request.session.get_expiry_date()
    
    # Cycle session key (security measure)
    request.session.cycle_key()
    
    # Check if session is empty
    if request.session.is_empty():
        print("Session has no data")
    
    # Get session key
    session_key = request.session.session_key
    
    return HttpResponse(f"Session key: {session_key}")

# Session-based user preferences
class UserPreferencesManager:
    """Manage user preferences using sessions"""
    
    @staticmethod
    def get_preferences(request):
        """Get user preferences with defaults"""
        
        default_preferences = {
            'theme': 'light',
            'language': 'en',
            'timezone': 'UTC',
            'items_per_page': 20,
            'notifications': {
                'email': True,
                'push': False,
                'sms': False
            }
        }
        
        preferences = request.session.get('preferences', {})
        
        # Merge with defaults
        for key, default_value in default_preferences.items():
            if key not in preferences:
                preferences[key] = default_value
        
        return preferences
    
    @staticmethod
    def update_preference(request, key, value):
        """Update a specific preference"""
        
        preferences = request.session.setdefault('preferences', {})
        
        # Handle nested keys (e.g., 'notifications.email')
        if '.' in key:
            keys = key.split('.')
            current = preferences
            
            for k in keys[:-1]:
                current = current.setdefault(k, {})
            
            current[keys[-1]] = value
        else:
            preferences[key] = value
        
        request.session.modified = True
        
        return preferences
    
    @staticmethod
    def reset_preferences(request):
        """Reset preferences to defaults"""
        
        if 'preferences' in request.session:
            del request.session['preferences']
        
        return UserPreferencesManager.get_preferences(request)

# Session-based wizard/multi-step forms
class FormWizardSession:
    """Manage multi-step form data in sessions"""
    
    def __init__(self, request, wizard_name):
        self.request = request
        self.wizard_name = wizard_name
        self.session_key = f'wizard_{wizard_name}'
    
    def get_wizard_data(self):
        """Get all wizard data"""
        return self.request.session.get(self.session_key, {})
    
    def set_step_data(self, step, data):
        """Set data for a specific step"""
        wizard_data = self.get_wizard_data()
        wizard_data[f'step_{step}'] = data
        wizard_data['current_step'] = step
        wizard_data['updated_at'] = timezone.now().isoformat()
        
        self.request.session[self.session_key] = wizard_data
        self.request.session.modified = True
    
    def get_step_data(self, step):
        """Get data for a specific step"""
        wizard_data = self.get_wizard_data()
        return wizard_data.get(f'step_{step}', {})
    
    def get_current_step(self):
        """Get current step number"""
        wizard_data = self.get_wizard_data()
        return wizard_data.get('current_step', 1)
    
    def clear_wizard(self):
        """Clear all wizard data"""
        if self.session_key in self.request.session:
            del self.request.session[self.session_key]
    
    def is_step_completed(self, step):
        """Check if a step is completed"""
        return f'step_{step}' in self.get_wizard_data()
    
    def get_completed_steps(self):
        """Get list of completed steps"""
        wizard_data = self.get_wizard_data()
        steps = []
        
        for key in wizard_data.keys():
            if key.startswith('step_'):
                step_num = int(key.split('_')[1])
                steps.append(step_num)
        
        return sorted(steps)

# Usage example for form wizard
def registration_wizard_step_1(request):
    """First step of registration wizard"""
    
    wizard = FormWizardSession(request, 'registration')
    
    if request.method == 'POST':
        form = PersonalInfoForm(request.POST)
        
        if form.is_valid():
            wizard.set_step_data(1, form.cleaned_data)
            return redirect('registration_step_2')
    else:
        # Load existing data if available
        initial_data = wizard.get_step_data(1)
        form = PersonalInfoForm(initial=initial_data)
    
    context = {
        'form': form,
        'current_step': 1,
        'total_steps': 3,
        'completed_steps': wizard.get_completed_steps()
    }
    
    return render(request, 'registration/step1.html', context)

class SessionPerformance:
    """Session performance optimization techniques"""
    
    @staticmethod
    def minimize_session_data():
        """Best practices for session data management"""
        
        best_practices = {
            'data_size': [
                'Store only essential data in sessions',
                'Use references (IDs) instead of full objects',
                'Compress large data before storing',
                'Clean up unused session keys regularly'
            ],
            'data_structure': [
                'Use simple data types when possible',
                'Avoid deeply nested structures',
                'Consider using separate cache for large objects',
                'Use database for persistent user data'
            ],
            'access_patterns': [
                'Minimize session reads/writes per request',
                'Batch session operations when possible',
                'Use lazy loading for session data',
                'Cache frequently accessed session data'
            ]
        }
        
        return best_practices
    
    @staticmethod
    def session_optimization_examples():
        """Examples of session optimization"""
        
        # Bad: Storing full user object
        def bad_session_usage(request, user):
            request.session['user_data'] = {
                'id': user.id,
                'username': user.username,
                'email': user.email,
                'profile': user.profile.__dict__,
                'permissions': list(user.get_all_permissions()),
                'groups': [g.__dict__ for g in user.groups.all()]
            }
        
        # Good: Storing minimal data
        def good_session_usage(request, user):
            request.session['user_id'] = user.id
            request.session['username'] = user.username
            # Load other data from database when needed
        
        # Efficient session data access
        def efficient_session_access(request):
            # Cache session data in request for multiple access
            if not hasattr(request, '_cached_preferences'):
                request._cached_preferences = request.session.get('preferences', {})
            
            return request._cached_preferences
        
        return {
            'bad_example': bad_session_usage,
            'good_example': good_session_usage,
            'efficient_access': efficient_session_access
        }
    
    @staticmethod
    def session_cleanup_strategies():
        """Strategies for session cleanup"""
        
        cleanup_strategies = {
            'automatic_cleanup': {
                'description': 'Built-in Django session cleanup',
                'command': 'python manage.py clearsessions',
                'frequency': 'Daily via cron job',
                'implementation': """
                # Add to crontab
                0 2 * * * /path/to/venv/bin/python /path/to/project/manage.py clearsessions
                """
            },
            'custom_cleanup': {
                'description': 'Custom cleanup with additional logic',
                'implementation': """
                from django.core.management.base import BaseCommand
                from django.contrib.sessions.models import Session
                from django.utils import timezone
                
                class Command(BaseCommand):
                    def handle(self, *args, **options):
                        # Clean expired sessions
                        expired = Session.objects.filter(expire_date__lt=timezone.now())
                        count = expired.count()
                        expired.delete()
                        
                        # Clean orphaned data
                        self.cleanup_orphaned_data()
                        
                        self.stdout.write(f'Cleaned {count} expired sessions')
                """
            },
            'selective_cleanup': {
                'description': 'Clean sessions based on criteria',
                'implementation': """
                # Clean sessions older than 30 days regardless of expiry
                old_sessions = Session.objects.filter(
                    expire_date__lt=timezone.now() - timedelta(days=30)
                )
                old_sessions.delete()
                
                # Clean sessions with specific patterns
                inactive_sessions = Session.objects.filter(
                    session_data__contains='inactive_user'
                )
                inactive_sessions.delete()
                """
            }
        }
        
        return cleanup_strategies