AI Resilience Architecture

interface ProviderHealth {
  providerId: string;
  status: 'healthy' | 'degraded' | 'failed';
  latency: number;
  errorRate: number;
  lastCheck: Date;
  consecutiveFailures: number;
}
 
class ProviderHealthMonitor {
  private healthChecks = new Map<string, ProviderHealth>();
  
  async monitorProviders(): Promise<void> {
    const providers = ['openrouter', 'anthropic', 'openai', 'google'];
    
    await Promise.allSettled(
      providers.map(async (providerId) => {
        const start = Date.now();
        
        try {
          await this.pingProvider(providerId);
          const latency = Date.now() - start;
          
          this.updateHealth(providerId, {
            status: latency > 5000 ? 'degraded' : 'healthy',
            latency,
            errorRate: this.calculateErrorRate(providerId),
            consecutiveFailures: 0
          });
          
        } catch (error) {
          this.updateHealth(providerId, {
            status: 'failed',
            latency: Date.now() - start,
            errorRate: 1.0,
            consecutiveFailures: this.incrementFailures(providerId)
          });
        }
      })
    );
  }
  
  getHealthyProviders(): string[] {
    return Array.from(this.healthChecks.entries())
      .filter(([_, health]) => health.status === 'healthy')
      .sort((a, b) => a[1].latency - b[1].latency)
      .map(([providerId]) => providerId);
  }
}

interface RoutingDecision {
  provider: string;
  model: string;
  reasoning: string;
  fallbackChain: string[];
}
 
class IntelligentRouter {
  async selectProvider(request: AIRequest): Promise<RoutingDecision> {
    const healthyProviders = this.healthMonitor.getHealthyProviders();
    const complexity = this.analyzeComplexity(request);
    const urgency = this.analyzeUrgency(request);
    
    // Cost-optimized for simple requests
    if (complexity === 'low' && healthyProviders.includes('openrouter')) {
      return {
        provider: 'openrouter',
        model: 'google/gemma-3b',
        reasoning: 'Cost-effective for simple queries',
        fallbackChain: ['anthropic/claude-haiku', 'openai/gpt-4o-mini', 'local/gemma-3b']
      };
    }
    
    // Quality-optimized for complex requests  
    if (complexity === 'high' && healthyProviders.includes('anthropic')) {
      return {
        provider: 'anthropic',
        model: 'claude-3-haiku',
        reasoning: 'High-quality reasoning for complex queries',
        fallbackChain: ['openai/gpt-4o-mini', 'openrouter/llama-7b', 'local/gemma-3b']
      };
    }
    
    // Emergency fallback
    return {
      provider: 'local',
      model: 'gemma-3b-quantized',
      reasoning: 'All cloud providers unavailable',
      fallbackChain: ['cached-responses']
    };
  }
}

class CircuitBreaker {
  private state: 'closed' | 'open' | 'half-open' = 'closed';
  private failureCount = 0;
  private lastFailure?: Date;
  
  constructor(
    private readonly threshold = 5,
    private readonly timeout = 60000 // 1 minute
  ) {}
  
  async execute<T>(operation: () => Promise<T>): Promise<T> {
    if (this.state === 'open') {
      if (Date.now() - this.lastFailure!.getTime() > this.timeout) {
        this.state = 'half-open';
      } else {
        throw new Error('Circuit breaker is open');
      }
    }
    
    try {
      const result = await operation();
      this.onSuccess();
      return result;
    } catch (error) {
      this.onFailure();
      throw error;
    }
  }
  
  private onSuccess(): void {
    this.failureCount = 0;
    this.state = 'closed';
  }
  
  private onFailure(): void {
    this.failureCount++;
    this.lastFailure = new Date();
    
    if (this.failureCount >= this.threshold) {
      this.state = 'open';
    }
  }
}

interface QualityTier {
  level: 'premium' | 'standard' | 'basic' | 'emergency';
  providers: string[];
  maxLatency: number;
  features: string[];
}
 
