# Function to process customer orders
# - Validate order items against inventory
# - Calculate total with applicable discounts
# - Apply tax based on customer location
# - Return order summary with estimated delivery date
def process_order(customer_id: str, items: list[OrderItem]) -> OrderSummary:
    # AI will generate implementation based on comments

# test_order_processor.py
import pytest
from order_processor import process_order, OrderItem, OrderSummary

class TestOrderProcessor:
    def test_valid_order_calculates_correct_total(self):
        items = [
            OrderItem(sku="WIDGET-001", quantity=2, price=29.99),
            OrderItem(sku="GADGET-002", quantity=1, price=49.99)
        ]
        result = process_order("CUST-123", items)
        assert result.subtotal == 109.97
        assert result.status == "confirmed"
    
    def test_empty_order_raises_validation_error(self):
        with pytest.raises(ValidationError):
            process_order("CUST-123", [])
    
    def test_out_of_stock_item_returns_partial_order(self):
        # Test implementation...

# In your main file, reference related modules
from models.user import User, UserRole
from services.auth import AuthService
from repositories.user_repository import UserRepository

# AI now understands your project structure and patterns
class UserService:
    def __init__(
        self, 
        auth_service: AuthService,
        user_repo: UserRepository
    ):
        self.auth = auth_service
        self.repo = user_repo
    
    # AI suggests methods consistent with your patterns

# Before: Monolithic function
def handle_order(request):
    # Validate
    if not request.items:
        return {"error": "No items"}
    
    # Check inventory
    for item in request.items:
        stock = db.query(f"SELECT stock FROM products WHERE id={item.id}")
        if stock < item.quantity:
            return {"error": f"Insufficient stock for {item.id}"}
    
    # Calculate pricing
    subtotal = sum(item.price * item.quantity for item in request.items)
    tax = subtotal * 0.1
    total = subtotal + tax
    
    # Create order
    order_id = db.execute("INSERT INTO orders ...")
    
    # Send notifications
    send_email(request.user_email, f"Order {order_id} confirmed")
    send_sms(request.user_phone, f"Order confirmed: {order_id}")
    
    return {"order_id": order_id, "total": total}

# After: Clean architecture (AI-assisted refactoring)
class OrderService:
    def __init__(
        self,
        validator: OrderValidator,
        inventory: InventoryService,
        pricing: PricingService,
        repository: OrderRepository,
        notifier: NotificationService
    ):
        self.validator = validator
        self.inventory = inventory
        self.pricing = pricing
        self.repository = repository
        self.notifier = notifier
    
    async def create_order(self, request: CreateOrderRequest) -> Result[Order, OrderError]:
        # Validate
        validation = self.validator.validate(request)
        if validation.is_error:
            return validation
        
        # Check inventory
        availability = await self.inventory.check_availability(request.items)
        if not availability.all_available:
            return Err(InsufficientStockError(availability.unavailable_items))
        
        # Calculate pricing
        pricing = self.pricing.calculate(request.items, request.customer_id)
        
        # Persist
        order = await self.repository.create(request, pricing)
        
        # Notify (async, non-blocking)
        await self.notifier.notify_order_created(order)
        
        return Ok(order)

# Good: Provide context at file top
"""
Order Processing Module

This module handles e-commerce order processing for a B2B platform.
Key considerations:
- Multi-currency support (USD, EUR, GBP)
- Bulk order discounts
- Net-30 payment terms
- Integration with SAP ERP
"""

# AI now understands business context

# AI suggested (potentially insecure!)
def authenticate(username, password):
    query = f"SELECT * FROM users WHERE username='{username}' AND password='{password}'"
    # SQL INJECTION VULNERABILITY!

# Always review for security
def authenticate(username, password):
    query = "SELECT * FROM users WHERE username = ? AND password_hash = ?"
    password_hash = hash_password(password)
    return db.execute(query, (username, password_hash))

# If your project uses dataclasses
from dataclasses import dataclass

@dataclass
class Order:
    id: str
    items: list[OrderItem]
    total: Decimal

# Don't let AI generate incompatible patterns
# (e.g., Pydantic models if you use dataclasses)

# Example metrics to track
metrics = {
    "lines_accepted_from_ai": 1250,
    "lines_modified_after_ai": 180,
    "acceptance_rate": 0.87,
    "time_saved_estimate_hours": 12,
    "bugs_from_ai_suggestions": 2,
    "security_issues_caught": 5
}