// Pattern 1: Graceful Degradation
class ResilientHost {
  async executeWithFallback(primary, fallback) {
    try {
      return await primary();
    } catch (error) {
      console.warn('Primary failed, trying fallback:', error.message);
      return await fallback();
    }
  }
}

// Pattern 2: Request Batching
class BatchingHost {
  constructor() {
    this.pendingRequests = [];
    this.batchTimer = null;
  }
  
  async request(client, method, params) {
    return new Promise((resolve, reject) => {
      this.pendingRequests.push({
        client, method, params, resolve, reject
      });
      
      if (!this.batchTimer) {
        this.batchTimer = setTimeout(() => this.flush(), 10);
      }
    });
  }
  
  async flush() {
    const batch = this.pendingRequests.splice(0);
    this.batchTimer = null;
    
    // Group by client
    const byClient = this.groupBy(batch, 'client');
    
    // Send batched requests
    for (const [client, requests] of Object.entries(byClient)) {
      const batchRequest = {
        method: 'batch',
        params: requests.map(r => ({
          method: r.method,
          params: r.params
        }))
      };
      
      try {
        const results = await client.request(batchRequest);
        requests.forEach((r, i) => r.resolve(results[i]));
      } catch (error) {
        requests.forEach(r => r.reject(error));
      }
    }
  }
}

// Pattern 3: Capability Caching
class CachingHost {
  constructor() {
    this.capabilityCache = new Map();
    this.cacheTimeout = 5 * 60 * 1000; // 5 minutes
  }
  
  async getCapabilities(client) {
    const cached = this.capabilityCache.get(client.id);
    
    if (cached && Date.now() - cached.timestamp < this.cacheTimeout) {
      return cached.capabilities;
    }
    
    const capabilities = await client.request('capabilities/list');
    
    this.capabilityCache.set(client.id, {
      capabilities,
      timestamp: Date.now()
    });
    
    return capabilities;
  }
}