MongoDB Distributed Caching and Session Management: High-Performance Web Application State Management and Cache Optimization

-- Traditional PostgreSQL session storage - limited scalability and complex cleanup
CREATE TABLE user_sessions (
    session_id VARCHAR(128) PRIMARY KEY,
    user_id BIGINT NOT NULL,
    session_data JSONB NOT NULL,

    -- Session lifecycle management
    created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
    last_accessed TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
    expires_at TIMESTAMPTZ NOT NULL,

    -- Session metadata
    ip_address INET,
    user_agent TEXT,
    device_fingerprint VARCHAR(256),

    -- Security and fraud detection
    login_method VARCHAR(50),
    mfa_verified BOOLEAN DEFAULT FALSE,
    risk_score DECIMAL(3,2) DEFAULT 0.0,

    -- Application state
    active BOOLEAN DEFAULT TRUE,
    invalidated_at TIMESTAMPTZ,
    invalidation_reason VARCHAR(100)
);

-- Manual session cleanup (requires scheduled maintenance)
CREATE OR REPLACE FUNCTION cleanup_expired_sessions()
RETURNS INTEGER AS $$
DECLARE
    deleted_count INTEGER;
BEGIN
    -- Delete expired sessions
    DELETE FROM user_sessions 
    WHERE expires_at < CURRENT_TIMESTAMP
       OR (active = FALSE AND invalidated_at < CURRENT_TIMESTAMP - INTERVAL '1 day');

    GET DIAGNOSTICS deleted_count = ROW_COUNT;

    -- Log cleanup activity
    INSERT INTO session_cleanup_log (cleanup_date, sessions_deleted)
    VALUES (CURRENT_TIMESTAMP, deleted_count);

    RETURN deleted_count;
END;
$$ LANGUAGE plpgsql;

-- Complex cache table design with manual expiration
CREATE TABLE application_cache (
    cache_key VARCHAR(512) PRIMARY KEY,
    cache_namespace VARCHAR(100) NOT NULL,
    cache_data JSONB NOT NULL,

    -- Expiration management
    created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
    expires_at TIMESTAMPTZ NOT NULL,
    last_accessed TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,

    -- Cache metadata
    data_size INTEGER,
    cache_tags TEXT[],
    cache_version VARCHAR(50),

    -- Usage statistics
    hit_count BIGINT DEFAULT 0,
    miss_count BIGINT DEFAULT 0,
    invalidation_count INTEGER DEFAULT 0
);

-- Indexing for cache lookups (expensive maintenance overhead)
CREATE INDEX idx_cache_namespace_key ON application_cache (cache_namespace, cache_key);
CREATE INDEX idx_cache_expires_at ON application_cache (expires_at);
CREATE INDEX idx_cache_tags ON application_cache USING GIN (cache_tags);
CREATE INDEX idx_cache_last_accessed ON application_cache (last_accessed);

-- Manual cache invalidation logic (complex and error-prone)
CREATE OR REPLACE FUNCTION invalidate_cache_by_tags(tag_names TEXT[])
RETURNS INTEGER AS $$
DECLARE
    invalidated_count INTEGER;
BEGIN
    -- Invalidate cache entries with matching tags
    DELETE FROM application_cache 
    WHERE cache_tags && tag_names;

    GET DIAGNOSTICS invalidated_count = ROW_COUNT;

    -- Update invalidation statistics
    UPDATE cache_statistics 
    SET tag_invalidations = tag_invalidations + invalidated_count,
        last_invalidation = CURRENT_TIMESTAMP
    WHERE stat_date = CURRENT_DATE;

    RETURN invalidated_count;
END;
$$ LANGUAGE plpgsql;

-- Session data queries with complex join logic
WITH active_sessions AS (
    SELECT 
        us.session_id,
        us.user_id,
        us.session_data,
        us.last_accessed,
        us.expires_at,
        us.ip_address,
        us.device_fingerprint,

        -- Calculate session duration
        EXTRACT(EPOCH FROM us.last_accessed - us.created_at) / 3600 as session_hours,

        -- Determine session freshness
        CASE 
            WHEN us.last_accessed > CURRENT_TIMESTAMP - INTERVAL '15 minutes' THEN 'active'
            WHEN us.last_accessed > CURRENT_TIMESTAMP - INTERVAL '1 hour' THEN 'recent'
            WHEN us.last_accessed > CURRENT_TIMESTAMP - INTERVAL '6 hours' THEN 'idle'
            ELSE 'stale'
        END as session_status,

        -- Extract user preferences from session data
        us.session_data->>'preferences' as user_preferences,
        us.session_data->>'shopping_cart' as shopping_cart,
        us.session_data->>'last_page' as last_page

    FROM user_sessions us
    WHERE us.active = TRUE 
    AND us.expires_at > CURRENT_TIMESTAMP
),