const QUALITY_TIERS: QualityTier[] = [
  {
    level: 'premium',
    providers: ['anthropic/claude-3-haiku', 'openai/gpt-4o-mini'],
    maxLatency: 3000,
    features: ['context-awareness', 'empathy', 'nuanced-advice']
  },
  {
    level: 'standard', 
    providers: ['openrouter/llama-7b', 'google/gemini-flash'],
    maxLatency: 5000,
    features: ['context-awareness', 'basic-advice']
  },
  {
    level: 'basic',
    providers: ['openrouter/gemma-3b'],
    maxLatency: 2000,
    features: ['simple-responses', 'safety-filtering']
  },
  {
    level: 'emergency',
    providers: ['local/gemma-3b', 'cached-responses'],
    maxLatency: 1000,
    features: ['basic-safety', 'simple-responses']
  }
];

class FeatureDegradation {
  async handleDegradedService(request: AIRequest): Promise<AIResponse> {
    const availableTier = this.determineAvailableTier();
    
    switch (availableTier.level) {
      case 'premium':
        return this.generatePremiumResponse(request);
        
      case 'standard':
        return this.generateStandardResponse(request);
        
      case 'basic':
        // Disable advanced features, keep core functionality
        return this.generateBasicResponse({
          ...request,
          features: request.features.filter(f => ['safety', 'basic-advice'].includes(f))
        });
        
      case 'emergency':
        // Use cached responses or simple patterns
        const cachedResponse = await this.getCachedResponse(request);
        if (cachedResponse) return cachedResponse;
        
        return {
          content: "I'm experiencing technical difficulties but want to help. Please try rephrasing your question, or check back in a few minutes.",
          confidence: 0.3,
          tier: 'emergency'
        };
    }
  }
}

// supabase/functions/ai-resilient/index.ts
import { serve } from "https://deno.land/std@0.168.0/http/server.ts";
 
serve(async (req) => {
  const { query, context, userId } = await req.json();
  
  try {
    // Try cloud providers first
    const cloudResponse = await tryCloudProviders(query, context);
    if (cloudResponse) {
      // Cache successful responses
      await cacheResponse(query, cloudResponse);
      return new Response(JSON.stringify(cloudResponse));
    }
  } catch (error) {
    console.warn('Cloud providers failed, trying local fallbacks');
  }
  
  // Fallback to cached responses
  const cachedResponse = await getCachedResponse(query);
  if (cachedResponse && isRecentEnough(cachedResponse)) {
    return new Response(JSON.stringify({
      ...cachedResponse,
      source: 'cache',
      freshness: 'cached'
    }));
  }
  
  // Last resort: local model
  const localResponse = await runLocalModel(query, context);
  return new Response(JSON.stringify({
    ...localResponse,
    source: 'local',
    freshness: 'computed'
  }));
});

class SemanticCache {
  private embeddingCache = new Map<string, number[]>();
  private responseCache = new Map<string, CachedResponse>();
  
  async getCachedResponse(query: string): Promise<AIResponse | null> {
    // Check exact match first
    const exactMatch = this.responseCache.get(query);
    if (exactMatch && !this.isExpired(exactMatch)) {
      return exactMatch.response;
    }
    
    // Check semantic similarity
    const queryEmbedding = await this.getEmbedding(query);
    const similarQueries = await this.findSimilarQueries(queryEmbedding, 0.9);
    
    if (similarQueries.length > 0) {
      const bestMatch = similarQueries[0];
      return {
        ...bestMatch.response,
        metadata: {
          ...bestMatch.response.metadata,
          similarityScore: bestMatch.similarity,
          originalQuery: bestMatch.query
        }
      };
    }
    
    return null;
  }
  
  private async findSimilarQueries(embedding: number[], threshold: number): Promise<SimilarQuery[]> {
    const similarities: SimilarQuery[] = [];
    
    for (const [query, cachedEmbedding] of this.embeddingCache) {
      const similarity = this.cosineSimilarity(embedding, cachedEmbedding);
      
      if (similarity >= threshold) {
        const response = this.responseCache.get(query);
        if (response && !this.isExpired(response)) {
          similarities.push({ query, similarity, response: response.response });
        }
      }
    }
    
    return similarities.sort((a, b) => b.similarity - a.similarity);
  }
}

interface SystemHealth {
  overall: 'healthy' | 'degraded' | 'critical';
  providers: ProviderHealth[];
  cacheHitRate: number;
  averageLatency: number;
  errorRate: number;
  activeRequests: number;
  queueDepth: number;
}
 
