// lib/global-link-shortener-stack.ts - Multi-region deployment pattern
import * as cdk from 'aws-cdk-lib';
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
import * as route53 from 'aws-cdk-lib/aws-route53';
import * as cloudfront from 'aws-cdk-lib/aws-cloudfront';
import { Construct } from 'constructs';

export interface GlobalLinkShortenerProps {
  readonly primaryRegion: string;
  readonly replicationRegions: string[];
  readonly domainName: string;
  readonly certificateArn: string;
}

export class GlobalLinkShortenerStack extends cdk.Stack {
  public readonly globalTable: dynamodb.Table;
  public readonly distribution: cloudfront.Distribution;

  constructor(scope: Construct, id: string, props: GlobalLinkShortenerProps) {
    super(scope, id, { 
      env: { region: props.primaryRegion },
      crossRegionReferences: true 
    });

    // Global DynamoDB table mit cross-region replication
    this.globalTable = new dynamodb.Table(this, 'GlobalLinksTable', {
      tableName: 'global-links-table',
      partitionKey: { name: 'shortCode', type: dynamodb.AttributeType.STRING },
      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
      
      // Point-in-time recovery für globale Daten
      pointInTimeRecovery: true,
      
      // Global tables für multi-region active-active
      replicationRegions: props.replicationRegions,
      
      // Stream für real-time Analytics über Regionen
      stream: dynamodb.StreamViewType.NEW_AND_OLD_IMAGES,
      
      // Deletion protection - das hab ich auf die harte Tour gelernt
      removalPolicy: cdk.RemovalPolicy.RETAIN,
      deletionProtection: true,
    });

    // Global secondary index für Analytics Queries
    this.globalTable.addGlobalSecondaryIndex({
      indexName: 'domain-timestamp-index',
      partitionKey: { name: 'domain', type: dynamodb.AttributeType.STRING },
      sortKey: { name: 'createdAt', type: dynamodb.AttributeType.STRING },
    });

    // Route 53 health checks für jede Region
    const healthChecks = props.replicationRegions.map((region, index) => {
      return new route53.CfnHealthCheck(this, `HealthCheck-${region}`, {
        type: 'HTTPS',
        resourcePath: '/health',
        fullyQualifiedDomainName: `${region}.${props.domainName}`,
        port: 443,
        requestInterval: 30,
        failureThreshold: 3,
      });
    });

    // Global CloudFront Distribution mit regionalen Origins
    this.distribution = new cloudfront.Distribution(this, 'GlobalDistribution', {
      comment: 'Global Link Shortener Distribution',
      
      // Price class für globale Edge Locations
      priceClass: cloudfront.PriceClass.PRICE_CLASS_ALL,
      
      // Custom domain Konfiguration
      domainNames: [props.domainName],
      certificate: acm.Certificate.fromCertificateArn(
        this, 'Certificate', props.certificateArn
      ),
      
      // Regionale Origins mit Health Check Failover
      additionalBehaviors: this.createRegionalBehaviors(props.replicationRegions),
      
      // Cache Policy für Redirect Responses
      defaultBehavior: {
        origin: new origins.HttpOrigin(`${props.primaryRegion}.${props.domainName}`),
        cachePolicy: cloudfront.CachePolicy.CACHING_OPTIMIZED,
        originRequestPolicy: cloudfront.OriginRequestPolicy.CORS_S3_ORIGIN,
        viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
        
        // Edge Lambda für Geo-Routing Optimierung
        edgeLambdas: [{
          functionVersion: this.createEdgeFunction(),
          eventType: cloudfront.LambdaEdgeEventType.ORIGIN_REQUEST,
        }],
      },
    });
  }

  private createRegionalBehaviors(regions: string[]) {
    const behaviors: Record<string, cloudfront.BehaviorOptions> = {};
    
    regions.forEach(region => {
      behaviors[`/${region}/*`] = {
        origin: new origins.HttpOrigin(`${region}.api.example.com`),
        cachePolicy: cloudfront.CachePolicy.CACHING_OPTIMIZED,
        viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
      };
    });
    
    return behaviors;
  }
}

// bin/global-deployment.ts - Regionale Deployment Orchestrierung
#!/usr/bin/env node
import 'source-map-support/register';
import * as cdk from 'aws-cdk-lib';
import { GlobalLinkShortenerStack } from '../lib/global-link-shortener-stack';
import { RegionalLinkShortenerStack } from '../lib/regional-link-shortener-stack';

const app = new cdk.App();

