// Example: HTTP API Handler for order processing
import { APIGatewayProxyHandler } from 'aws-lambda';
import { OrderProcessor } from './processes/order-processor';
import { OrderStore } from './stores/order-store';

export const handler: APIGatewayProxyHandler = async (event) => {
  const orderProcessor = new OrderProcessor(new OrderStore());
  
  try {
    const order = JSON.parse(event.body || '{}');
    const result = await orderProcessor.process(order);
    
    return {
      statusCode: 201,
      body: JSON.stringify({ success: true, orderId: result.id })
    };
  } catch (error) {
    return {
      statusCode: 400,
      body: JSON.stringify({ error: error.message })
    };
  }
};

// Example: Queue Producer for async order processing
import { SQS } from 'aws-sdk';

export class OrderQueueProducer {
  private sqs: SQS;
  private queueUrl: string;

  constructor(queueUrl: string) {
    this.sqs = new SQS();
    this.queueUrl = queueUrl;
  }

  async enqueue(order: Order): Promise<void> {
    await this.sqs.sendMessage({
      QueueUrl: this.queueUrl,
      MessageBody: JSON.stringify({
        orderId: order.id,
        type: 'PROCESS_ORDER',
        payload: order
      }),
      // Enable FIFO for ordered processing
      MessageGroupId: order.customerId,
      // Ensure exactly-once processing
      MessageDeduplicationId: `order-${order.id}-${Date.now()}`
    }).promise();
  }
}

// Example: Queue Consumer with DLQ handling
export class OrderQueueConsumer {
  private readonly maxRetries = 3;
  
  async processMessage(message: SQS.Message): Promise<void> {
    const attempt = this.getAttemptCount(message);
    const order = JSON.parse(message.Body || '{}');
    
    try {
      await this.processOrder(order);
    } catch (error) {
      if (attempt >= this.maxRetries) {
        // Send to DLQ after max retries
        await this.sendToDeadLetterQueue(message, error);
      }
      throw error; // Re-throw to trigger Lambda retry
    }
  }
  
  private getAttemptCount(message: SQS.Message): number {
    const attempts = message.Attributes?.ApproximateReceiveCount;
    return attempts ? parseInt(attempts, 10) : 1;
  }
}

// Generated with Claude Code - Order Processing Workflow
// Claude Code prompt: "Create an ARC workflow for e-commerce 
// order processing with validation, payment, and notifications"

import { DynamoDB } from 'aws-sdk';

interface Order {
  id: string;
  customerId: string;
  items: OrderItem[];
  total: number;
  status: 'PENDING' | 'PAID' | 'SHIPPED' | 'DELIVERED';
}

export class OrderWorkflow {
  private db: DynamoDB.DocumentClient;
  private paymentQueue: any;
  private notificationService: any;

  async createOrder(order: Order): Promise<Order> {
    // Step 1: Validate order
    this.validateOrder(order);
    
    // Step 2: Save initial order state
    const savedOrder = await this.saveOrder({
      ...order,
      status: 'PENDING',
      createdAt: new Date().toISOString()
    });
    
    // Step 3: Queue for payment processing
    await this.paymentQueue.send({
      orderId: savedOrder.id,
      amount: savedOrder.total,
      customerId: savedOrder.customerId
    });
    
    return savedOrder;
  }
  
  private validateOrder(order: Order): void {
    if (!order.items?.length) {
      throw new Error('Order must contain at least one item');
    }
    if (order.total <= 0) {
      throw new Error('Order total must be positive');
    }
  }
  
  private async saveOrder(order: Order): Promise<Order> {
    await this.db.put({
      TableName: process.env.ORDER_TABLE!,
      Item: order
    }).promise();
    return order;
  }
}

// Example: Idempotent payment processing
export async function processPayment(
  event: PaymentEvent
): Promise<PaymentResult> {
  // Check if payment already processed
  const existing = await paymentStore.findByOrderId(event.orderId);
  if (existing?.status === 'COMPLETED') {
    return { status: 'DUPLICATE', existingPayment: existing };
  }
  
  // Process payment (idempotent operation)
  const result = await paymentGateway.charge({
    amount: event.amount,
    orderId: event.orderId
  });
  
  await paymentStore.save({
    orderId: event.orderId,
    status: 'COMPLETED',
    transactionId: result.transactionId
  });
  
  return { status: 'SUCCESS', transactionId: result.transactionId };
}

// Structured logging for CloudWatch
export function createLogger(context: string) {
  return {
    info: (message: string, data?: object) => {
      console.log(JSON.stringify({
        level: 'INFO',
        context,
        message,
        timestamp: new Date().toISOString(),
        ...data
      }));
    },
    error: (message: string, error: Error, data?: object) => {
      console.error(JSON.stringify({
        level: 'ERROR',
        context,
        message,
        error: { message: error.message, stack: error.stack },
        timestamp: new Date().toISOString(),
        ...data
      }));
    }
  };
}

// Example: Caching layer implementation
export class CachedOrderStore implements OrderStore {
  private cache: Redis;
  private store: DynamoDBOrderStore;
  private ttl = 300; // 5 minutes

  async findById(id: string): Promise<Order | null> {
    // Check cache first
    const cached = await this.cache.get(`order:${id}`);
    if (cached) {
      return JSON.parse(cached);
    }
    
    // Fetch from database
    const order = await this.store.findById(id);
    
    // Cache the result
    if (order) {
      await this.cache.setex(
        `order:${id}`,
        this.ttl,
        JSON.stringify(order)
      );
    }
    
    return order;
  }
}