class HealthDashboard {
  async getSystemHealth(): Promise<SystemHealth> {
    const [
      providerHealth,
      cacheStats,
      performanceMetrics,
      queueMetrics
    ] = await Promise.all([
      this.getProviderHealth(),
      this.getCacheStats(),
      this.getPerformanceMetrics(),
      this.getQueueMetrics()
    ]);
    
    const overall = this.calculateOverallHealth(
      providerHealth,
      performanceMetrics,
      queueMetrics
    );
    
    return {
      overall,
      providers: providerHealth,
      cacheHitRate: cacheStats.hitRate,
      averageLatency: performanceMetrics.avgLatency,
      errorRate: performanceMetrics.errorRate,
      activeRequests: performanceMetrics.activeRequests,
      queueDepth: queueMetrics.depth
    };
  }
  
  private calculateOverallHealth(
    providers: ProviderHealth[],
    performance: PerformanceMetrics,
    queue: QueueMetrics
  ): 'healthy' | 'degraded' | 'critical' {
    const healthyProviders = providers.filter(p => p.status === 'healthy').length;
    
    if (healthyProviders === 0) return 'critical';
    if (healthyProviders < 2 || performance.errorRate > 0.1 || queue.depth > 100) return 'degraded';
    return 'healthy';
  }
}

class AlertingSystem {
  private alertChannels = ['email', 'slack', 'pagerduty'];
  
  async monitorAndAlert(): Promise<void> {
    const health = await this.healthDashboard.getSystemHealth();
    
    // Critical alerts
    if (health.overall === 'critical') {
      await this.sendAlert({
        severity: 'critical',
        message: 'AI system is experiencing critical issues',
        details: {
          healthyProviders: health.providers.filter(p => p.status === 'healthy').length,
          errorRate: health.errorRate,
          queueDepth: health.queueDepth
        },
        channels: this.alertChannels
      });
    }
    
    // Degraded performance alerts
    if (health.overall === 'degraded') {
      await this.sendAlert({
        severity: 'warning',
        message: 'AI system performance is degraded',
        details: {
          averageLatency: health.averageLatency,
          cacheHitRate: health.cacheHitRate,
          degradedProviders: health.providers.filter(p => p.status === 'degraded')
        },
        channels: ['slack']
      });
    }
    
    // Performance trend alerts
    await this.checkPerformanceTrends(health);
  }
}

class EmergencyResponseSystem {
  private emergencyResponses = {
    coParenting: [
      "I understand this is a challenging situation. The most important thing is focusing on what's best for your children.",
      "Co-parenting conflicts are difficult. Consider having a calm conversation when emotions aren't running high.",
      "Your children benefit when both parents work together. Try to find common ground in your shared love for them."
    ],
    scheduling: [
      "Schedule conflicts happen. Try to be flexible and communicate early about any changes needed.",
      "Consider using a shared calendar to help prevent scheduling conflicts in the future.",
      "When schedules conflict, focus on finding solutions that work for everyone, especially the children."
    ],
    communication: [
      "Clear, respectful communication is key to successful co-parenting.",
      "Try to keep conversations focused on the children and practical matters.",
      "If emotions are high, consider taking a break and returning to the conversation later."
    ]
  };
  
  async generateEmergencyResponse(query: string): Promise<AIResponse> {
    const category = this.categorizeQuery(query);
    const responses = this.emergencyResponses[category] || this.emergencyResponses.coParenting;
    
    // Simple pattern matching for more relevant responses
    const relevantResponses = responses.filter(response => 
      this.hasKeywordOverlap(query, response)
    );
    
    const selectedResponse = relevantResponses.length > 0 
      ? relevantResponses[Math.floor(Math.random() * relevantResponses.length)]
      : responses[Math.floor(Math.random() * responses.length)];
    
    return {
      content: selectedResponse + " I'm experiencing technical difficulties, but I'm here to help. Please try again in a few minutes.",
      confidence: 0.2,
      source: 'emergency',
      timestamp: new Date().toISOString()
    };
  }
}

class RequestBatcher {
  private batches = new Map<string, BatchRequest[]>();
  private batchTimers = new Map<string, NodeJS.Timeout>();
  