// Configuration driven deployment
const regions = [
  { name: 'us-east-1', isPrimary: true, weight: 40 },
  { name: 'eu-west-1', isPrimary: false, weight: 35 },
  { name: 'ap-southeast-1', isPrimary: false, weight: 25 },
];

const domainName = app.node.tryGetContext('domainName') || 'links.example.com';

// Deploy primary global resources
const globalStack = new GlobalLinkShortenerStack(app, 'GlobalLinkShortener', {
  primaryRegion: 'us-east-1',
  replicationRegions: regions.filter(r => !r.isPrimary).map(r => r.name),
  domainName,
  certificateArn: app.node.tryGetContext('certificateArn'),
});

// Deploy regional stacks
regions.forEach(region => {
  new RegionalLinkShortenerStack(app, `LinkShortener-${region.name}`, {
    env: { region: region.name },
    globalTable: globalStack.globalTable,
    isPrimaryRegion: region.isPrimary,
    trafficWeight: region.weight,
    domainName,
    
    // Cross-stack references für globale Resources
    crossRegionReferences: true,
  });
});

// lib/database-scaling-stack.ts - Erweiterte DynamoDB Scaling Patterns
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
import * as elasticache from 'aws-cdk-lib/aws-elasticache';
import * as lambda from 'aws-cdk-lib/aws-lambda';

export class ScalableDatabaseStack extends cdk.Stack {
  
  // Hot Partition Detection und Mitigation
  private createShardedTable() {
    const table = new dynamodb.Table(this, 'ShardedLinksTable', {
      partitionKey: { name: 'shardKey', type: dynamodb.AttributeType.STRING },
      sortKey: { name: 'shortCode', type: dynamodb.AttributeType.STRING },
      
      // On-demand Scaling für unvorhersehbaren Traffic
      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
      
      // Contributor Insights für Hot Partition Detection
      contributorInsightsEnabled: true,
    });

    // Add write sharding logic
    const shardingFunction = new lambda.Function(this, 'ShardingFunction', {
      runtime: lambda.Runtime.NODEJS_18_X,
      handler: 'sharding.handler',
      code: lambda.Code.fromAsset('functions'),
      environment: {
        SHARD_COUNT: '100', // Load über Shards verteilen
        TABLE_NAME: table.tableName,
      },
    });

    return table;
  }

  // Redis Cluster für Hot Link Caching
  private createCacheCluster() {
    const cacheSubnetGroup = new elasticache.CfnSubnetGroup(
      this, 'CacheSubnetGroup', {
        description: 'Subnet group für Redis cluster',
        subnetIds: this.vpc.privateSubnets.map(subnet => subnet.subnetId),
      }
    );

    return new elasticache.CfnCacheCluster(this, 'RedisCluster', {
      engine: 'redis',
      engineVersion: '7.0',
      cacheNodeType: 'cache.r6g.large',
      numCacheNodes: 1,
      
      // Multi-AZ für High Availability
      azMode: 'cross-az',
      preferredAvailabilityZones: ['us-east-1a', 'us-east-1b'],
      
      // Subnet und Security Konfiguration
      cacheSubnetGroupName: cacheSubnetGroup.ref,
      vpcSecurityGroupIds: [this.cacheSecurityGroup.securityGroupId],
      
      // Backup und Maintenance
      snapshotRetentionLimit: 5,
      snapshotWindow: '03:00-05:00',
      preferredMaintenanceWindow: 'sun:05:00-sun:07:00',
    });
  }

  // Read Replica Pattern für Analytics
  private createAnalyticsReadReplicas() {
    // Separate Table für Analytics um Redirects nicht zu beeinträchtigen
    return new dynamodb.Table(this, 'AnalyticsTable', {
      partitionKey: { name: 'date', type: dynamodb.AttributeType.STRING },
      sortKey: { name: 'linkId', type: dynamodb.AttributeType.STRING },
      
      // Time-based Partitioning für Analytics Queries
      timeToLiveAttribute: 'ttl',
      
      // Stream Processing für Real-time Aggregation
      stream: dynamodb.StreamViewType.NEW_AND_OLD_IMAGES,
    });
  }
}

// functions/sharding.ts - Hot Partition Mitigation
import { DynamoDBClient, PutItemCommand } from '@aws-sdk/client-dynamodb';
import { createHash } from 'crypto';

interface LinkData {
  shortCode: string;
  targetUrl: string;
  domain: string;
  createdAt: string;
}

