import { Logger } from '@aws-lambda-powertools/logger'
import { injectLambdaContext } from '@aws-lambda-powertools/logger/middleware'
import middy from '@middy/core'

const logger = new Logger({
  serviceName: 'order-service',
  logLevel: 'INFO',
})

// ✅ Middy middleware: injects Lambda context (request ID, cold start flag, function name)
// into every log line automatically — no manual logger.addContext() calls required
export const handler = middy(
  async (event: AWSLambda.APIGatewayProxyEvent): Promise<AWSLambda.APIGatewayProxyResult> => {
    // Set correlation ID from upstream: API GW requestId or custom header
    const correlationId = event.headers['x-correlation-id'] ?? event.requestContext.requestId
    logger.appendKeys({ correlationId, orderId: event.pathParameters?.orderId })

    logger.info('Processing order request', {
      path: event.path,
      method: event.httpMethod,
    })

    try {
      const order = await processOrder(event)
      logger.info('Order processed successfully', { orderId: order.id, status: order.status })
      return { statusCode: 200, body: JSON.stringify(order) }
    } catch (err) {
      logger.error('Order processing failed', { error: (err as Error).message })
      throw err
    }
  }
).use(injectLambdaContext(logger))

// Every log line now contains:
// { "level": "INFO", "service": "order-service", "correlationId": "abc123",
//   "orderId": "o99", "function_name": "OrderProcessor",
//   "cold_start": false, "xray_trace_id": "..." }

import { Metrics, MetricUnit } from '@aws-lambda-powertools/metrics'
import { logMetrics } from '@aws-lambda-powertools/metrics/middleware'

const metrics = new Metrics({ namespace: 'OrderService', serviceName: 'order-processor' })

export const handler = middy(
  async (event: AWSLambda.SQSEvent) => {
    for (const record of event.Records) {
      const order = JSON.parse(record.body)

      metrics.addDimension('orderRegion', order.region) // Dimension per invocation
      metrics.addMetric('OrderProcessed', MetricUnit.Count, 1)
      metrics.addMetric('OrderTotal', MetricUnit.NoUnit, order.total)

      if (order.status === 'FRAUD_FLAGGED') {
        metrics.addMetric('FraudFlaggedOrder', MetricUnit.Count, 1)
      }
    }
    // Metrics are flushed at end of handler as structured JSON — no synchronous API call
  }
).use(logMetrics(metrics))

// EMF output (auto-flushed to CloudWatch Logs):
// { "_aws": { "Timestamp": ..., "CloudWatchMetrics": [{ "Namespace": "OrderService",
//   "Dimensions": [["service", "orderRegion"]], "Metrics": [{ "Name": "OrderProcessed", "Unit": "Count" }] }] },
//   "service": "order-processor", "orderRegion": "us-east", "OrderProcessed": 1, "OrderTotal": 149.99 }

import { Tracer } from '@aws-lambda-powertools/tracer'
import { captureLambdaHandler } from '@aws-lambda-powertools/tracer/middleware'
import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb'

const tracer = new Tracer({ serviceName: 'order-service' })

// Auto-capture: DynamoDB SDK calls appear as X-Ray subsegments automatically
const docClient = tracer.captureAWSv3Client(
  DynamoDBDocumentClient.from(new DynamoDBClient({ region: process.env.AWS_REGION }))
)

export const handler = middy(
  async (event: AWSLambda.SQSEvent) => {
    for (const record of event.Records) {
      const order = JSON.parse(record.body)

      // Custom annotation — searchable in X-Ray console
      tracer.putAnnotation('orderId', order.orderId)
      tracer.putAnnotation('orderRegion', order.region)

      // Custom metadata — visible in trace detail, not searchable
      tracer.putMetadata('orderPayload', { total: order.total, itemCount: order.items.length })

      const segment = tracer.getSegment()!
      const subsegment = segment.addNewSubsegment('## processPayment')
      try {
        await processPayment(order)
      } catch (err) {
        subsegment.addError(err as Error)
        throw err
      } finally {
        subsegment.close()
      }
    }
  }
).use(captureLambdaHandler(tracer))

// CDK: X-Ray sampling rule — trace all order failures, 10% of successes
import { CfnSamplingRule } from 'aws-cdk-lib/aws-xray'

new CfnSamplingRule(this, 'OrderSamplingRule', {
  samplingRule: {
    ruleName: 'OrderErrorRule',
    resourceArn: '*',
    host: '*',
    httpMethod: '*',
    urlPath: '*',
    serviceName: 'order-service',
    serviceType: 'AWS::Lambda::Function',
    fixedRate: 0.10,   // 10% of normal requests
    reservoirSize: 5,  // Always trace up to 5 req/s regardless of rate
    priority: 1,
    version: 1,
  }
})

