/**
 * Offline Message Handling and Synchronization Service
 * Ensures message delivery and synchronization when agents are offline or reconnecting
 */

import type { Address } from '@solana/addresses';
import type { Rpc, SolanaRpcApi } from '@solana/rpc';
import type { RpcSubscriptions, SolanaRpcSubscriptionsApi } from '@solana/rpc-subscriptions';
import type { Commitment } from '@solana/rpc-types';
import type { KeyPairSigner } from '@solana/signers';
import type { IRealtimeMessage, MessageType, MessagePriority, DeliveryStatus, ConnectionStatus } from './realtime-communication';
import { sendAndConfirmTransactionFactory } from '../utils/transaction-helpers.js';

/**
 * Offline storage strategies
 */
export type OfflineStorageStrategy = 
  | 'memory'              // In-memory storage (lost on restart)
  | 'local_storage'       // Browser localStorage
  | 'indexed_db'          // Browser IndexedDB
  | 'file_system'         // Node.js file system
  | 'blockchain'          // On-chain storage
  | 'distributed'         // Distributed storage network
  | 'hybrid';             // Combination of strategies

/**
 * Synchronization strategies
 */
export type SyncStrategy = 
  | 'full_sync'           // Sync all messages
  | 'delta_sync'          // Sync only changes
  | 'priority_sync'       // Sync high priority first
  | 'conversation_sync'   // Sync by conversation
  | 'time_window_sync'    // Sync within time window
  | 'selective_sync';     // User-defined selective sync

/**
 * Conflict resolution strategies
 */
export type ConflictResolutionStrategy = 
  | 'last_write_wins'     // Most recent update wins
  | 'first_write_wins'    // First update wins
  | 'merge_changes'       // Attempt to merge
  | 'user_decision'       // Let user decide
  | 'priority_based'      // Based on message priority
  | 'sender_priority';    // Based on sender reputation

/**
 * Offline message storage
 */
export interface IOfflineMessage {
  // Original message
  message: IRealtimeMessage;
  
  // Offline metadata
  storedAt: number;
  storageStrategy: OfflineStorageStrategy;
  syncStatus: 'pending' | 'syncing' | 'synced' | 'failed' | 'conflict';
  lastSyncAttempt?: number;
  syncAttempts: number;
  
  // Storage location
  storageLocation: {
    primary: string;
    backup?: string;
    checksum: string;
  };
  
  // Conflict tracking
  conflicts?: Array<{
    conflictId: string;
    type: 'duplicate' | 'ordering' | 'content' | 'metadata';
    description: string;
    possibleResolutions: string[];
    severity: 'low' | 'medium' | 'high';
  }>;
  
  // Delivery tracking
  deliveryTracking: {
    originalDeliveryAttempts: number;
    offlineQueuedAt: number;
    estimatedSyncTime: number;
    priorityBoost: number;
  };
}

/**
 * Agent presence and sync state
 */
export interface IAgentSyncState {
  agentAddress: Address;
  isOnline: boolean;
  lastSeenOnline: number;
  lastSyncTimestamp: number;
  
  // Pending synchronization
  pendingMessages: {
    incoming: Address[];  // Message IDs to be delivered
    outgoing: Address[];  // Message IDs to be sent
    conflicts: Address[]; // Message IDs with conflicts
  };
  
  // Sync preferences
  syncPreferences: {
    strategy: SyncStrategy;
    maxOfflineTime: number;
    priorityThreshold: MessagePriority;
    autoResolveConflicts: boolean;
    conflictResolution: ConflictResolutionStrategy;
  };
  
  // Storage configuration
  storageConfig: {
    primaryStrategy: OfflineStorageStrategy;
    backupStrategy?: OfflineStorageStrategy;
    maxStorageSize: number; // bytes
    retentionPeriod: number; // milliseconds
    encryptionEnabled: boolean;
  };
  
  // Sync statistics
  syncStats: {
    totalMessagesSynced: number;
    lastSyncDuration: number;
    averageSyncTime: number;
    conflictsResolved: number;
    failedSyncs: number;
  };
}

/**
 * Synchronization session
 */
export interface ISyncSession {
  sessionId: string;
  agentAddress: Address;
  startTime: number;
  endTime?: number;
  status: 'active' | 'completed' | 'failed' | 'cancelled';
  
  // Sync progress
  progress: {
    totalMessages: number;
    processedMessages: number;
    successfulSyncs: number;
    failedSyncs: number;
    conflictsFound: number;
    estimatedTimeRemaining: number;
  };
  