export const handler = async (event: any) => {
  const { shortCode, targetUrl, domain } = event as LinkData;
  
  // Shard Key Generation um Load zu verteilen
  const shardKey = generateShardKey(shortCode, domain);
  
  const client = new DynamoDBClient({});
  
  // Write to sharded partition
  const command = new PutItemCommand({
    TableName: process.env.TABLE_NAME,
    Item: {
      shardKey: { S: shardKey },
      shortCode: { S: shortCode },
      targetUrl: { S: targetUrl },
      domain: { S: domain },
      createdAt: { S: new Date().toISOString() },
      
      // TTL für automatisches Cleanup von alten Links
      ttl: { N: Math.floor(Date.now() / 1000) + (365 * 24 * 60 * 60) },
    },
    
    // Conditional write um Overwrites zu verhindern
    ConditionExpression: 'attribute_not_exists(shortCode)',
  });

  try {
    await client.send(command);
    return { statusCode: 201, body: JSON.stringify({ shortCode, shardKey }) };
  } catch (error) {
    console.error('Sharding write failed:', error);
    throw new Error('Failed to create sharded link');
  }
};

function generateShardKey(shortCode: string, domain: string): string {
  const shardCount = parseInt(process.env.SHARD_COUNT || '10');
  
  // Consistent Hashing für gleichmäßige Verteilung
  const hash = createHash('md5')
    .update(`${shortCode}-${domain}`)
    .digest('hex');
  
  const shardIndex = parseInt(hash.substring(0, 8), 16) % shardCount;
  return `shard-${shardIndex.toString().padStart(3, '0')}`;
}

// lib/disaster-recovery-stack.ts - Multi-region Failover Automation
import * as route53 from 'aws-cdk-lib/aws-route53';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as sns from 'aws-cdk-lib/aws-sns';
import * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';

export class DisasterRecoveryStack extends cdk.Stack {
  
  // Automatisiertes Failover mit Route 53 Health Checks
  private createFailoverRouting() {
    const hostedZone = route53.HostedZone.fromLookup(this, 'Zone', {
      domainName: 'example.com',
    });

    // Primary Region Record mit Health Check
    const primaryHealthCheck = new route53.CfnHealthCheck(this, 'PrimaryHealth', {
      type: 'HTTPS',
      resourcePath: '/health',
      fullyQualifiedDomainName: 'us-east-1.api.example.com',
      port: 443,
      requestInterval: 30,
      failureThreshold: 3,
      
      // CloudWatch Alarm Integration
      insufficientDataHealthStatus: 'Failure',
      measureLatency: true,
      regions: ['us-east-1', 'us-west-1', 'eu-west-1'],
    });

    // Primary Record mit Failover Routing
    new route53.ARecord(this, 'PrimaryRecord', {
      zone: hostedZone,
      recordName: 'api',
      target: route53.RecordTarget.fromIpAddresses('1.2.3.4'),
      setIdentifier: 'primary',
      failover: route53.FailoverRoutingPolicy.PRIMARY,
      healthCheckId: primaryHealthCheck.attrHealthCheckId,
    });

    // Secondary Region Record
    const secondaryHealthCheck = new route53.CfnHealthCheck(this, 'SecondaryHealth', {
      type: 'HTTPS',
      resourcePath: '/health',
      fullyQualifiedDomainName: 'eu-west-1.api.example.com',
      port: 443,
      requestInterval: 30,
      failureThreshold: 3,
    });

    new route53.ARecord(this, 'SecondaryRecord', {
      zone: hostedZone,
      recordName: 'api',
      target: route53.RecordTarget.fromIpAddresses('5.6.7.8'),
      setIdentifier: 'secondary',
      failover: route53.FailoverRoutingPolicy.SECONDARY,
      healthCheckId: secondaryHealthCheck.attrHealthCheckId,
    });
  }

  // Cross-region Backup Automation
  private createBackupStrategy() {
    const backupFunction = new lambda.Function(this, 'BackupFunction', {
      runtime: lambda.Runtime.NODEJS_18_X,
      handler: 'backup.handler',
      code: lambda.Code.fromAsset('functions'),
      timeout: cdk.Duration.minutes(15),
      
      environment: {
        PRIMARY_TABLE: 'links-table-us-east-1',
        BACKUP_BUCKET: 'links-backup-bucket',
        CROSS_REGION_BUCKET: 'links-backup-eu-west-1',
      },
    });

    // Schedule daily backups
    new events.Rule(this, 'BackupSchedule', {
      schedule: events.Schedule.cron({ 
        hour: '2', 
        minute: '0' 
      }),
      targets: [new targets.LambdaFunction(backupFunction)],
    });

    // Point-in-time Recovery Monitoring
    const recoveryAlarm = new cloudwatch.Alarm(this, 'RecoveryAlarm', {
      metric: backupFunction.metricErrors(),
      threshold: 1,
      evaluationPeriods: 1,
    });

    // SNS Notification für Backup Failures
    const alertTopic = new sns.Topic(this, 'BackupAlerts');
    recoveryAlarm.addAlarmAction(new cloudwatchActions.SnsAction(alertTopic));
  }
}