// The minimum alarm set — without these, a production incident is invisible until users report it
const fn: Function = ...

// 1. Error rate alarm (percentage, not absolute count)
new Alarm(this, `${fn.functionName}-ErrorRate`, {
  metric: fn.metricErrors().createAlarm // percentage requires MathExpression
  // Use MathExpression: errors / (errors + invocations) × 100
  metric: new MathExpression({
    expression: '100*(errors/invocations)',
    usingMetrics: {
      errors: fn.metricErrors({ period: Duration.minutes(5) }),
      invocations: fn.metricInvocations({ period: Duration.minutes(5) }),
    }
  }),
  threshold: 5, // Alert if error rate > 5%
  evaluationPeriods: 2,
})

// 2. P99 duration alarm
new Alarm(this, `${fn.functionName}-P99Duration`, {
  metric: fn.metricDuration({ statistic: 'p99', period: Duration.minutes(5) }),
  threshold: fn.timeout!.toMilliseconds() * 0.8, // Alert at 80% of timeout
  evaluationPeriods: 2,
})

// 3. Throttle alarm
new Alarm(this, `${fn.functionName}-Throttles`, {
  metric: fn.metricThrottles({ period: Duration.minutes(1) }),
  threshold: 0,
  evaluationPeriods: 1,
})

// 4. Concurrent executions (approaching Reserved Concurrency limit)
new Alarm(this, `${fn.functionName}-ConcurrencyUtilization`, {
  metric: fn.metricConcurrentExecutions({ period: Duration.minutes(1), statistic: 'Maximum' }),
  threshold: (fn.reservedConcurrentExecutions ?? 1000) * 0.8,
  evaluationPeriods: 3,
})

Lambda cost = (Invocation cost) + (Compute cost) + (Provisioned Concurrency cost, if any)

Invocation cost: $0.20 per million invocations (same regardless of memory or duration)
Compute cost:    GB-seconds × $0.0000166667 per GB-second

GB-seconds = (memory_MB / 1024) × duration_seconds × invocation_count

Example: 512MB, 200ms avg, 10M invocations/month:
  GB-seconds = (512/1024) × 0.2 × 10,000,000 = 1,000,000 GB-seconds
  Compute cost: 1,000,000 × $0.0000166667 = $16.67
  Invocation cost: (10,000,000 / 1,000,000) × $0.20 = $2.00
  Total: $18.67/month

Power Tuning insight: increasing memory to 1024MB reduces duration to 100ms:
  GB-seconds = (1024/1024) × 0.1 × 10,000,000 = 1,000,000 GB-seconds (SAME)
  But: execution completes in half the time → same cost, lower latency
  Further: 1769MB (1 vCPU) at 80ms:
  GB-seconds = (1769/1024) × 0.08 × 10,000,000 = 1,382,000 GB-seconds (MORE EXPENSIVE)
  → 1024MB is the cost-optimal point for this workload

On-Demand:
  Write Request Units (WRU): $1.25 per million
  Read Request Units (RRU):  $0.25 per million

Capacity consumption by operation:
  GetItem:              1 RRU (eventually consistent) per 4KB
  PutItem/UpdateItem:   1 WRU per 1KB
  Query:                1 RRU per 4KB of data returned
  Scan:                 1 RRU per 4KB of data SCANNED (not returned — filter does not reduce cost)
  TransactWriteItems:   2 WRU per item
  BatchWriteItem:       1 WRU per item

FinOps anti-pattern: Scan + FilterExpression
  10M-item table × 1KB avg size = 10,000,000 RRU per Scan
  Even if FilterExpression keeps 1% of items (100,000 items) → STILL 10M RRU charged
  Cost: 10,000,000 / 1,000,000 × $0.25 = $2.50 per Scan
  1 Scan/day × 30 days = $75/month — for one query, mostly discarded data

FinOps fix: Query with KeyConditionExpression
  Query by PK = "STATUS#PENDING" with limit 1,000 → reads only PENDING items
  Cost: 1,000 items × 1KB = 1,000 RRU = $0.00025 per query
  → 99.99% cost reduction vs Scan for same result

REST API:  $3.50 per million requests + $0.09/GB data transfer
HTTP API:  $1.00 per million requests + $0.09/GB data transfer

At 100M requests/month:
  REST API:  $350 + data transfer
  HTTP API:  $100 + data transfer
  Savings if HTTP API is functionally equivalent: $250/month (71% reduction)