session_analytics AS (
    SELECT 
        COUNT(*) as total_active_sessions,
        COUNT(DISTINCT user_id) as unique_users,
        AVG(session_hours) as avg_session_duration,

        COUNT(*) FILTER (WHERE session_status = 'active') as active_sessions,
        COUNT(*) FILTER (WHERE session_status = 'recent') as recent_sessions,
        COUNT(*) FILTER (WHERE session_status = 'idle') as idle_sessions,
        COUNT(*) FILTER (WHERE session_status = 'stale') as stale_sessions,

        -- Risk analysis
        COUNT(*) FILTER (WHERE risk_score > 0.7) as high_risk_sessions,
        COUNT(DISTINCT ip_address) as unique_ip_addresses,

        -- Application state analysis
        COUNT(*) FILTER (WHERE shopping_cart IS NOT NULL) as sessions_with_cart,
        AVG(CAST(shopping_cart->>'item_count' AS INTEGER)) as avg_cart_items

    FROM active_sessions
)

SELECT 
    'Session Management Report' as report_type,
    CURRENT_TIMESTAMP as generated_at,

    -- Session statistics
    sa.total_active_sessions,
    sa.unique_users,
    ROUND(sa.avg_session_duration::NUMERIC, 2) as avg_session_hours,

    -- Session distribution
    JSON_BUILD_OBJECT(
        'active', sa.active_sessions,
        'recent', sa.recent_sessions, 
        'idle', sa.idle_sessions,
        'stale', sa.stale_sessions
    ) as session_distribution,

    -- Security metrics
    sa.high_risk_sessions,
    sa.unique_ip_addresses,
    ROUND((sa.high_risk_sessions::FLOAT / sa.total_active_sessions * 100)::NUMERIC, 2) as risk_percentage,

    -- Business metrics
    sa.sessions_with_cart,
    ROUND(sa.avg_cart_items::NUMERIC, 1) as avg_cart_items,
    ROUND((sa.sessions_with_cart::FLOAT / sa.total_active_sessions * 100)::NUMERIC, 2) as cart_conversion_rate

FROM session_analytics sa;

-- Cache performance queries (limited analytics capabilities)
WITH cache_performance AS (
    SELECT 
        cache_namespace,
        COUNT(*) as total_entries,
        SUM(data_size) as total_size_bytes,
        AVG(data_size) as avg_entry_size,

        -- Hit ratio calculation
        SUM(hit_count) as total_hits,
        SUM(miss_count) as total_misses,
        CASE 
            WHEN SUM(hit_count + miss_count) > 0 THEN
                ROUND((SUM(hit_count)::FLOAT / SUM(hit_count + miss_count) * 100)::NUMERIC, 2)
            ELSE 0
        END as hit_ratio_percent,

        -- Expiration analysis
        COUNT(*) FILTER (WHERE expires_at <= CURRENT_TIMESTAMP) as expired_entries,
        COUNT(*) FILTER (WHERE expires_at > CURRENT_TIMESTAMP + INTERVAL '1 hour') as long_lived_entries,

        -- Access patterns
        AVG(hit_count) as avg_hits_per_entry,
        MAX(last_accessed) as most_recent_access,
        MIN(last_accessed) as oldest_access

    FROM application_cache
    GROUP BY cache_namespace
)

SELECT 
    cp.cache_namespace,
    cp.total_entries,
    ROUND((cp.total_size_bytes / 1024.0 / 1024.0)::NUMERIC, 2) as size_mb,
    ROUND(cp.avg_entry_size::NUMERIC, 0) as avg_entry_size_bytes,
    cp.hit_ratio_percent,
    cp.expired_entries,
    cp.long_lived_entries,
    cp.avg_hits_per_entry,

    -- Cache efficiency assessment
    CASE 
        WHEN cp.hit_ratio_percent > 90 THEN 'excellent'
        WHEN cp.hit_ratio_percent > 70 THEN 'good'
        WHEN cp.hit_ratio_percent > 50 THEN 'acceptable'
        ELSE 'poor'
    END as cache_efficiency,

    -- Recommendations
    CASE 
        WHEN cp.expired_entries > cp.total_entries * 0.1 THEN 'Consider shorter TTL or more frequent cleanup'
        WHEN cp.hit_ratio_percent < 50 THEN 'Review caching strategy and key patterns'
        WHEN cp.avg_entry_size > 1048576 THEN 'Consider data compression or smaller cache objects'
        ELSE 'Cache performance within normal parameters'
    END as recommendation