  // Sync operations
  operations: Array<{
    operationId: string;
    type: 'message_download' | 'message_upload' | 'conflict_resolution' | 'cleanup';
    messageId?: Address;
    status: 'pending' | 'processing' | 'completed' | 'failed';
    startTime: number;
    endTime?: number;
    error?: string;
  }>;
  
  // Performance metrics
  performance: {
    dataTransferred: number; // bytes
    bandwidth: number; // bytes per second
    latency: number;
    retransmissions: number;
  };
}

/**
 * Conflict resolution result
 */
export interface IConflictResolution {
  conflictId: string;
  messageId: Address;
  resolutionStrategy: ConflictResolutionStrategy;
  resolvedMessage: IRealtimeMessage;
  discardedVersions: IRealtimeMessage[];
  resolutionReason: string;
  userInput?: any;
  resolvedAt: number;
}

/**
 * Offline sync analytics
 */
export interface IOfflineSyncAnalytics {
  // Usage patterns
  offlinePatterns: {
    averageOfflineTime: number;
    longestOfflineSession: number;
    shortestOfflineSession: number;
    offlineFrequency: number; // per day
    peakOfflineHours: Array<{
      hour: number;
      offlineAgents: number;
    }>;
  };
  
  // Sync performance
  syncPerformance: {
    averageSyncTime: number;
    syncSuccessRate: number;
    syncFailureRate: number;
    averageMessagesPerSync: number;
    dataTransferEfficiency: number;
  };
  
  // Conflict analysis
  conflictAnalysis: {
    totalConflicts: number;
    conflictTypes: Record<string, number>;
    resolutionMethods: Record<ConflictResolutionStrategy, number>;
    averageResolutionTime: number;
    userInterventionRate: number;
  };
  
  // Storage utilization
  storageUtilization: {
    totalStorageUsed: number; // bytes
    averageMessageSize: number;
    storageEfficiency: number;
    cleanupFrequency: number;
    compressionRatio: number;
  };
  
  // Predictive insights
  predictions: {
    nextOfflinePeriod?: {
      estimatedStart: number;
      estimatedDuration: number;
      confidence: number;
    };
    expectedSyncLoad: Array<{
      timeWindow: number;
      expectedMessages: number;
      estimatedSyncTime: number;
    }>;
    storageProjection: {
      daysUntilFull: number;
      recommendedCleanup: boolean;
    };
  };
}

/**
 * Offline Message Handling and Synchronization Service
 */
export class OfflineSyncService {
  private offlineMessages = new Map<Address, IOfflineMessage>();
  private agentSyncStates = new Map<Address, IAgentSyncState>();
  private activeSyncSessions = new Map<string, ISyncSession>();
  private conflictResolutions = new Map<string, IConflictResolution>();
  private storageAdapters = new Map<OfflineStorageStrategy, any>();

  constructor(
    private readonly rpc: Rpc<SolanaRpcApi>,
    private readonly rpcSubscriptions: RpcSubscriptions<SolanaRpcSubscriptionsApi>,
    private readonly _programId: Address,
    private readonly commitment: Commitment = 'confirmed'
  ) {
    this.initializeStorageAdapters();
    this.startSyncMonitoring();
    this.startCleanupRoutine();
    this.startAnalyticsCollection();
  }

