// Graceful degradation implementation with feature flags and fallback mechanisms
import { DynamoDBClient, GetItemCommand } from '@aws-sdk/client-dynamodb';
import { CloudWatchClient, GetMetricStatisticsCommand } from '@aws-sdk/client-cloudwatch';
import { marshall, unmarshall } from '@aws-sdk/util-dynamodb';

interface FeatureFlag {
  name: string;
  enabled: boolean;
  conditions?: {
    maxErrorRate?: number;
    maxLatency?: number;
    maxCpuUtilization?: number;
  };
}

interface SystemHealth {
  errorRate: number;
  averageLatency: number;
  cpuUtilization: number;
  activeConnections: number;
}

class ResilienceManager {
  private dynamoClient: DynamoDBClient;
  private cloudWatchClient: CloudWatchClient;
  private featureFlagsTable: string;

  constructor(featureFlagsTable: string) {
    this.dynamoClient = new DynamoDBClient({});
    this.cloudWatchClient = new CloudWatchClient({});
    this.featureFlagsTable = featureFlagsTable;
  }

  async shouldEnableFeature(featureName: string): Promise<boolean> {
    try {
      const featureFlag = await this.getFeatureFlag(featureName);
      if (!featureFlag.enabled) {
        return false;
      }

      if (featureFlag.conditions) {
        const systemHealth = await this.getSystemHealth();
        return this.evaluateHealthConditions(featureFlag.conditions, systemHealth);
      }

      return true;
    } catch (error) {
      // Fail safe: disable features when unable to determine status
      console.error(`Error checking feature flag ${featureName}:`, error);
      return false;
    }
  }

  private async getFeatureFlag(name: string): Promise<FeatureFlag> {
    const response = await this.dynamoClient.send(new GetItemCommand({
      TableName: this.featureFlagsTable,
      Key: marshall({ name })
    }));

    if (!response.Item) {
      throw new Error(`Feature flag ${name} not found`);
    }

    return unmarshall(response.Item) as FeatureFlag;
  }

  private async getSystemHealth(): Promise<SystemHealth> {
    const now = new Date();
    const fiveMinutesAgo = new Date(now.getTime() - 5 * 60 * 1000);

    // Get error rate from CloudWatch
    const errorRateMetric = await this.cloudWatchClient.send(new GetMetricStatisticsCommand({
      Namespace: 'AWS/Lambda',
      MetricName: 'Errors',
      StartTime: fiveMinutesAgo,
      EndTime: now,
      Period: 300,
      Statistics: ['Sum']
    }));

    const invocationsMetric = await this.cloudWatchClient.send(new GetMetricStatisticsCommand({
      Namespace: 'AWS/Lambda',
      MetricName: 'Invocations',
      StartTime: fiveMinutesAgo,
      EndTime: now,
      Period: 300,
      Statistics: ['Sum']
    }));

    const errors = errorRateMetric.Datapoints?.[0]?.Sum || 0;
    const invocations = invocationsMetric.Datapoints?.[0]?.Sum || 1;
    const errorRate = (errors / invocations) * 100;

    // Get average latency
    const latencyMetric = await this.cloudWatchClient.send(new GetMetricStatisticsCommand({
      Namespace: 'AWS/Lambda',
      MetricName: 'Duration',
      StartTime: fiveMinutesAgo,
      EndTime: now,
      Period: 300,
      Statistics: ['Average']
    }));

    const averageLatency = latencyMetric.Datapoints?.[0]?.Average || 0;

    return {
      errorRate,
      averageLatency,
      cpuUtilization: 0, // Would implement based on your infrastructure
      activeConnections: 0 // Would implement based on your load balancer metrics
    };
  }

  private evaluateHealthConditions(conditions: FeatureFlag['conditions'], health: SystemHealth): boolean {
    if (conditions.maxErrorRate && health.errorRate > conditions.maxErrorRate) {
      return false;
    }

    if (conditions.maxLatency && health.averageLatency > conditions.maxLatency) {
      return false;
    }

    if (conditions.maxCpuUtilization && health.cpuUtilization > conditions.maxCpuUtilization) {
      return false;
    }

    return true;
  }
}

// Application service with graceful degradation
class ECommerceService {
  private resilienceManager: ResilienceManager;
  private cache: Map<string, any> = new Map();

  constructor() {
    this.resilienceManager = new ResilienceManager('feature-flags');
  }