FROM cache_performance cp
ORDER BY cp.total_entries DESC;

-- Problems with traditional cache and session management:
-- 1. Manual expiration cleanup with potential for orphaned data
-- 2. Complex indexing strategies and maintenance overhead
-- 3. Limited scalability for high-concurrency web applications
-- 4. No built-in distributed consistency or replication
-- 5. Complex cache invalidation logic prone to race conditions
-- 6. Separate infrastructure requirements for cache and session stores
-- 7. Limited analytics and monitoring capabilities
-- 8. Manual session lifecycle management and security tracking
-- 9. No automatic compression or storage optimization
-- 10. Complex failover and disaster recovery procedures

// MongoDB Distributed Caching and Session Management System
const { MongoClient, ObjectId } = require('mongodb');

const client = new MongoClient('mongodb://localhost:27017/?replicaSet=rs0');
const db = client.db('distributed_cache_system');

// Comprehensive MongoDB Caching and Session Manager
class AdvancedCacheSessionManager {
  constructor(db, config = {}) {
    this.db = db;
    this.collections = {
      userSessions: db.collection('user_sessions'),
      applicationCache: db.collection('application_cache'),
      cacheStatistics: db.collection('cache_statistics'),
      sessionEvents: db.collection('session_events'),
      cacheMetrics: db.collection('cache_metrics'),
      deviceFingerprints: db.collection('device_fingerprints')
    };

    // Advanced configuration
    this.config = {
      // Session management
      defaultSessionTTL: config.defaultSessionTTL || 7200, // 2 hours
      extendedSessionTTL: config.extendedSessionTTL || 86400, // 24 hours for "remember me"
      maxSessionsPerUser: config.maxSessionsPerUser || 10,
      sessionCleanupInterval: config.sessionCleanupInterval || 300, // 5 minutes

      // Cache management
      defaultCacheTTL: config.defaultCacheTTL || 3600, // 1 hour
      maxCacheSize: config.maxCacheSize || 16 * 1024 * 1024, // 16MB per entry
      enableCompression: config.enableCompression !== false,
      enableDistribution: config.enableDistribution !== false,

      // Security settings
      enableDeviceTracking: config.enableDeviceTracking !== false,
      enableRiskScoring: config.enableRiskScoring !== false,
      maxRiskScore: config.maxRiskScore || 0.8,
      suspiciousActivityThreshold: config.suspiciousActivityThreshold || 5,

      // Performance optimization
      enableMetrics: config.enableMetrics !== false,
      metricsRetentionDays: config.metricsRetentionDays || 30,
      enableLazyLoading: config.enableLazyLoading !== false,
      cacheWarmupEnabled: config.cacheWarmupEnabled !== false
    };

    // Initialize TTL collections and indexes
    this.initializeCollections();
    this.setupMetricsCollection();
    this.startMaintenanceTasks();
  }

  async initializeCollections() {
    console.log('Initializing MongoDB TTL collections and indexes...');

    try {
      // Configure user sessions collection with TTL
      await this.collections.userSessions.createIndex(
        { "expiresAt": 1 },
        { 
          expireAfterSeconds: 0,
          name: "session_ttl_index"
        }
      );

      // Additional session indexes for performance
      await this.collections.userSessions.createIndexes([
        { key: { sessionId: 1 }, unique: true, name: "session_id_unique" },
        { key: { userId: 1, expiresAt: 1 }, name: "user_active_sessions" },
        { key: { deviceFingerprint: 1 }, name: "device_sessions" },
        { key: { ipAddress: 1, createdAt: 1 }, name: "ip_activity" },
        { key: { riskScore: 1 }, name: "risk_analysis" },
        { key: { "sessionData.shoppingCart.items": 1 }, name: "cart_sessions", sparse: true }
      ]);

      // Configure application cache collection with TTL
      await this.collections.applicationCache.createIndex(
        { "expiresAt": 1 },
        { 
          expireAfterSeconds: 0,
          name: "cache_ttl_index"
        }
      );

      // Cache performance indexes
      await this.collections.applicationCache.createIndexes([
        { key: { cacheKey: 1 }, unique: true, name: "cache_key_unique" },
        { key: { namespace: 1, cacheKey: 1 }, name: "namespace_key_lookup" },
        { key: { tags: 1 }, name: "cache_tags" },
        { key: { lastAccessed: 1 }, name: "access_patterns" },
        { key: { dataSize: 1 }, name: "size_analysis" }
      ]);

      // Cache metrics with TTL for automatic cleanup
      await this.collections.cacheMetrics.createIndex(
        { "timestamp": 1 },
        { 
          expireAfterSeconds: this.config.metricsRetentionDays * 24 * 3600,
          name: "metrics_ttl_index"
        }
      );

      console.log('TTL collections and indexes initialized successfully');

    } catch (error) {
      console.error('Error initializing collections:', error);
      throw error;
    }
  }