// functions/backup.ts - Automatisierte Disaster Recovery Backup
import { DynamoDBClient, ScanCommand } from '@aws-sdk/client-dynamodb';
import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
import { gzip } from 'zlib';
import { promisify } from 'util';

const gzipAsync = promisify(gzip);

export const handler = async (event: any) => {
  const dynamoClient = new DynamoDBClient({ region: 'us-east-1' });
  const s3Client = new S3Client({ region: 'us-east-1' });
  
  const timestamp = new Date().toISOString().split('T')[0];
  let lastEvaluatedKey;
  let backupData = [];

  try {
    // Paginated Scan der gesamten Table
    do {
      const scanCommand = new ScanCommand({
        TableName: process.env.PRIMARY_TABLE,
        ExclusiveStartKey: lastEvaluatedKey,
        Limit: 1000, // In Chunks verarbeiten
      });

      const result = await dynamoClient.send(scanCommand);
      if (result.Items) {
        backupData.push(...result.Items);
      }
      
      lastEvaluatedKey = result.LastEvaluatedKey;
      
      // Progress Logging für große Tables
      console.log(`Backed up ${backupData.length} items...`);
      
    } while (lastEvaluatedKey);

    // Backup komprimieren und uploaden
    const compressed = await gzipAsync(JSON.stringify(backupData));
    
    const uploadCommand = new PutObjectCommand({
      Bucket: process.env.BACKUP_BUCKET,
      Key: `daily-backups/${timestamp}/links-backup.json.gz`,
      Body: compressed,
      
      // Cross-region Replication Tags
      Tagging: 'BackupType=Daily&Region=us-east-1&Replicate=true',
      
      // Encryption für sensitive Daten
      ServerSideEncryption: 'AES256',
    });

    await s3Client.send(uploadCommand);
    
    // Cross-region Copy für echtes Disaster Recovery
    await copyToSecondaryRegion(compressed, timestamp);
    
    return {
      statusCode: 200,
      body: JSON.stringify({
        itemsBackedUp: backupData.length,
        backupKey: `daily-backups/${timestamp}/links-backup.json.gz`,
        timestamp,
      }),
    };

  } catch (error) {
    console.error('Backup failed:', error);
    
    // Alert an Operations Team senden
    await sendAlert({
      subject: 'Link Shortener Backup Failed',
      message: `Backup failed at ${new Date().toISOString()}: ${error.message}`,
      severity: 'HIGH',
    });
    
    throw error;
  }
};

async function copyToSecondaryRegion(data: Buffer, timestamp: string) {
  const secondaryS3 = new S3Client({ region: 'eu-west-1' });
  
  return secondaryS3.send(new PutObjectCommand({
    Bucket: process.env.CROSS_REGION_BUCKET,
    Key: `daily-backups/${timestamp}/links-backup.json.gz`,
    Body: data,
    ServerSideEncryption: 'AES256',
  }));
}

// lib/maintenance-automation-stack.ts - Technical Debt Management
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as stepfunctions from 'aws-cdk-lib/aws-stepfunctions';
import * as events from 'aws-cdk-lib/aws-events';

export class MaintenanceAutomationStack extends cdk.Stack {
  
  // Automatisierte Dependency Updates
  private createDependencyUpdatePipeline() {
    const updateFunction = new lambda.Function(this, 'DependencyUpdater', {
      runtime: lambda.Runtime.NODEJS_18_X,
      handler: 'maintenance.updateDependencies',
      code: lambda.Code.fromAsset('functions'),
      timeout: cdk.Duration.minutes(5),
      
      environment: {
        GITHUB_TOKEN: 'your-github-token',
        REPOSITORY: 'your-org/link-shortener',
        SLACK_WEBHOOK: process.env.SLACK_WEBHOOK || '',
      },
    });

    // Wöchentliche Dependency Checks
    new events.Rule(this, 'WeeklyUpdates', {
      schedule: events.Schedule.cron({
        weekDay: '1', // Montag
        hour: '9',
        minute: '0',
      }),
      targets: [new targets.LambdaFunction(updateFunction)],
    });
  }