  async getProductRecommendations(userId: string): Promise<any[]> {
    const canUseMLRecommendations = await this.resilienceManager.shouldEnableFeature('ml-recommendations');
    const canUseCollaborativeFiltering = await this.resilienceManager.shouldEnableFeature('collaborative-filtering');

    try {
      if (canUseMLRecommendations) {
        return await this.getMLRecommendations(userId);
      } else if (canUseCollaborativeFiltering) {
        return await this.getCollaborativeRecommendations(userId);
      } else {
        // Fallback to simple popular products
        return await this.getPopularProducts();
      }
    } catch (error) {
      console.error('Recommendation service failed, using fallback:', error);
      return await this.getCachedRecommendations(userId) || [];
    }
  }

  async processOrder(orderData: any): Promise<{ success: boolean; orderId?: string; message: string }> {
    const canUseAdvancedPricing = await this.resilienceManager.shouldEnableFeature('advanced-pricing');
    const canUseInventoryReservation = await this.resilienceManager.shouldEnableFeature('inventory-reservation');

    try {
      // Core order processing always enabled
      const orderId = await this.createOrder(orderData);

      // Optional features with graceful degradation
      if (canUseAdvancedPricing) {
        await this.applyAdvancedPricing(orderId, orderData);
      } else {
        await this.applyBasicPricing(orderId, orderData);
      }

      if (canUseInventoryReservation) {
        await this.reserveInventory(orderId, orderData.items);
      } else {
        // Process without reservation, accept slight overselling risk
        console.warn(`Inventory reservation disabled for order ${orderId}`);
      }

      return {
        success: true,
        orderId,
        message: 'Order processed successfully'
      };
    } catch (error) {
      return {
        success: false,
        message: 'Order processing failed. Please try again.'
      };
    }
  }

  // Placeholder methods for actual implementations
  private async getMLRecommendations(userId: string): Promise<any[]> {
    // Call to ML service
    return [];
  }

  private async getCollaborativeRecommendations(userId: string): Promise<any[]> {
    // Call to collaborative filtering service
    return [];
  }

  private async getPopularProducts(): Promise<any[]> {
    // Return cached popular products
    return this.cache.get('popular-products') || [];
  }

  private async getCachedRecommendations(userId: string): Promise<any[] | null> {
    return this.cache.get(`recommendations-${userId}`);
  }

  private async createOrder(orderData: any): Promise<string> {
    // Core order creation logic
    return 'order-' + Date.now();
  }

  private async applyAdvancedPricing(orderId: string, orderData: any): Promise<void> {
    // Advanced pricing logic with dynamic discounts
  }

  private async applyBasicPricing(orderId: string, orderData: any): Promise<void> {
    // Simple pricing calculation
  }

  private async reserveInventory(orderId: string, items: any[]): Promise<void> {
    // Inventory reservation logic
  }
}

// Lambda handler with resilience patterns
export const orderHandler = async (event: any) => {
  const service = new ECommerceService();
  
  try {
    const result = await service.processOrder(event.orderData);
    
    return {
      statusCode: result.success ? 200 : 400,
      body: JSON.stringify(result)
    };
  } catch (error) {
    // Circuit breaker pattern: fail fast on repeated errors
    console.error('Order processing error:', error);
    
    return {
      statusCode: 503,
      body: JSON.stringify({
        success: false,
        message: 'Service temporarily unavailable. Please try again later.'
      })
    };
  }
};

The concept of antifragility extends beyond mere resilience to systems that actually improve under stress. While most systems degrade gracefully under load, antifragile systems use stress as information to strengthen their future responses. AWS services like Auto Scaling exhibit antifragile characteristics by learning from historical load patterns to pre-scale resources before anticipated demand spikes. Application-level antifragility might involve machine learning models that improve their predictions based on past failure patterns or monitoring systems that automatically tune alert thresholds based on operational experience.

Chaos engineering practices deliberately introduce failures to validate resilience assumptions and discover weaknesses before they manifest in production. AWS Fault Injection Simulator provides managed chaos engineering capabilities that can simulate various failure modes across AWS services. The practice of regularly conducting chaos experiments helps teams develop muscle memory for incident response and validates that monitoring and alerting systems correctly identify and escalate problems.

Implementing effective chaos engineering requires careful consideration of blast radius and safety mechanisms. Starting with non-production environments allows teams to develop confidence in their chaos experiments before conducting them in production. Automated rollback mechanisms ensure that chaos experiments don't cause prolonged outages, while comprehensive monitoring provides visibility into system behavior during experiments. The goal is not to cause failures but to learn how systems respond to failure conditions and identify areas for improvement.