  async createUserSession(userId, sessionData, options = {}) {
    console.log(`Creating new session for user: ${userId}`);

    try {
      // Clean up old sessions if user has too many
      await this.enforceSessionLimits(userId);

      // Generate secure session ID
      const sessionId = await this.generateSecureSessionId();

      // Calculate expiration time
      const ttlSeconds = options.rememberMe ? 
        this.config.extendedSessionTTL : 
        this.config.defaultSessionTTL;

      const expiresAt = new Date(Date.now() + (ttlSeconds * 1000));

      // Calculate risk score
      const riskScore = await this.calculateSessionRiskScore(userId, sessionData, options);

      // Create session document
      const session = {
        _id: new ObjectId(),
        sessionId: sessionId,
        userId: userId,

        // Session lifecycle
        createdAt: new Date(),
        lastAccessed: new Date(),
        expiresAt: expiresAt,
        ttlSeconds: ttlSeconds,

        // Session data with flexible structure
        sessionData: {
          preferences: sessionData.preferences || {},
          shoppingCart: sessionData.shoppingCart || { items: [], total: 0 },
          navigation: sessionData.navigation || { lastPage: '/', referrer: null },
          applicationState: sessionData.applicationState || {},
          temporaryData: sessionData.temporaryData || {}
        },

        // Security and device tracking
        ipAddress: options.ipAddress,
        userAgent: options.userAgent,
        deviceFingerprint: await this.generateDeviceFingerprint(options),
        riskScore: riskScore,

        // Authentication metadata
        loginMethod: options.loginMethod || 'password',
        mfaVerified: options.mfaVerified || false,
        loginLocation: options.loginLocation,

        // Session flags
        active: true,
        rememberMe: options.rememberMe || false,

        // Usage statistics
        pageViews: 0,
        actionsPerformed: 0,
        dataTransferred: 0
      };

      // Insert session with automatic TTL handling
      const result = await this.collections.userSessions.insertOne(session);

      // Log session creation event
      await this.logSessionEvent(sessionId, 'session_created', {
        userId: userId,
        riskScore: riskScore,
        ttlSeconds: ttlSeconds,
        rememberMe: options.rememberMe
      });

      // Update device fingerprint tracking
      if (this.config.enableDeviceTracking) {
        await this.updateDeviceTracking(session.deviceFingerprint, userId, sessionId);
      }

      console.log(`Session created successfully: ${sessionId}`);

      return {
        sessionId: sessionId,
        expiresAt: expiresAt,
        riskScore: riskScore,
        success: true
      };

    } catch (error) {
      console.error('Error creating user session:', error);
      throw error;
    }
  }

  async getSessionData(sessionId, options = {}) {
    console.log(`Retrieving session data: ${sessionId}`);

    try {
      // Find active session
      const session = await this.collections.userSessions.findOne({
        sessionId: sessionId,
        active: true,
        expiresAt: { $gt: new Date() }
      });

      if (!session) {
        return { success: false, reason: 'session_not_found' };
      }

      // Update last accessed timestamp
      const updateData = {
        $set: { lastAccessed: new Date() },
        $inc: { 
          pageViews: options.incrementPageView ? 1 : 0,
          actionsPerformed: options.actionPerformed ? 1 : 0
        }
      };

      await this.collections.userSessions.updateOne(
        { sessionId: sessionId },
        updateData
      );

      // Check for risk score updates
      if (this.config.enableRiskScoring && options.updateRiskScore) {
        const newRiskScore = await this.calculateSessionRiskScore(
          session.userId, 
          session.sessionData, 
          options
        );

        if (newRiskScore > this.config.maxRiskScore) {
          await this.flagHighRiskSession(sessionId, newRiskScore);
        }
      }

      return {
        success: true,
        session: session,
        userId: session.userId,
        sessionData: session.sessionData,
        expiresAt: session.expiresAt,
        riskScore: session.riskScore
      };

    } catch (error) {
      console.error('Error retrieving session data:', error);
      throw error;
    }
  }