  // Data Cleanup Automation
  private createDataCleanupPipeline() {
    // Step Function für sicheres Data Cleanup
    const cleanupWorkflow = new stepfunctions.StateMachine(this, 'CleanupWorkflow', {
      definition: stepfunctions.Chain
        .start(new stepfunctions.Task(this, 'IdentifyExpiredLinks', {
          task: new tasks.LambdaInvoke(this.identifyExpiredLinksFunction),
        }))
        .next(new stepfunctions.Task(this, 'CreateBackupSnapshot', {
          task: new tasks.LambdaInvoke(this.createBackupFunction),
        }))
        .next(new stepfunctions.Task(this, 'DeleteExpiredLinks', {
          task: new tasks.LambdaInvoke(this.deleteExpiredLinksFunction),
        }))
        .next(new stepfunctions.Task(this, 'VerifyCleanup', {
          task: new tasks.LambdaInvoke(this.verifyCleanupFunction),
        })),
      timeout: cdk.Duration.hours(2),
    });

    // Monatliches Cleanup Schedule
    new events.Rule(this, 'MonthlyCleanup', {
      schedule: events.Schedule.cron({
        day: '1',
        hour: '3',
        minute: '0',
      }),
      targets: [new targets.SfnStateMachine(cleanupWorkflow)],
    });
  }

  // Security Audit Automation
  private createSecurityAuditPipeline() {
    const auditFunction = new lambda.Function(this, 'SecurityAuditor', {
      runtime: lambda.Runtime.NODEJS_18_X,
      handler: 'security.auditSystem',
      code: lambda.Code.fromAsset('functions'),
      timeout: cdk.Duration.minutes(10),
      
      environment: {
        SECURITY_SCAN_BUCKET: 'security-audit-results',
        COMPLIANCE_WEBHOOK: process.env.COMPLIANCE_WEBHOOK || '',
      },
    });

    // Tägliche Security Checks
    new events.Rule(this, 'DailySecurityAudit', {
      schedule: events.Schedule.rate(cdk.Duration.days(1)),
      targets: [new targets.LambdaFunction(auditFunction)],
    });
  }
}

// functions/maintenance.ts - Automatisierte Maintenance Tasks
import { Octokit } from '@octokit/rest';
import { execSync } from 'child_process';
import { writeFileSync, readFileSync } from 'fs';

export const updateDependencies = async (event: any) => {
  const octokit = new Octokit({
    auth: process.env.GITHUB_TOKEN,
  });

  try {
    // Check für outdated packages
    const outdated = execSync('npm outdated --json', { encoding: 'utf8' });
    const outdatedPackages = JSON.parse(outdated);
    
    if (Object.keys(outdatedPackages).length === 0) {
      console.log('All dependencies sind up to date');
      return { statusCode: 200, body: 'No updates needed' };
    }

    // Feature Branch für Updates erstellen
    const branchName = `dependency-updates-${new Date().toISOString().split('T')[0]}`;
    
    await octokit.rest.git.createRef({
      owner: 'your-org',
      repo: 'link-shortener',
      ref: `refs/heads/${branchName}`,
      sha: await getCurrentCommitSha(),
    });

    // package.json mit kompatiblen Versionen updaten
    const packageJson = JSON.parse(readFileSync('package.json', 'utf8'));
    let updatedCount = 0;

    for (const [pkg, info] of Object.entries(outdatedPackages)) {
      const pkgInfo = info as any;
      
      // Nur Patch und Minor Versions für Stabilität updaten
      if (isCompatibleUpdate(pkgInfo.current, pkgInfo.latest)) {
        if (packageJson.dependencies[pkg]) {
          packageJson.dependencies[pkg] = `^${pkgInfo.latest}`;
          updatedCount++;
        }
        if (packageJson.devDependencies[pkg]) {
          packageJson.devDependencies[pkg] = `^${pkgInfo.latest}`;
          updatedCount++;
        }
      }
    }

    if (updatedCount > 0) {
      writeFileSync('package.json', JSON.stringify(packageJson, null, 2));
      
      // Tests laufen lassen um Kompatibilität zu prüfen
      const testResult = execSync('npm test', { encoding: 'utf8' });
      
      // Pull Request erstellen
      await octokit.rest.pulls.create({
        owner: 'your-org',
        repo: 'link-shortener',
        title: `Automatisierte Dependency Updates (${updatedCount} packages)`,
        head: branchName,
        base: 'main',
        body: createPRBody(outdatedPackages, updatedCount),
      });

      await notifySlack(`Created PR für ${updatedCount} dependency updates`);
    }

    return {
      statusCode: 200,
      body: JSON.stringify({ updatedPackages: updatedCount }),
    };

  } catch (error) {
    console.error('Dependency update failed:', error);
    await notifySlack(`❌ Dependency update failed: ${error.message}`);
    throw error;
  }
};