  /**
   * Configure offline storage for an agent
   */
  async configureOfflineStorage(
    agent: KeyPairSigner,
    config: {
      primaryStrategy: OfflineStorageStrategy;
      backupStrategy?: OfflineStorageStrategy;
      maxStorageSize: number;
      retentionPeriod: number;
      encryptionEnabled: boolean;
      syncPreferences: {
        strategy: SyncStrategy;
        maxOfflineTime: number;
        priorityThreshold: MessagePriority;
        autoResolveConflicts: boolean;
        conflictResolution: ConflictResolutionStrategy;
      };
    }
  ): Promise<{
    success: boolean;
    configId: string;
    error?: string;
  }> {
    try {
      console.log(`⚙️ Configuring offline storage for agent: ${agent.address}`);

      // Validate configuration
      this.validateStorageConfig(config);

      // Initialize agent sync state
      const syncState: IAgentSyncState = {
        agentAddress: agent.address,
        isOnline: true,
        lastSeenOnline: Date.now(),
        lastSyncTimestamp: Date.now(),
        pendingMessages: {
          incoming: [],
          outgoing: [],
          conflicts: [],
        },
        syncPreferences: config.syncPreferences,
        storageConfig: {
          primaryStrategy: config.primaryStrategy,
          backupStrategy: config.backupStrategy,
          maxStorageSize: config.maxStorageSize,
          retentionPeriod: config.retentionPeriod,
          encryptionEnabled: config.encryptionEnabled,
        },
        syncStats: {
          totalMessagesSynced: 0,
          lastSyncDuration: 0,
          averageSyncTime: 0,
          conflictsResolved: 0,
          failedSyncs: 0,
        },
      };

      // Store sync state
      this.agentSyncStates.set(agent.address, syncState);

      // Initialize storage adapters
      await this.initializeAgentStorage(agent.address, config);

      const configId = `config_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;

      console.log('✅ Offline storage configured successfully');
      return {
        success: true,
        configId,
      };
    } catch (error) {
      console.error('❌ Offline storage configuration failed:', error);
      return {
        success: false,
        configId: '',
        error: String(error),
      };
    }
  }

  /**
   * Store message for offline delivery
   */
  async storeOfflineMessage(
    message: IRealtimeMessage,
    storageStrategy?: OfflineStorageStrategy
  ): Promise<{
    success: boolean;
    storageId: string;
    estimatedSyncTime: number;
  }> {
    try {
      console.log(`📥 Storing message offline: ${message.messageId}`);

      // Get agent sync state
      const syncState = this.agentSyncStates.get(message.toAddress);
      if (!syncState) {
        throw new Error('Agent not configured for offline storage');
      }

      // Determine storage strategy
      const strategy = storageStrategy || syncState.storageConfig.primaryStrategy;

      // Check storage capacity
      await this.checkStorageCapacity(message.toAddress, message);

      // Create offline message
      const offlineMessage: IOfflineMessage = {
        message,
        storedAt: Date.now(),
        storageStrategy: strategy,
        syncStatus: 'pending',
        syncAttempts: 0,
        storageLocation: {
          primary: await this.generateStorageLocation(message.messageId, strategy),
          checksum: this.calculateChecksum(message),
        },
        deliveryTracking: {
          originalDeliveryAttempts: message.retryCount,
          offlineQueuedAt: Date.now(),
          estimatedSyncTime: this.calculateEstimatedSyncTime(syncState),
          priorityBoost: this.calculatePriorityBoost(message),
        },
      };

      // Store message using appropriate adapter
      await this.storeMessageWithAdapter(offlineMessage, strategy);

      // Add to offline messages map
      this.offlineMessages.set(message.messageId, offlineMessage);

      // Update agent sync state
      syncState.pendingMessages.incoming.push(message.messageId);

      console.log('✅ Message stored offline successfully');
      return {
        success: true,
        storageId: offlineMessage.storageLocation.primary,
        estimatedSyncTime: offlineMessage.deliveryTracking.estimatedSyncTime,
      };
    } catch (error) {
      throw new Error(`Offline message storage failed: ${String(error)}`);
    }
  }

  /**
   * Start synchronization session when agent comes online
   */
  async startSyncSession(
    agent: KeyPairSigner,
    options: {
      syncStrategy?: SyncStrategy;
      priorityThreshold?: MessagePriority;
      maxMessages?: number;
      timeWindow?: {
        start: number;
        end: number;
      };
    } = {}
  ): Promise<{
    sessionId: string;
    estimatedDuration: number;
    messagesToSync: number;
  }> {
    try {
      console.log(`🔄 Starting sync session for agent: ${agent.address}`);

      // Get agent sync state
      const syncState = this.agentSyncStates.get(agent.address);
      if (!syncState) {
        throw new Error('Agent not configured for offline sync');
      }

      // Update online status
      syncState.isOnline = true;
      syncState.lastSeenOnline = Date.now();

      // Create sync session
      const sessionId = `sync_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
      
      // Get messages to sync
      const messagesToSync = await this.getMessagesToSync(agent.address, options);

      const syncSession: ISyncSession = {
        sessionId,
        agentAddress: agent.address,
        startTime: Date.now(),
        status: 'active',
        progress: {
          totalMessages: messagesToSync.length,
          processedMessages: 0,
          successfulSyncs: 0,
          failedSyncs: 0,
          conflictsFound: 0,
          estimatedTimeRemaining: this.calculateSyncDuration(messagesToSync.length),
        },
        operations: [],
        performance: {
          dataTransferred: 0,
          bandwidth: 0,
          latency: 0,
          retransmissions: 0,
        },
      };

      // Store sync session
      this.activeSyncSessions.set(sessionId, syncSession);

      // Start sync process
      this.processSyncSession(syncSession);

      console.log('✅ Sync session started:', {
        sessionId,
        messagesToSync: messagesToSync.length
      });

      return {
        sessionId,
        estimatedDuration: syncSession.progress.estimatedTimeRemaining,
        messagesToSync: messagesToSync.length,
      };
    } catch (error) {
      throw new Error(`Sync session start failed: ${String(error)}`);
    }
  }