  async updateSessionData(sessionId, updateData, options = {}) {
    console.log(`Updating session data: ${sessionId}`);

    try {
      // Prepare update operations
      const update = {
        $set: {
          lastAccessed: new Date(),
          'sessionData.preferences': updateData.preferences,
          'sessionData.shoppingCart': updateData.shoppingCart,
          'sessionData.navigation': updateData.navigation,
          'sessionData.applicationState': updateData.applicationState
        }
      };

      // Optional TTL extension
      if (options.extendTTL) {
        const newExpirationTime = new Date(Date.now() + (this.config.defaultSessionTTL * 1000));
        update.$set.expiresAt = newExpirationTime;
      }

      // Merge temporary data if provided
      if (updateData.temporaryData) {
        update.$set['sessionData.temporaryData'] = {
          ...updateData.temporaryData
        };
      }

      const result = await this.collections.userSessions.updateOne(
        { 
          sessionId: sessionId, 
          active: true,
          expiresAt: { $gt: new Date() }
        },
        update
      );

      if (result.matchedCount === 0) {
        return { success: false, reason: 'session_not_found' };
      }

      // Log session update event
      await this.logSessionEvent(sessionId, 'session_updated', {
        updateFields: Object.keys(updateData),
        extendTTL: options.extendTTL
      });

      return { success: true };

    } catch (error) {
      console.error('Error updating session data:', error);
      throw error;
    }
  }

  async invalidateSession(sessionId, reason = 'user_logout') {
    console.log(`Invalidating session: ${sessionId}, reason: ${reason}`);

    try {
      const result = await this.collections.userSessions.updateOne(
        { sessionId: sessionId },
        {
          $set: {
            active: false,
            invalidatedAt: new Date(),
            invalidationReason: reason,
            // Set immediate expiration for automatic cleanup
            expiresAt: new Date()
          }
        }
      );

      if (result.matchedCount > 0) {
        // Log session invalidation
        await this.logSessionEvent(sessionId, 'session_invalidated', {
          reason: reason,
          invalidatedAt: new Date()
        });
      }

      return { success: result.matchedCount > 0 };

    } catch (error) {
      console.error('Error invalidating session:', error);
      throw error;
    }
  }

  async setCache(cacheKey, data, options = {}) {
    console.log(`Setting cache entry: ${cacheKey}`);

    try {
      // Validate data size
      const dataSize = JSON.stringify(data).length;
      if (dataSize > this.config.maxCacheSize) {
        throw new Error(`Cache data size ${dataSize} exceeds maximum ${this.config.maxCacheSize}`);
      }

      // Calculate expiration time
      const ttlSeconds = options.ttl || this.config.defaultCacheTTL;
      const expiresAt = new Date(Date.now() + (ttlSeconds * 1000));

      // Prepare cache document
      const cacheEntry = {
        cacheKey: cacheKey,
        namespace: options.namespace || 'default',
        data: this.config.enableCompression ? await this.compressData(data) : data,
        compressed: this.config.enableCompression,

        // Expiration handling
        createdAt: new Date(),
        expiresAt: expiresAt,
        ttlSeconds: ttlSeconds,
        lastAccessed: new Date(),

        // Metadata
        tags: options.tags || [],
        version: options.version || '1.0',
        dataSize: dataSize,
        contentType: options.contentType || 'application/json',

        // Usage statistics
        hitCount: 0,
        accessHistory: [],

        // Cache strategy metadata
        cacheStrategy: options.strategy || 'default',
        invalidationRules: options.invalidationRules || []
      };

      // Upsert cache entry with automatic TTL
      await this.collections.applicationCache.replaceOne(
        { cacheKey: cacheKey },
        cacheEntry,
        { upsert: true }
      );

      // Update cache metrics
      await this.updateCacheMetrics('set', cacheKey, {
        namespace: cacheEntry.namespace,
        dataSize: dataSize,
        ttlSeconds: ttlSeconds
      });

      console.log(`Cache entry set successfully: ${cacheKey}`);
      return { success: true, expiresAt: expiresAt };

    } catch (error) {
      console.error('Error setting cache entry:', error);
      throw error;
    }
  }