  async submitRequest(request: AIRequest): Promise<AIResponse> {
    const batchKey = this.getBatchKey(request);
    const batch = this.batches.get(batchKey) || [];
    
    return new Promise((resolve, reject) => {
      batch.push({ request, resolve, reject });
      this.batches.set(batchKey, batch);
      
      // Set batch processing timer
      if (!this.batchTimers.has(batchKey)) {
        const timer = setTimeout(() => {
          this.processBatch(batchKey);
        }, 100); // 100ms batch window
        
        this.batchTimers.set(batchKey, timer);
      }
    });
  }
  
  private async processBatch(batchKey: string): Promise<void> {
    const batch = this.batches.get(batchKey) || [];
    this.batches.delete(batchKey);
    this.batchTimers.delete(batchKey);
    
    if (batch.length === 0) return;
    
    try {
      const responses = await this.sendBatchRequest(batch.map(b => b.request));
      
      batch.forEach((item, index) => {
        item.resolve(responses[index]);
      });
    } catch (error) {
      batch.forEach(item => {
        item.reject(error);
      });
    }
  }
}

class AdaptiveLoadBalancer {
  private providerWeights = new Map<string, number>();
  private performanceHistory = new Map<string, number[]>();
  
  selectProvider(providers: string[]): string {
    // Calculate weighted selection based on recent performance
    const weights = providers.map(provider => ({
      provider,
      weight: this.calculateWeight(provider)
    }));
    
    const totalWeight = weights.reduce((sum, w) => sum + w.weight, 0);
    const random = Math.random() * totalWeight;
    
    let current = 0;
    for (const { provider, weight } of weights) {
      current += weight;
      if (random <= current) {
        return provider;
      }
    }
    
    return providers[0]; // Fallback
  }
  
  private calculateWeight(provider: string): number {
    const history = this.performanceHistory.get(provider) || [1000]; // Default latency
    const avgLatency = history.reduce((sum, val) => sum + val, 0) / history.length;
    const errorRate = this.getErrorRate(provider);
    
    // Lower latency and error rate = higher weight
    return Math.max(0.1, 1 / (avgLatency / 1000 + errorRate * 10));
  }
}

class EmergencyBudgetManager {
  private dailyBudget = 100; // $100 per day
  private currentSpend = 0;
  private emergencyMode = false;
  
  async shouldAllowRequest(request: AIRequest): Promise<boolean> {
    const estimatedCost = this.estimateRequestCost(request);
    
    if (this.currentSpend + estimatedCost > this.dailyBudget) {
      this.emergencyMode = true;
      
      // Only allow critical requests in emergency mode
      if (request.priority !== 'critical') {
        return false;
      }
    }
    
    return true;
  }
  
  async handleBudgetExceeded(): Promise<void> {
    // Switch to local-only mode
    await this.activateLocalOnlyMode();
    
    // Alert administrators
    await this.alertBudgetExceeded();
    
    // Notify users of degraded service
    await this.notifyServiceDegradation();
  }
}

class CoParentingAssistantResilience {
  async handleCoParentingQuery(query: string, context: CoParentingContext): Promise<AIResponse> {
    const fallbackChain = [
      () => this.tryPremiumProviders(query, context),
      () => this.tryStandardProviders(query, context),
      () => this.tryBasicProviders(query, context),
      () => this.useTemplateResponses(query, context),
      () => this.generateEmergencyResponse(query, context)
    ];
    
    for (const fallback of fallbackChain) {
      try {
        const response = await fallback();
        if (response) {
          return this.addResilienceMetadata(response, fallback.name);
        }
      } catch (error) {
        console.warn(`Fallback ${fallback.name} failed:`, error);
      }
    }
    
    throw new Error('All fallback methods exhausted');
  }
  
  private async useTemplateResponses(query: string, context: CoParentingContext): Promise<AIResponse> {
    const templates = this.getRelevantTemplates(query, context);
    const selectedTemplate = this.selectBestTemplate(templates, query);
    
    return {
      content: this.personalizeTemplate(selectedTemplate, context),
      confidence: 0.6,
      source: 'template',
      template: selectedTemplate.id
    };
  }
}