  /**
   * Handle agent going offline
   */
  async handleAgentOffline(
    agentAddress: Address,
    reason: 'disconnect' | 'timeout' | 'error' | 'maintenance' = 'disconnect'
  ): Promise<{
    success: boolean;
    pendingMessages: number;
    estimatedSyncTime: number;
  }> {
    try {
      console.log(`📴 Handling agent offline: ${agentAddress} (${reason})`);

      const syncState = this.agentSyncStates.get(agentAddress);
      if (!syncState) {
        throw new Error('Agent sync state not found');
      }

      // Update offline status
      syncState.isOnline = false;
      syncState.lastSeenOnline = Date.now();

      // Cancel any active sync sessions
      const activeSessions = Array.from(this.activeSyncSessions.values())
        .filter(session => session.agentAddress === agentAddress && session.status === 'active');

      for (const session of activeSessions) {
        session.status = 'cancelled';
        session.endTime = Date.now();
      }

      // Calculate estimated sync time for when agent returns
      const estimatedSyncTime = this.calculateEstimatedSyncTime(syncState);

      console.log('✅ Agent offline handling complete:', {
        pendingMessages: syncState.pendingMessages.incoming.length,
        estimatedSyncTime
      });

      return {
        success: true,
        pendingMessages: syncState.pendingMessages.incoming.length,
        estimatedSyncTime,
      };
    } catch (error) {
      throw new Error(`Agent offline handling failed: ${String(error)}`);
    }
  }

  /**
   * Resolve message conflicts
   */
  async resolveConflicts(
    agent: KeyPairSigner,
    conflictIds: string[],
    resolutions: Array<{
      conflictId: string;
      strategy: ConflictResolutionStrategy;
      userInput?: any;
    }>
  ): Promise<{
    resolved: string[];
    failed: Array<{
      conflictId: string;
      error: string;
    }>;
  }> {
    try {
      console.log(`🔧 Resolving ${conflictIds.length} conflicts for agent: ${agent.address}`);

      const resolved: string[] = [];
      const failed: Array<{ conflictId: string; error: string }> = [];

      for (const resolution of resolutions) {
        try {
          const result = await this.resolveIndividualConflict(
            agent.address,
            resolution.conflictId,
            resolution.strategy,
            resolution.userInput
          );

          if (result.success) {
            resolved.push(resolution.conflictId);
            
            // Store resolution
            this.conflictResolutions.set(resolution.conflictId, {
              conflictId: resolution.conflictId,
              messageId: result.messageId!,
              resolutionStrategy: resolution.strategy,
              resolvedMessage: result.resolvedMessage!,
              discardedVersions: result.discardedVersions || [],
              resolutionReason: result.reason || 'User resolution',
              userInput: resolution.userInput,
              resolvedAt: Date.now(),
            });
          } else {
            failed.push({
              conflictId: resolution.conflictId,
              error: result.error || 'Unknown error',
            });
          }
        } catch (error) {
          failed.push({
            conflictId: resolution.conflictId,
            error: String(error),
          });
        }
      }

      console.log(`✅ Conflict resolution complete: ${resolved.length} resolved, ${failed.length} failed`);
      return { resolved, failed };
    } catch (error) {
      throw new Error(`Conflict resolution failed: ${String(error)}`);
    }
  }

  /**
   * Get sync status for an agent
   */
  async getSyncStatus(agentAddress: Address): Promise<{
    isOnline: boolean;
    lastSyncTime: number;
    pendingMessages: {
      incoming: number;
      outgoing: number;
      conflicts: number;
    };
    activeSyncSession?: {
      sessionId: string;
      progress: number; // 0-100
      estimatedTimeRemaining: number;
    };
    storageUtilization: {
      used: number;
      available: number;
      percentage: number;
    };
  }> {
    try {
      const syncState = this.agentSyncStates.get(agentAddress);
      if (!syncState) {
        throw new Error('Agent sync state not found');
      }

      // Find active sync session
      const activeSession = Array.from(this.activeSyncSessions.values())
        .find(session => session.agentAddress === agentAddress && session.status === 'active');

      // Calculate storage utilization
      const storageUtilization = await this.calculateStorageUtilization(agentAddress);

      return {
        isOnline: syncState.isOnline,
        lastSyncTime: syncState.lastSyncTimestamp,
        pendingMessages: {
          incoming: syncState.pendingMessages.incoming.length,
          outgoing: syncState.pendingMessages.outgoing.length,
          conflicts: syncState.pendingMessages.conflicts.length,
        },
        activeSyncSession: activeSession ? {
          sessionId: activeSession.sessionId,
          progress: (activeSession.progress.processedMessages / activeSession.progress.totalMessages) * 100,
          estimatedTimeRemaining: activeSession.progress.estimatedTimeRemaining,
        } : undefined,
        storageUtilization,
      };
    } catch (error) {
      throw new Error(`Failed to get sync status: ${String(error)}`);
    }
  }