  async getCache(cacheKey, options = {}) {
    console.log(`Getting cache entry: ${cacheKey}`);

    try {
      const cacheEntry = await this.collections.applicationCache.findOneAndUpdate(
        {
          cacheKey: cacheKey,
          expiresAt: { $gt: new Date() }
        },
        {
          $set: { lastAccessed: new Date() },
          $inc: { hitCount: 1 },
          $push: {
            accessHistory: {
              $each: [{ timestamp: new Date(), source: options.source || 'application' }],
              $slice: -10 // Keep only last 10 access records
            }
          }
        },
        { returnDocument: 'after' }
      );

      if (!cacheEntry.value) {
        // Record cache miss
        await this.updateCacheMetrics('miss', cacheKey, {
          namespace: options.namespace || 'default'
        });

        return { success: false, reason: 'cache_miss' };
      }

      // Decompress data if needed
      const data = cacheEntry.value.compressed ? 
        await this.decompressData(cacheEntry.value.data) : 
        cacheEntry.value.data;

      // Record cache hit
      await this.updateCacheMetrics('hit', cacheKey, {
        namespace: cacheEntry.value.namespace,
        dataSize: cacheEntry.value.dataSize
      });

      return {
        success: true,
        data: data,
        metadata: {
          createdAt: cacheEntry.value.createdAt,
          expiresAt: cacheEntry.value.expiresAt,
          hitCount: cacheEntry.value.hitCount,
          tags: cacheEntry.value.tags,
          version: cacheEntry.value.version
        }
      };

    } catch (error) {
      console.error('Error getting cache entry:', error);
      throw error;
    }
  }

  async invalidateCache(criteria, options = {}) {
    console.log('Invalidating cache entries with criteria:', criteria);

    try {
      let query = {};

      // Build invalidation query based on criteria
      if (criteria.key) {
        query.cacheKey = criteria.key;
      } else if (criteria.pattern) {
        query.cacheKey = { $regex: criteria.pattern };
      } else if (criteria.namespace) {
        query.namespace = criteria.namespace;
      } else if (criteria.tags) {
        query.tags = { $in: criteria.tags };
      }

      // Immediate expiration for automatic cleanup
      const result = await this.collections.applicationCache.updateMany(
        query,
        {
          $set: { 
            expiresAt: new Date(),
            invalidatedAt: new Date(),
            invalidationReason: options.reason || 'manual_invalidation'
          }
        }
      );

      // Update invalidation metrics
      await this.updateCacheMetrics('invalidation', null, {
        criteriaType: Object.keys(criteria)[0],
        entriesInvalidated: result.modifiedCount,
        reason: options.reason
      });

      console.log(`Invalidated ${result.modifiedCount} cache entries`);
      return { success: true, invalidatedCount: result.modifiedCount };

    } catch (error) {
      console.error('Error invalidating cache entries:', error);
      throw error;
    }
  }

  async getUserSessionAnalytics(userId, options = {}) {
    console.log(`Generating session analytics for user: ${userId}`);

    try {
      const timeRange = options.timeRange || 24; // hours
      const startTime = new Date(Date.now() - (timeRange * 3600 * 1000));

      const analytics = await this.collections.userSessions.aggregate([
        {
          $match: {
            userId: userId,
            createdAt: { $gte: startTime }
          }
        },
        {
          $group: {
            _id: '$userId',

            // Session counts
            totalSessions: { $sum: 1 },
            activeSessions: {
              $sum: {
                $cond: [
                  { $and: [
                    { $eq: ['$active', true] },
                    { $gt: ['$expiresAt', new Date()] }
                  ]},
                  1,
                  0
                ]
              }
            },

            // Duration analysis
            averageSessionDuration: {
              $avg: {
                $divide: [
                  { $subtract: ['$lastAccessed', '$createdAt'] },
                  1000 * 60 // Convert to minutes
                ]
              }
            },

            // Activity metrics
            totalPageViews: { $sum: '$pageViews' },
            totalActions: { $sum: '$actionsPerformed' },

            // Risk analysis
            averageRiskScore: { $avg: '$riskScore' },
            highRiskSessions: {
              $sum: {
                $cond: [{ $gt: ['$riskScore', 0.7] }, 1, 0]
              }
            },

            // Device analysis
            uniqueDevices: { $addToSet: '$deviceFingerprint' },
            uniqueIpAddresses: { $addToSet: '$ipAddress' },

            // Authentication methods
            loginMethods: { $addToSet: '$loginMethod' },
            mfaUsage: {
              $sum: {
                $cond: [{ $eq: ['$mfaVerified', true] }, 1, 0]
              }
            }
          }
        },
        {
          $project: {
            userId: '$_id',
            totalSessions: 1,
            activeSessions: 1,
            averageSessionDuration: { $round: ['$averageSessionDuration', 2] },
            totalPageViews: 1,
            totalActions: 1,
            averageRiskScore: { $round: ['$averageRiskScore', 3] },
            highRiskSessions: 1,
            deviceCount: { $size: '$uniqueDevices' },
            ipAddressCount: { $size: '$uniqueIpAddresses' },
            loginMethods: 1,
            mfaUsagePercentage: {
              $round: [
                { $multiply: [
                  { $divide: ['$mfaUsage', '$totalSessions'] },
                  100
                ]},
                2
              ]
            }
          }
        }
      ]).toArray();

      return analytics[0] || null;

    } catch (error) {
      console.error('Error generating user session analytics:', error);
      throw error;
    }
  }