```typescript
// Chaos Engineering implementation using AWS Fault Injection Simulator
import { FISClient, StartExperimentCommand, StopExperimentCommand, GetExperimentCommand } from '@aws-sdk/client-fis';
import { CloudWatchClient, PutMetricDataCommand } from '@aws-sdk/client-cloudwatch';
import { SSMClient, GetParameterCommand } from '@aws-sdk/client-ssm';

interface ChaosExperiment {
  name: string;
  templateId: string;
  targetResources: string[];
  duration: number;
  safeguards: {
    maxErrorRate: number;
    maxLatency: number;
    rollbackActions: string[];
  };
}

interface ExperimentResult {
  experimentId: string;
  success: boolean;
  duration: number;
  metrics: {
    errorRateBefore: number;
    errorRateAfter: number;
    latencyBefore: number;
    latencyAfter: number;
    recoveryTime: number;
  };
  lessons: string[];
}

class ChaosEngineeringOrchestrator {
  private fisClient: FISClient;
  private cloudWatchClient: CloudWatchClient;
  private ssmClient: SSMClient;

  constructor() {
    this.fisClient = new FISClient({});
    this.cloudWatchClient = new CloudWatchClient({});
    this.ssmClient = new SSMClient({});
  }

  async runChaosExperiment(experiment: ChaosExperiment): Promise<ExperimentResult> {
    console.log(`Starting chaos experiment: ${experiment.name}`);
    
    // Collect baseline metrics
    const baselineMetrics = await this.collectMetrics();
    
    try {
      // Check if it's safe to run experiment
      await this.validateSafeguards(experiment.safeguards);
      
      // Start the chaos experiment
      const experimentId = await this.startExperiment(experiment.templateId);
      
      // Monitor experiment progress
      const result = await this.monitorExperiment(
        experimentId, 
        experiment.duration, 
        experiment.safeguards,
        baselineMetrics
      );
      
      return result;
    } catch (error) {
      console.error(`Chaos experiment ${experiment.name} failed:`, error);
      throw error;
    }
  }

  private async startExperiment(templateId: string): Promise<string> {
    const response = await this.fisClient.send(new StartExperimentCommand({
      experimentTemplateId: templateId,
      tags: {
        'chaos-engineering': 'true',
        'environment': 'production',
        'automation': 'true'
      }
    }));

    if (!response.experiment?.id) {
      throw new Error('Failed to start chaos experiment');
    }

    return response.experiment.id;
  }

  private async monitorExperiment(
    experimentId: string, 
    duration: number, 
    safeguards: ChaosExperiment['safeguards'],
    baseline: any
  ): Promise<ExperimentResult> {
    const startTime = Date.now();
    const endTime = startTime + (duration * 1000);
    
    let shouldStop = false;
    const monitoringInterval = 30000; // Check every 30 seconds
    
    while (Date.now() < endTime && !shouldStop) {
      await new Promise(resolve => setTimeout(resolve, monitoringInterval));
      
      // Check current metrics against safeguards
      const currentMetrics = await this.collectMetrics();
      const safeguardViolation = await this.checkSafeguards(currentMetrics, safeguards);
      
      if (safeguardViolation) {
        console.warn('Safeguard violation detected, stopping experiment');
        await this.stopExperiment(experimentId);
        shouldStop = true;
      }
      
      // Log metrics for analysis
      await this.logMetrics(experimentId, currentMetrics);
    }

    // Collect final metrics
    const finalMetrics = await this.collectMetrics();
    
    // Wait for system to recover and measure recovery time
    const recoveryTime = await this.measureRecoveryTime(baseline);
    
    return {
      experimentId,
      success: !shouldStop,
      duration: Date.now() - startTime,
      metrics: {
        errorRateBefore: baseline.errorRate,
        errorRateAfter: finalMetrics.errorRate,
        latencyBefore: baseline.latency,
        latencyAfter: finalMetrics.latency,
        recoveryTime
      },
      lessons: await this.extractLessons(experimentId, baseline, finalMetrics)
    };
  }

  private async stopExperiment(experimentId: string): Promise<void> {
    await this.fisClient.send(new StopExperimentCommand({
      id: experimentId
    }));
  }

  private async validateSafeguards(safeguards: ChaosExperiment['safeguards']): Promise<void> {
    const currentMetrics = await this.collectMetrics();
    
    if (currentMetrics.errorRate > safeguards.maxErrorRate * 0.5) {
      throw new Error('System already showing elevated error rates, experiment aborted');
    }
    
    if (currentMetrics.latency > safeguards.maxLatency * 0.8) {
      throw new Error('System already showing elevated latency, experiment aborted');
    }
  }

  private async checkSafeguards(metrics: any, safeguards: ChaosExperiment['safeguards']): Promise<boolean> {
    return metrics.errorRate > safeguards.maxErrorRate || 
           metrics.latency > safeguards.maxLatency;
  }

  private async collectMetrics(): Promise<any> {
    // This would collect real metrics from CloudWatch
    // Placeholder implementation
    return {
      errorRate: Math.random() * 5, // 0-5% error rate
      latency: 100 + Math.random() * 200, // 100-300ms latency
      throughput: 1000 + Math.random() * 500 // 1000-1500 RPS
    };
  }

  private async measureRecoveryTime(baseline: any): Promise<number> {
    const recoveryStart = Date.now();
    const maxRecoveryTime = 300000; // 5 minutes max
    
    while (Date.now() - recoveryStart < maxRecoveryTime) {
      await new Promise(resolve => setTimeout(resolve, 10000)); // Check every 10 seconds
      
      const currentMetrics = await this.collectMetrics();
      
      // Consider recovered when metrics are within 10% of baseline
      if (Math.abs(currentMetrics.errorRate - baseline.errorRate) < baseline.errorRate * 0.1 &&
          Math.abs(currentMetrics.latency - baseline.latency) < baseline.latency * 0.1) {
        return Date.now() - recoveryStart;
      }
    }
    
    return maxRecoveryTime; // Recovery took longer than expected
  }

  private async logMetrics(experimentId: string, metrics: any): Promise<void> {
    await this.cloudWatchClient.send(new PutMetricDataCommand({
      Namespace: 'ChaosEngineering',
      MetricData: [
        {
          MetricName: 'ErrorRate',
          Value: metrics.errorRate,
          Unit: 'Percent',
          Dimensions: [
            { Name: 'ExperimentId', Value: experimentId }
          ]
        },
        {
          MetricName: 'Latency',
          Value: metrics.latency,
          Unit: 'Milliseconds',
          Dimensions: [
            { Name: 'ExperimentId', Value: experimentId }
          ]
        }
      ]
    }));
  }

  private async extractLessons(experimentId: string, baseline: any, final: any): Promise<string[]> {
    const lessons: string[] = [];
    
    if (final.errorRate > baseline.errorRate * 2) {
      lessons.push('System shows poor error handling under stress');
    }
    
    if (final.latency > baseline.latency * 3) {
      lessons.push('Latency degrades significantly under failure conditions');
    }
    
    // Add more analysis based on your specific metrics
    
    return lessons;
  }
}

// Automated chaos experiment runner
export const chaosExperimentHandler = async (event: { 
  environment: string;
  experimentType: string;
}) => {
  // Only run in non-production during business hours for safety
  const now = new Date();
  const isBusinessHours = now.getHours() >= 9 && now.getHours() <= 17;
  const isWeekday = now.getDay() >= 1 && now.getDay() <= 5;
  
  if (event.environment === 'production' && (!isBusinessHours || !isWeekday)) {
    return {
      statusCode: 400,
      body: JSON.stringify({
        message: 'Production chaos experiments only allowed during business hours'
      })
    };
  }

  const orchestrator = new ChaosEngineeringOrchestrator();
  
  const experiment: ChaosExperiment = {
    name: `${event.experimentType}-experiment`,
    templateId: await getExperimentTemplate(event.experimentType),
    targetResources: await getTargetResources(event.environment),
    duration: 300, // 5 minutes
    safeguards: {
      maxErrorRate: 10, // 10% error rate threshold
      maxLatency: 5000, // 5 second latency threshold
      rollbackActions: ['stop-experiment', 'scale-up-resources']
    }
  };

  try {
    const result = await orchestrator.runChaosExperiment(experiment);
    
    return {
      statusCode: 200,
      body: JSON.stringify({
        experimentId: result.experimentId,
        success: result.success,
        duration: result.duration,
        metrics: result.metrics,
        lessons: result.lessons
      })
    };
  } catch (error) {
    return {
      statusCode: 500,
      body: JSON.stringify({
        error: 'Chaos experiment failed',
        message: error.message
      })
    };
  }
};

// Helper functions
async function getExperimentTemplate(experimentType: string): Promise<string> {
  // Return appropriate FIS template ID based on experiment type
  const templates = {
    'network-latency': 'EXT123456789',
    'instance-termination': 'EXT987654321',
    'database-failover': 'EXT456789123'
  };
  return templates[experimentType] || templates['network-latency'];
}

async function getTargetResources(environment: string): Promise<string[]> {
  // Return resource ARNs for the specified environment
  return [`arn:aws:ec2:us-east-1:123456789012:instance/i-${environment}example`];
}