  /**
   * Get comprehensive offline sync analytics
   */
  async getOfflineSyncAnalytics(
    timeframe: 'hour' | 'day' | 'week' | 'month' = 'day'
  ): Promise<IOfflineSyncAnalytics> {
    try {
      console.log(`📊 Generating offline sync analytics for ${timeframe}`);

      const now = Date.now();
      const timeframeDuration = this.getTimeframeDuration(timeframe);
      const startTime = now - timeframeDuration;

      // Generate comprehensive analytics
      const analytics = await this.calculateOfflineSyncAnalytics(startTime, now);

      console.log('✅ Offline sync analytics generated');
      return analytics;
    } catch (error) {
      throw new Error(`Analytics generation failed: ${String(error)}`);
    }
  }

  /**
   * Private helper methods
   */

  private initializeStorageAdapters(): void {
    // Initialize storage adapters for different strategies
    this.storageAdapters.set('memory', new MemoryStorageAdapter());
    this.storageAdapters.set('blockchain', new BlockchainStorageAdapter(this.rpc, this._programId));
    this.storageAdapters.set('hybrid', new HybridStorageAdapter());
  }

  private validateStorageConfig(config: any): void {
    if (!config.primaryStrategy) {
      throw new Error('Primary storage strategy is required');
    }

    if (config.maxStorageSize <= 0) {
      throw new Error('Max storage size must be positive');
    }

    if (config.retentionPeriod <= 0) {
      throw new Error('Retention period must be positive');
    }
  }

  private async initializeAgentStorage(agentAddress: Address, config: any): Promise<void> {
    const primaryAdapter = this.storageAdapters.get(config.primaryStrategy);
    if (primaryAdapter) {
      await primaryAdapter.initialize(agentAddress, config);
    }

    if (config.backupStrategy) {
      const backupAdapter = this.storageAdapters.get(config.backupStrategy);
      if (backupAdapter) {
        await backupAdapter.initialize(agentAddress, config);
      }
    }
  }

  private async checkStorageCapacity(agentAddress: Address, message: IRealtimeMessage): Promise<void> {
    const syncState = this.agentSyncStates.get(agentAddress);
    if (!syncState) return;

    const messageSize = JSON.stringify(message).length;
    const currentUsage = await this.calculateCurrentStorageUsage(agentAddress);

    if (currentUsage + messageSize > syncState.storageConfig.maxStorageSize) {
      // Attempt cleanup
      await this.performStorageCleanup(agentAddress);
      
      // Recheck
      const newUsage = await this.calculateCurrentStorageUsage(agentAddress);
      if (newUsage + messageSize > syncState.storageConfig.maxStorageSize) {
        throw new Error('Insufficient storage capacity');
      }
    }
  }

  private async generateStorageLocation(messageId: Address, strategy: OfflineStorageStrategy): Promise<string> {
    switch (strategy) {
      case 'memory':
        return `mem://${messageId}`;
      case 'blockchain':
        return `chain://${this._programId}/${messageId}`;
      case 'hybrid':
        return `hybrid://${messageId}`;
      default:
        return `default://${messageId}`;
    }
  }

  private calculateChecksum(message: IRealtimeMessage): string {
    // Simple checksum calculation
    const content = JSON.stringify(message);
    let hash = 0;
    for (let i = 0; i < content.length; i++) {
      const char = content.charCodeAt(i);
      hash = ((hash << 5) - hash) + char;
      hash = hash & hash; // Convert to 32-bit integer
    }
    return Math.abs(hash).toString(16);
  }

  private calculateEstimatedSyncTime(syncState: IAgentSyncState): number {
    const pendingCount = syncState.pendingMessages.incoming.length + syncState.pendingMessages.outgoing.length;
    const averageSyncTime = syncState.syncStats.averageSyncTime || 1000; // Default 1s per message
    
    return Date.now() + (pendingCount * averageSyncTime);
  }

  private calculatePriorityBoost(message: IRealtimeMessage): number {
    const priorityBoosts = {
      critical: 10,
      urgent: 5,
      high: 2,
      normal: 1,
      low: 0,
    };
    return priorityBoosts[message.priority] || 1;
  }

