// Default bus: receives all AWS service events (CloudTrail, CodePipeline, EC2 state changes, etc.)
// Cannot be deleted. Cannot be modified. AWS publishes to it automatically.

// Custom bus: your domain events
import { EventBus } from 'aws-cdk-lib/aws-events'
const appBus = new EventBus(this, 'AppEventBus', {
  eventBusName: 'myapp-events',
})

// Partner bus: SaaS integrations (Shopify, Stripe, Datadog, Auth0, etc.)
// Created when you activate an event source from the SaaS partner
// Partner events flow in without any ingestion Lambda

// Rule: route all completed orders to the fulfillment Lambda
import { Rule, EventPattern } from 'aws-cdk-lib/aws-events'
import { LambdaFunction } from 'aws-cdk-lib/aws-events-targets'

new Rule(this, 'OrderConfirmedRule', {
  eventBus: appBus,
  eventPattern: {
    source: ['com.myapp.orders'],
    detailType: ['OrderStatusChanged'],
    detail: {
      status: ['CONFIRMED'],
      // Nested field matching — routes only US region orders to this target
      region: ['us-east', 'us-west'],
      // Numeric range: total > 100 (for high-value order priority processing)
      total: [{ numeric: ['>', 100] }],
    }
  },
  targets: [new LambdaFunction(fulfillmentLambda)]
})

import { RuleTargetInput } from 'aws-cdk-lib/aws-events'

new Rule(this, 'OrderToSQS', {
  eventBus: appBus,
  eventPattern: { source: ['com.myapp.orders'], detailType: ['OrderStatusChanged'] },
  targets: [new SqsQueue(processingQueue, {
    message: RuleTargetInput.fromObject({
      // Extract only the fields the target needs — strip event envelope
      orderId: EventField.fromPath('$.detail.orderId'),
      status: EventField.fromPath('$.detail.status'),
      userId: EventField.fromPath('$.detail.userId'),
      timestamp: EventField.fromPath('$.time'),
    })
  })]
})
// Target receives clean { orderId, status, userId, timestamp } instead of the full EventBridge envelope

// ❌ Traffic-cop Lambda: only filters and routes, no business logic
// This Lambda exists solely to:
// 1. Deserialize the SQS message body
// 2. Check if status === 'COMPLETED'
// 3. If yes: put event to EventBridge
// 4. If no: return (discard the message)
// Cost: Lambda invocation + cold-start risk + deployment artifact to maintain

export const handler = async (event: AWSLambda.SQSEvent) => {
  for (const record of event.Records) {
    const message = JSON.parse(record.body)
    if (message.status !== 'COMPLETED') continue // 90% of messages discarded here
    await eventBridge.send(new PutEventsCommand({
      Entries: [{ Source: 'com.myapp', DetailType: 'OrderCompleted', Detail: record.body }]
    }))
  }
}

// ✅ EventBridge Pipe: replaces the traffic-cop Lambda entirely
import { CfnPipe } from 'aws-cdk-lib/aws-pipes'

new CfnPipe(this, 'OrderCompletedPipe', {
  roleArn: pipeRole.roleArn,
  source: queue.queueArn,       // SQS as source
  sourceParameters: {
    sqsQueueParameters: { batchSize: 10 }
  },
  // Server-side filter: only records with status=COMPLETED flow through
  filter: {
    filters: [{
      pattern: JSON.stringify({ body: { status: ['COMPLETED'] } })
    }]
  },
  // Optional enrichment Lambda (only needed for complex transforms)
  // Omit if input transformer covers the transformation
  target: appBus.eventBusArn,  // EventBridge bus as target
  targetParameters: {
    eventBridgeEventBusParameters: {
      detailType: 'OrderCompleted',
      source: 'com.myapp.orders',
    },
    inputTemplate: JSON.stringify({
      orderId: '<$.body.orderId>',
      userId: '<$.body.userId>',
      completedAt: '<$.body.completedAt>',
    })
  }
})
// Zero Lambda code. Zero cold starts. Zero invocation billing. Zero deployment artifact.

// CDK: enable schema discovery on the custom event bus
import { CfnDiscoverer } from 'aws-cdk-lib/aws-eventschemas'

new CfnDiscoverer(this, 'SchemaDiscoverer', {
  sourceArn: appBus.eventBusArn,
  description: 'Auto-discover schemas from myapp event bus',
})
// After events flow: Schema Registry generates a JSON Schema per (source, detailType)

// Generated TypeScript bindings (via `aws events generate-code` or Schema Registry UI):
// Auto-generated — do not edit manually
export interface OrderStatusChangedEvent {
  version: string
  id: string
  source: 'com.myapp.orders'
  'detail-type': 'OrderStatusChanged'
  detail: {
    orderId: string
    userId: string
    status: 'PENDING' | 'CONFIRMED' | 'SHIPPED' | 'DELIVERED' | 'CANCELLED'
    total: number
    region: string
    updatedAt: string
  }
}

// Usage: type-safe event publishing
const orderEvent: OrderStatusChangedEvent['detail'] = {
  orderId: 'o99',
  userId: 'u42',
  status: 'CONFIRMED', // ← TypeScript catches typos: 'Confirmed' is a compile error
  total: 149.99,
  region: 'us-east',
  updatedAt: new Date().toISOString(),
}

// CDK: Archive all events on the custom bus for 90 days
import { Archive } from 'aws-cdk-lib/aws-events'

new Archive(this, 'AppEventArchive', {
  sourceEventBus: appBus,
  archiveName: 'myapp-event-archive',
  retention: Duration.days(90),
  eventPattern: {}, // Archive ALL events — use eventPattern to filter if needed
})

// Replay: after fixing a consumer bug, replay events from a time window
// This re-routes archived events through the event bus to the current rule targets
// CLI:
// aws events start-replay \
//   --replay-name fix-inventory-bug-replay \
//   --event-source-arn arn:aws:events:us-east-1:123:archive/myapp-event-archive \
//   --event-start-time 2026-09-01T00:00:00Z \
//   --event-end-time 2026-09-02T00:00:00Z \
//   --destination '{"EventBusArn": "arn:aws:events:us-east-1:123:event-bus/myapp-events"}'

// CloudWatch: one alarm per DLQ, one per service — never combine
// Lambda async DLQ alarm
new Alarm(this, 'LambdaAsyncDLQAlarm', {
  metric: lambdaAsyncDlq.metricApproximateNumberOfMessagesVisible(),
  threshold: 0, evaluationPeriods: 1,
  alarmDescription: 'Lambda async invocations failing — events lost from async path',
})

// SQS DLQ alarm
new Alarm(this, 'SqsDLQAlarm', {
  metric: sqsDlq.metricApproximateNumberOfMessagesVisible(),
  threshold: 0, evaluationPeriods: 1,
  alarmDescription: 'SQS messages failing processing — work items require investigation',
})

// EventBridge rule DLQ alarm
new Alarm(this, 'EventBridgeDLQAlarm', {
  metric: eventBridgeDlq.metricApproximateNumberOfMessagesVisible(),
  threshold: 0, evaluationPeriods: 1,
  alarmDescription: 'EventBridge rule target delivery failing — events not reaching consumer',
})