function isCompatibleUpdate(current: string, latest: string): boolean {
  const [currentMajor, currentMinor] = current.split('.').map(Number);
  const [latestMajor, latestMinor] = latest.split('.').map(Number);
  
  // Nur gleiche Major Version Updates erlauben
  return currentMajor === latestMajor && latestMinor >= currentMinor;
}

async function notifySlack(message: string) {
  if (!process.env.SLACK_WEBHOOK) return;
  
  await fetch(process.env.SLACK_WEBHOOK, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ text: message }),
  });
}

// lib/operational-excellence-stack.ts - Observability und Alerting
import * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';
import * as sns from 'aws-cdk-lib/aws-sns';
import * as chatbot from 'aws-cdk-lib/aws-chatbot';

export class OperationalExcellenceStack extends cdk.Stack {
  
  // Umfassendes Monitoring Dashboard
  private createOperationalDashboard() {
    const dashboard = new cloudwatch.Dashboard(this, 'OperationalDashboard', {
      dashboardName: 'LinkShortener-Operations',
      
      widgets: [
        // SLA Monitoring
        [
          new cloudwatch.GraphWidget({
            title: 'Response Time SLA (95th Percentile)',
            left: [
              new cloudwatch.Metric({
                namespace: 'AWS/Lambda',
                metricName: 'Duration',
                statistic: 'p95',
                dimensionsMap: {
                  FunctionName: 'redirect-function',
                },
              }),
            ],
            leftYAxis: { min: 0, max: 100 },
            
            // SLA Linie bei 50ms
            leftAnnotations: [{
              value: 50,
              label: 'SLA Threshold',
              color: cloudwatch.Color.RED,
            }],
          }),
          
          new cloudwatch.SingleValueWidget({
            title: 'Aktuelle Availability',
            metrics: [
              new cloudwatch.MathExpression({
                expression: '100 - (errors / requests * 100)',
                usingMetrics: {
                  errors: new cloudwatch.Metric({
                    namespace: 'AWS/Lambda',
                    metricName: 'Errors',
                    statistic: 'Sum',
                  }),
                  requests: new cloudwatch.Metric({
                    namespace: 'AWS/Lambda',
                    metricName: 'Invocations',
                    statistic: 'Sum',
                  }),
                },
              }),
            ],
          }),
        ],
        
        // Cost Monitoring
        [
          new cloudwatch.GraphWidget({
            title: 'Tägliche Cost Breakdown',
            stacked: true,
            left: [
              new cloudwatch.Metric({
                namespace: 'AWS/Billing',
                metricName: 'EstimatedCharges',
                statistic: 'Maximum',
                dimensionsMap: {
                  Currency: 'USD',
                  ServiceName: 'AmazonDynamoDB',
                },
              }),
              new cloudwatch.Metric({
                namespace: 'AWS/Billing',
                metricName: 'EstimatedCharges',
                statistic: 'Maximum',
                dimensionsMap: {
                  Currency: 'USD',
                  ServiceName: 'AWSLambda',
                },
              }),
            ],
          }),
        ],
        
        // Business Metrics
        [
          new cloudwatch.GraphWidget({
            title: 'Business Impact Metrics',
            left: [
              new cloudwatch.Metric({
                namespace: 'LinkShortener/Business',
                metricName: 'LinksCreated',
                statistic: 'Sum',
              }),
              new cloudwatch.Metric({
                namespace: 'LinkShortener/Business',
                metricName: 'RedirectsServed',
                statistic: 'Sum',
              }),
            ],
          }),
        ],
      ],
    });

    return dashboard;
  }