  private async storeMessageWithAdapter(offlineMessage: IOfflineMessage, strategy: OfflineStorageStrategy): Promise<void> {
    const adapter = this.storageAdapters.get(strategy);
    if (adapter) {
      await adapter.store(offlineMessage);
    }
  }

  private async getMessagesToSync(agentAddress: Address, options: any): Promise<IOfflineMessage[]> {
    const syncState = this.agentSyncStates.get(agentAddress);
    if (!syncState) return [];

    // Get all pending messages
    const pendingMessageIds = [
      ...syncState.pendingMessages.incoming,
      ...syncState.pendingMessages.outgoing,
    ];

    let messagesToSync = pendingMessageIds
      .map(id => this.offlineMessages.get(id))
      .filter(msg => msg !== undefined) as IOfflineMessage[];

    // Apply filters based on options
    if (options.priorityThreshold) {
      messagesToSync = messagesToSync.filter(msg => 
        this.getPriorityValue(msg.message.priority) >= this.getPriorityValue(options.priorityThreshold)
      );
    }

    if (options.timeWindow) {
      messagesToSync = messagesToSync.filter(msg => 
        msg.message.timestamp >= options.timeWindow.start &&
        msg.message.timestamp <= options.timeWindow.end
      );
    }

    if (options.maxMessages) {
      messagesToSync = messagesToSync.slice(0, options.maxMessages);
    }

    return messagesToSync;
  }

  private getPriorityValue(priority: MessagePriority): number {
    const values = { critical: 4, urgent: 3, high: 2, normal: 1, low: 0 };
    return values[priority] || 1;
  }

  private calculateSyncDuration(messageCount: number): number {
    return messageCount * 1000; // 1s per message estimate
  }

  private async processSyncSession(session: ISyncSession): Promise<void> {
    try {
      const messagesToSync = await this.getMessagesToSync(session.agentAddress, {});
      
      for (const offlineMessage of messagesToSync) {
        const operation = {
          operationId: `op_${Date.now()}_${Math.random().toString(36).substr(2, 6)}`,
          type: 'message_download' as const,
          messageId: offlineMessage.message.messageId,
          status: 'processing' as const,
          startTime: Date.now(),
        };

        session.operations.push(operation);

        try {
          // Simulate message sync
          await this.syncMessage(offlineMessage);
          
          operation.status = 'completed';
          operation.endTime = Date.now();
          session.progress.successfulSyncs++;
          
          // Update offline message status
          offlineMessage.syncStatus = 'synced';
          offlineMessage.lastSyncAttempt = Date.now();

        } catch (error) {
          operation.status = 'failed';
          operation.endTime = Date.now();
          operation.error = String(error);
          session.progress.failedSyncs++;
          
          offlineMessage.syncStatus = 'failed';
          offlineMessage.syncAttempts++;
        }

        session.progress.processedMessages++;
        session.progress.estimatedTimeRemaining = 
          (session.progress.totalMessages - session.progress.processedMessages) * 1000;
      }

      // Complete session
      session.status = 'completed';
      session.endTime = Date.now();

      // Update agent sync state
      const syncState = this.agentSyncStates.get(session.agentAddress);
      if (syncState) {
        syncState.lastSyncTimestamp = Date.now();
        syncState.syncStats.totalMessagesSynced += session.progress.successfulSyncs;
        syncState.syncStats.lastSyncDuration = session.endTime - session.startTime;
        
        // Update average sync time
        const totalSyncs = syncState.syncStats.totalMessagesSynced;
        syncState.syncStats.averageSyncTime = 
          ((syncState.syncStats.averageSyncTime * (totalSyncs - session.progress.successfulSyncs)) + 
           syncState.syncStats.lastSyncDuration) / totalSyncs;
      }

    } catch (error) {
      session.status = 'failed';
      session.endTime = Date.now();
      console.error('Sync session failed:', error);
    }
  }

  private async syncMessage(offlineMessage: IOfflineMessage): Promise<void> {
    // Simulate message synchronization
    console.log(`🔄 Syncing message: ${offlineMessage.message.messageId}`);
    
    // Add random delay to simulate network
    await new Promise(resolve => setTimeout(resolve, Math.random() * 500 + 100));
    
    // Simulate occasional sync failures
    if (Math.random() < 0.05) {
      throw new Error('Simulated sync failure');
    }
  }