  async getCachePerformanceReport(namespace = null, options = {}) {
    console.log('Generating cache performance report...');

    try {
      const timeRange = options.timeRange || 24; // hours
      const startTime = new Date(Date.now() - (timeRange * 3600 * 1000));

      // Build match criteria
      const matchCriteria = {
        timestamp: { $gte: startTime }
      };

      if (namespace) {
        matchCriteria.namespace = namespace;
      }

      const report = await this.collections.cacheMetrics.aggregate([
        { $match: matchCriteria },
        {
          $group: {
            _id: '$namespace',

            // Hit/miss statistics
            totalHits: {
              $sum: {
                $cond: [{ $eq: ['$operation', 'hit'] }, 1, 0]
              }
            },
            totalMisses: {
              $sum: {
                $cond: [{ $eq: ['$operation', 'miss'] }, 1, 0]
              }
            },
            totalSets: {
              $sum: {
                $cond: [{ $eq: ['$operation', 'set'] }, 1, 0]
              }
            },
            totalInvalidations: {
              $sum: {
                $cond: [{ $eq: ['$operation', 'invalidation'] }, '$metadata.entriesInvalidated', 0]
              }
            },

            // Data size statistics
            totalDataSize: {
              $sum: {
                $cond: [{ $eq: ['$operation', 'set'] }, '$metadata.dataSize', 0]
              }
            },
            averageDataSize: {
              $avg: {
                $cond: [{ $eq: ['$operation', 'set'] }, '$metadata.dataSize', null]
              }
            },

            // TTL analysis
            averageTTL: {
              $avg: {
                $cond: [{ $eq: ['$operation', 'set'] }, '$metadata.ttlSeconds', null]
              }
            }
          }
        },
        {
          $project: {
            namespace: '$_id',

            // Performance metrics
            totalRequests: { $add: ['$totalHits', '$totalMisses'] },
            hitRatio: {
              $round: [
                {
                  $cond: [
                    { $gt: [{ $add: ['$totalHits', '$totalMisses'] }, 0] },
                    {
                      $multiply: [
                        { $divide: ['$totalHits', { $add: ['$totalHits', '$totalMisses'] }] },
                        100
                      ]
                    },
                    0
                  ]
                },
                2
              ]
            },

            totalHits: 1,
            totalMisses: 1,
            totalSets: 1,
            totalInvalidations: 1,

            // Data insights
            totalDataSizeMB: {
              $round: [{ $divide: ['$totalDataSize', 1024 * 1024] }, 2]
            },
            averageDataSizeKB: {
              $round: [{ $divide: ['$averageDataSize', 1024] }, 2]
            },
            averageTTLHours: {
              $round: [{ $divide: ['$averageTTL', 3600] }, 2]
            }
          }
        }
      ]).toArray();

      return report;

    } catch (error) {
      console.error('Error generating cache performance report:', error);
      throw error;
    }
  }

  // Utility methods
  async generateSecureSessionId() {
    const crypto = require('crypto');
    return crypto.randomBytes(32).toString('hex');
  }