  // Intelligentes Alerting System
  private createIntelligentAlerting() {
    const criticalAlerts = new sns.Topic(this, 'CriticalAlerts');
    const warningAlerts = new sns.Topic(this, 'WarningAlerts');

    // P1: Service Down
    new cloudwatch.Alarm(this, 'ServiceDownAlarm', {
      alarmName: 'LinkShortener-ServiceDown-P1',
      metric: new cloudwatch.Metric({
        namespace: 'AWS/Lambda',
        metricName: 'Errors',
        statistic: 'Sum',
        dimensionsMap: { FunctionName: 'redirect-function' },
      }),
      threshold: 10,
      evaluationPeriods: 2,
      datapointsToAlarm: 2,
      treatMissingData: cloudwatch.TreatMissingData.BREACHING,
      
      alarmActions: [new cloudwatchActions.SnsAction(criticalAlerts)],
    });

    // P2: Performance Degradation
    new cloudwatch.Alarm(this, 'PerformanceDegradationAlarm', {
      alarmName: 'LinkShortener-SlowResponse-P2',
      metric: new cloudwatch.Metric({
        namespace: 'AWS/Lambda',
        metricName: 'Duration',
        statistic: 'p95',
      }),
      threshold: 100, // 100ms P95
      evaluationPeriods: 3,
      datapointsToAlarm: 2,
      
      alarmActions: [new cloudwatchActions.SnsAction(warningAlerts)],
    });

    // P3: Capacity Planning
    new cloudwatch.Alarm(this, 'CapacityPlanningAlarm', {
      alarmName: 'LinkShortener-HighLoad-P3',
      metric: new cloudwatch.Metric({
        namespace: 'AWS/DynamoDB',
        metricName: 'ConsumedReadCapacityUnits',
        statistic: 'Sum',
      }),
      threshold: 8000, // 80% der provisioned capacity
      evaluationPeriods: 5,
      datapointsToAlarm: 3,
      
      alarmActions: [new cloudwatchActions.SnsAction(warningAlerts)],
    });

    // Slack Integration für Team Notifications
    new chatbot.SlackChannelConfiguration(this, 'SlackNotifications', {
      slackChannelConfigurationName: 'linkshortener-alerts',
      slackWorkspaceId: 'YOUR_WORKSPACE_ID',
      slackChannelId: 'C01234567890',
      
      notificationTopics: [criticalAlerts, warningAlerts],
      guardrailPolicies: ['arn:aws:iam::aws:policy/CloudWatchReadOnlyAccess'],
    });
  }
}

// functions/incident-response.ts - Automatisierte Incident Response
export const autoIncidentResponse = async (event: any) => {
  const alarmName = event.Records[0].Sns.Message.AlarmName;
  const severity = extractSeverity(alarmName);
  
  console.log(`Processing ${severity} incident: ${alarmName}`);

  // Automatisierte Remediation basierend auf Severity
  switch (severity) {
    case 'P1':
      await handleCriticalIncident(event);
      break;
    case 'P2':
      await handlePerformanceIssue(event);
      break;
    case 'P3':
      await handleCapacityWarning(event);
      break;
  }
};

async function handleCriticalIncident(event: any) {
  // 1. PagerDuty Incident erstellen
  await createPagerDutyIncident({
    title: 'Link Shortener Service Down',
    severity: 'critical',
    service: 'link-shortener-prod',
  });

  // 2. Emergency Read Replicas aktivieren
  await enableEmergencyReadReplicas();

  // 3. Auf Maintenance Page switchen
  await updateMaintenancePage(true);

  // 4. Diagnostic Data Collection starten
  await collectDiagnosticData();
  
  // 5. Stakeholder benachrichtigen
  await notifyStakeholders('CRITICAL: Link shortener is experiencing downtime');
}

async function handlePerformanceIssue(event: any) {
  // Auto-scale DynamoDB capacity
  await scaleDynamoDBCapacity(1.5); // 50% Erhöhung
  
  // Cache leeren um potentiell langsame Queries zu entfernen
  await clearApplicationCache();
  
  // Performance Metrics sammeln
  await collectPerformanceMetrics();
}

async function handleCapacityWarning(event: any) {
  // Capacity Planning Automation
  const projectedGrowth = await calculateGrowthTrend();
  
  if (projectedGrowth > 0.8) { // 80% growth trend
    await scheduleCapacityReview();
    await notifyCapacityTeam(projectedGrowth);
  }
}

// functions/capacity-planning.ts - Growth Forecasting und Capacity Planning
import { CloudWatchClient, GetMetricStatisticsCommand } from '@aws-sdk/client-cloudwatch';
import { DynamoDBClient, DescribeTableCommand } from '@aws-sdk/client-dynamodb';

interface CapacityProjection {
  currentCapacity: number;
  projectedDemand: number;
  recommendedCapacity: number;
  confidenceLevel: number;
  timeframe: string;
}