  private async resolveIndividualConflict(
    agentAddress: Address,
    conflictId: string,
    strategy: ConflictResolutionStrategy,
    userInput?: any
  ): Promise<{
    success: boolean;
    messageId?: Address;
    resolvedMessage?: IRealtimeMessage;
    discardedVersions?: IRealtimeMessage[];
    reason?: string;
    error?: string;
  }> {
    try {
      // Find the conflict (simulate finding conflicting messages)
      const offlineMessage = Array.from(this.offlineMessages.values())
        .find(msg => msg.conflicts?.some(c => c.conflictId === conflictId));

      if (!offlineMessage) {
        return { success: false, error: 'Conflict not found' };
      }

      // Apply resolution strategy
      switch (strategy) {
        case 'last_write_wins':
          return {
            success: true,
            messageId: offlineMessage.message.messageId,
            resolvedMessage: offlineMessage.message,
            reason: 'Most recent version selected',
          };
        
        case 'user_decision':
          if (!userInput?.selectedVersion) {
            return { success: false, error: 'User selection required' };
          }
          return {
            success: true,
            messageId: offlineMessage.message.messageId,
            resolvedMessage: userInput.selectedVersion,
            reason: 'User manually selected version',
          };
        
        default:
          return {
            success: true,
            messageId: offlineMessage.message.messageId,
            resolvedMessage: offlineMessage.message,
            reason: `Resolved using ${strategy} strategy`,
          };
      }
    } catch (error) {
      return { success: false, error: String(error) };
    }
  }

  private async calculateStorageUtilization(agentAddress: Address): Promise<{
    used: number;
    available: number;
    percentage: number;
  }> {
    const syncState = this.agentSyncStates.get(agentAddress);
    if (!syncState) {
      return { used: 0, available: 0, percentage: 0 };
    }

    const used = await this.calculateCurrentStorageUsage(agentAddress);
    const available = syncState.storageConfig.maxStorageSize - used;
    const percentage = (used / syncState.storageConfig.maxStorageSize) * 100;

    return { used, available, percentage };
  }

  private async calculateCurrentStorageUsage(agentAddress: Address): Promise<number> {
    // Calculate total storage usage for agent
    let totalSize = 0;
    
    for (const offlineMessage of this.offlineMessages.values()) {
      if (offlineMessage.message.toAddress === agentAddress || offlineMessage.message.fromAddress === agentAddress) {
        totalSize += JSON.stringify(offlineMessage.message).length;
      }
    }

    return totalSize;
  }

  private async performStorageCleanup(agentAddress: Address): Promise<void> {
    const syncState = this.agentSyncStates.get(agentAddress);
    if (!syncState) return;

    // Remove old synced messages
    const cutoffTime = Date.now() - syncState.storageConfig.retentionPeriod;
    
    for (const [messageId, offlineMessage] of this.offlineMessages) {
      if ((offlineMessage.message.toAddress === agentAddress || offlineMessage.message.fromAddress === agentAddress) &&
          offlineMessage.syncStatus === 'synced' &&
          offlineMessage.storedAt < cutoffTime) {
        this.offlineMessages.delete(messageId);
      }
    }
  }

  private startSyncMonitoring(): void {
    setInterval(() => {
      this.monitorSyncSessions();
    }, 10000); // Check every 10 seconds
  }

  private monitorSyncSessions(): void {
    const now = Date.now();
    
    for (const [sessionId, session] of this.activeSyncSessions) {
      if (session.status === 'active') {
        // Check for stalled sessions
        if (now - session.startTime > 300000) { // 5 minutes
          session.status = 'failed';
          session.endTime = now;
          console.warn(`Sync session timed out: ${sessionId}`);
        }
      }
      
      // Cleanup completed sessions older than 1 hour
      if (session.endTime && now - session.endTime > 3600000) {
        this.activeSyncSessions.delete(sessionId);
      }
    }
  }

  private startCleanupRoutine(): void {
    setInterval(() => {
      this.performGlobalCleanup();
    }, 3600000); // Run every hour
  }

  private async performGlobalCleanup(): Promise<void> {
    // Cleanup old sync sessions, resolved conflicts, etc.
    const now = Date.now();
    const dayAgo = now - 86400000;

    // Remove old conflict resolutions
    for (const [conflictId, resolution] of this.conflictResolutions) {
      if (resolution.resolvedAt < dayAgo) {
        this.conflictResolutions.delete(conflictId);
      }
    }
  }

  private startAnalyticsCollection(): void {
    setInterval(() => {
      this.collectAnalyticsData();
    }, 300000); // Collect every 5 minutes
  }

  private collectAnalyticsData(): void {
    // Collect analytics data points
    const timestamp = Date.now();
    
    // Count offline agents
    const offlineAgents = Array.from(this.agentSyncStates.values())
      .filter(state => !state.isOnline).length;
    
    // Count pending messages
    const totalPendingMessages = Array.from(this.agentSyncStates.values())
      .reduce((sum, state) => sum + state.pendingMessages.incoming.length + state.pendingMessages.outgoing.length, 0);
    
    // Store data point (in a real implementation, this would go to a time series database)
    console.log(`📊 Analytics data point: ${offlineAgents} offline agents, ${totalPendingMessages} pending messages`);
  }