  async generateDeviceFingerprint(options) {
    const crypto = require('crypto');
    const fingerprint = `${options.userAgent || ''}-${options.ipAddress || ''}-${Date.now()}`;
    return crypto.createHash('sha256').update(fingerprint).digest('hex');
  }

  async calculateSessionRiskScore(userId, sessionData, options) {
    let riskScore = 0.0;

    // IP-based risk assessment
    if (options.ipAddress) {
      const recentSessions = await this.collections.userSessions.countDocuments({
        userId: userId,
        ipAddress: { $ne: options.ipAddress },
        createdAt: { $gte: new Date(Date.now() - 24 * 3600 * 1000) }
      });

      if (recentSessions > 0) riskScore += 0.2;
    }

    // Time-based risk assessment
    const currentHour = new Date().getHours();
    if (currentHour < 6 || currentHour > 23) {
      riskScore += 0.1;
    }

    // Device change assessment
    if (this.config.enableDeviceTracking && options.userAgent) {
      const knownDevice = await this.collections.deviceFingerprints.findOne({
        userId: userId,
        userAgent: options.userAgent
      });

      if (!knownDevice) riskScore += 0.3;
    }

    return Math.min(riskScore, 1.0);
  }

  async enforceSessionLimits(userId) {
    const sessionCount = await this.collections.userSessions.countDocuments({
      userId: userId,
      active: true,
      expiresAt: { $gt: new Date() }
    });

    if (sessionCount >= this.config.maxSessionsPerUser) {
      // Remove oldest sessions
      const sessionsToRemove = await this.collections.userSessions
        .find({
          userId: userId,
          active: true,
          expiresAt: { $gt: new Date() }
        })
        .sort({ lastAccessed: 1 })
        .limit(sessionCount - this.config.maxSessionsPerUser + 1)
        .toArray();

      for (const session of sessionsToRemove) {
        await this.invalidateSession(session.sessionId, 'session_limit_exceeded');
      }
    }
  }

  async logSessionEvent(sessionId, eventType, eventData) {
    if (!this.config.enableMetrics) return;

    await this.collections.sessionEvents.insertOne({
      sessionId: sessionId,
      eventType: eventType,
      eventData: eventData,
      timestamp: new Date()
    });
  }

  async updateCacheMetrics(operation, cacheKey, metadata) {
    if (!this.config.enableMetrics) return;

    await this.collections.cacheMetrics.insertOne({
      operation: operation,
      cacheKey: cacheKey,
      namespace: metadata.namespace,
      metadata: metadata,
      timestamp: new Date()
    });
  }

  async compressData(data) {
    const zlib = require('zlib');
    const jsonString = JSON.stringify(data);
    return zlib.deflateSync(jsonString);
  }

  async decompressData(compressedData) {
    const zlib = require('zlib');
    const decompressed = zlib.inflateSync(compressedData);
    return JSON.parse(decompressed.toString());
  }

  async startMaintenanceTasks() {
    // TTL collections handle expiration automatically
    console.log('Maintenance tasks initialized - TTL collections managing automatic cleanup');

    // Optional: Set up additional cleanup for edge cases
    if (this.config.sessionCleanupInterval > 0) {
      setInterval(async () => {
        await this.performMaintenanceCleanup();
      }, this.config.sessionCleanupInterval * 1000);
    }
  }

  async performMaintenanceCleanup() {
    try {
      // Optional cleanup for orphaned records or additional maintenance
      const orphanedSessions = await this.collections.userSessions.countDocuments({
        active: false,
        invalidatedAt: { $lt: new Date(Date.now() - 24 * 3600 * 1000) }
      });

      if (orphanedSessions > 0) {
        console.log(`Found ${orphanedSessions} orphaned sessions for cleanup`);
        // TTL will handle automatic cleanup
      }
    } catch (error) {
      console.warn('Error during maintenance cleanup:', error.message);
    }
  }
}

// Benefits of MongoDB Distributed Caching and Session Management:
// - Automatic TTL expiration with no manual cleanup required
// - Flexible document structure for complex session and cache data
// - Built-in indexing and query optimization for cache and session operations
// - Integrated compression and storage optimization capabilities
// - Sophisticated analytics and metrics collection with automatic retention
// - Advanced security features including risk scoring and device tracking
// - High-performance concurrent access with MongoDB's native concurrency controls
// - Seamless integration with existing MongoDB infrastructure
// - SQL-compatible operations through QueryLeaf for familiar management patterns
// - Distributed consistency and replication support for high availability

module.exports = {
  AdvancedCacheSessionManager
};