export const generateCapacityForecast = async (event: any): Promise<CapacityProjection> => {
  const cloudwatch = new CloudWatchClient({});
  const dynamodb = new DynamoDBClient({});

  // Historische Traffic Patterns analysieren
  const historicalData = await getHistoricalMetrics(cloudwatch, 90); // 90 Tage
  const seasonalPatterns = analyzeSeasonalTrends(historicalData);
  const growthTrend = calculateGrowthTrend(historicalData);

  // Aktuelle Capacity Settings holen
  const currentCapacity = await getCurrentCapacity(dynamodb);

  // Future Demand forecasten
  const projection = projectDemand({
    historicalData,
    seasonalPatterns,
    growthTrend,
    currentCapacity,
    timeframe: '30days',
  });

  // Actionable Recommendations generieren
  const recommendations = generateRecommendations(projection);

  // Capacity Planning Report erstellen
  await createCapacityReport({
    projection,
    recommendations,
    timestamp: new Date().toISOString(),
  });

  return projection;
};

async function getHistoricalMetrics(client: CloudWatchClient, days: number) {
  const endTime = new Date();
  const startTime = new Date(endTime.getTime() - days * 24 * 60 * 60 * 1000);

  const command = new GetMetricStatisticsCommand({
    Namespace: 'AWS/DynamoDB',
    MetricName: 'ConsumedReadCapacityUnits',
    Dimensions: [
      { Name: 'TableName', Value: 'links-table' },
    ],
    StartTime: startTime,
    EndTime: endTime,
    Period: 3600, // 1 Stunde Perioden
    Statistics: ['Average', 'Maximum'],
  });

  const response = await client.send(command);
  return response.Datapoints || [];
}

function analyzeSeasonalTrends(data: any[]) {
  // Gruppieren nach Wochentag und Stunde
  const patterns = {
    hourly: new Array(24).fill(0),
    daily: new Array(7).fill(0),
    monthly: new Array(12).fill(0),
  };

  data.forEach(point => {
    const date = new Date(point.Timestamp);
    const hour = date.getHours();
    const day = date.getDay();
    const month = date.getMonth();

    patterns.hourly[hour] += point.Average;
    patterns.daily[day] += point.Average;
    patterns.monthly[month] += point.Average;
  });

  // Patterns normalisieren
  return {
    peakHour: patterns.hourly.indexOf(Math.max(...patterns.hourly)),
    peakDay: patterns.daily.indexOf(Math.max(...patterns.daily)),
    peakMonth: patterns.monthly.indexOf(Math.max(...patterns.monthly)),
    variance: calculateVariance(patterns.hourly),
  };
}

function projectDemand(config: any): CapacityProjection {
  const {
    historicalData,
    seasonalPatterns,
    growthTrend,
    currentCapacity,
    timeframe,
  } = config;

  // Linear Regression für Growth Projection
  const baselineGrowth = growthTrend.slope * 30; // 30-Tage Projection
  
  // Seasonal Adjustment
  const seasonalMultiplier = getSeasonalMultiplier(seasonalPatterns, timeframe);
  
  // Business Event Adjustments (Holiday Sales, Marketing Campaigns)
  const eventMultiplier = getBusinessEventMultiplier(timeframe);

  const projectedDemand = 
    currentCapacity.average * 
    (1 + baselineGrowth) * 
    seasonalMultiplier * 
    eventMultiplier;

  return {
    currentCapacity: currentCapacity.provisioned,
    projectedDemand: Math.ceil(projectedDemand),
    recommendedCapacity: Math.ceil(projectedDemand * 1.2), // 20% Buffer
    confidenceLevel: calculateConfidence(growthTrend.r2),
    timeframe,
  };
}

function generateRecommendations(projection: CapacityProjection) {
  const recommendations = [];

  if (projection.projectedDemand > projection.currentCapacity * 0.8) {
    recommendations.push({
      type: 'SCALE_UP',
      urgency: 'HIGH',
      action: `DynamoDB Capacity auf ${projection.recommendedCapacity} RCU erhöhen`,
      estimatedCost: calculateCostIncrease(projection),
    });
  }

  if (projection.confidenceLevel &lt;0.7) {
    recommendations.push({
      type: 'MONITORING',
      urgency: 'MEDIUM',
      action: 'Monitoring Frequency erhöhen wegen niedrigem Confidence in Projection',
      estimatedCost: 0,
    });
  }

  return recommendations;
}