  private getTimeframeDuration(timeframe: string): number {
    const durations = {
      hour: 60 * 60 * 1000,
      day: 24 * 60 * 60 * 1000,
      week: 7 * 24 * 60 * 60 * 1000,
      month: 30 * 24 * 60 * 60 * 1000,
    };
    return durations[timeframe as keyof typeof durations] || durations.day;
  }

  private async calculateOfflineSyncAnalytics(startTime: number, endTime: number): Promise<IOfflineSyncAnalytics> {
    // Generate comprehensive offline sync analytics
    return {
      offlinePatterns: {
        averageOfflineTime: 3600000, // 1 hour
        longestOfflineSession: 86400000, // 24 hours
        shortestOfflineSession: 300000, // 5 minutes
        offlineFrequency: 2.5, // per day
        peakOfflineHours: Array.from({ length: 24 }, (_, hour) => ({
          hour,
          offlineAgents: Math.floor(Math.random() * 50) + 10,
        })),
      },
      syncPerformance: {
        averageSyncTime: 5000,
        syncSuccessRate: 95.5,
        syncFailureRate: 4.5,
        averageMessagesPerSync: 12,
        dataTransferEfficiency: 85.2,
      },
      conflictAnalysis: {
        totalConflicts: 23,
        conflictTypes: {
          duplicate: 10,
          ordering: 8,
          content: 3,
          metadata: 2,
        },
        resolutionMethods: {
          last_write_wins: 15,
          user_decision: 5,
          merge_changes: 2,
          first_write_wins: 1,
          priority_based: 0,
          sender_priority: 0,
        },
        averageResolutionTime: 45000,
        userInterventionRate: 21.7,
      },
      storageUtilization: {
        totalStorageUsed: 52428800, // 50MB
        averageMessageSize: 2048,
        storageEfficiency: 78.5,
        cleanupFrequency: 24, // hours
        compressionRatio: 3.2,
      },
      predictions: {
        nextOfflinePeriod: {
          estimatedStart: Date.now() + 7200000, // 2 hours from now
          estimatedDuration: 1800000, // 30 minutes
          confidence: 75,
        },
        expectedSyncLoad: [
          { timeWindow: Date.now() + 3600000, expectedMessages: 45, estimatedSyncTime: 45000 },
          { timeWindow: Date.now() + 7200000, expectedMessages: 23, estimatedSyncTime: 23000 },
          { timeWindow: Date.now() + 10800000, expectedMessages: 67, estimatedSyncTime: 67000 },
        ],
        storageProjection: {
          daysUntilFull: 15,
          recommendedCleanup: false,
        },
      },
    };
  }
}

/**
 * Storage adapter implementations
 */

class MemoryStorageAdapter {
  private storage = new Map<string, any>();

  async initialize(agentAddress: Address, config: any): Promise<void> {
    console.log(`Initializing memory storage for ${agentAddress}`);
  }

  async store(offlineMessage: IOfflineMessage): Promise<void> {
    this.storage.set(offlineMessage.message.messageId, offlineMessage);
  }

  async retrieve(messageId: Address): Promise<IOfflineMessage | null> {
    return this.storage.get(messageId) || null;
  }
}

class BlockchainStorageAdapter {
  constructor(
    private rpc: Rpc<SolanaRpcApi>,
    private programId: Address
  ) {}

  async initialize(agentAddress: Address, config: any): Promise<void> {
    console.log(`Initializing blockchain storage for ${agentAddress}`);
  }

  async store(offlineMessage: IOfflineMessage): Promise<void> {
    // Store message on blockchain
    console.log(`Storing message ${offlineMessage.message.messageId} on blockchain`);
  }

  async retrieve(messageId: Address): Promise<IOfflineMessage | null> {
    // Retrieve from blockchain
    return null;
  }
}

class HybridStorageAdapter {
  private memoryAdapter = new MemoryStorageAdapter();

  async initialize(agentAddress: Address, config: any): Promise<void> {
    await this.memoryAdapter.initialize(agentAddress, config);
  }

  async store(offlineMessage: IOfflineMessage): Promise<void> {
    await this.memoryAdapter.store(offlineMessage);
  }

  async retrieve(messageId: Address): Promise<IOfflineMessage | null> {
    return await this.memoryAdapter.retrieve(messageId);
  }
}