# Immediate response with payment result
async def process_payment_sync(payment_request):
    # All steps happen in real-time
    fraud_check = await fraud_service.analyze(payment_request)
    if fraud_check.risk_score > 0.8:
        return PaymentResult(status="DECLINED", reason="FRAUD")
    
    gateway_result = await payment_gateway.charge(payment_request)
    await database.save_transaction(gateway_result)
    
    return PaymentResult(status=gateway_result.status)

# Immediate acceptance, background processing
async def process_payment_async(payment_request):
    # Queue for background processing
    transaction_id = generate_transaction_id()
    await payment_queue.enqueue({
        'transaction_id': transaction_id,
        'payment_request': payment_request,
        'timestamp': datetime.utcnow()
    })
    
    return PaymentResult(
        status="PENDING",
        transaction_id=transaction_id,
        estimated_completion="30_seconds"
    )

async def transfer_money_acid(from_user, to_user, amount):
    async with database.transaction():
        # All operations in single transaction
        from_balance = await get_balance(from_user)
        if from_balance < amount:
            raise InsufficientFundsError()
        
        await update_balance(from_user, -amount)
        await update_balance(to_user, amount)
        await create_transaction_record(from_user, to_user, amount)
        
        # Either all succeed or all fail
        return TransferResult(status="SUCCESS")

async def transfer_money_saga(from_user, to_user, amount):
    saga_id = generate_saga_id()
    
    # Step 1: Reserve funds
    reserve_result = await reserve_funds(from_user, amount, saga_id)
    if not reserve_result.success:
        return TransferResult(status="FAILED")
    
    # Step 2: Credit recipient (async)
    await credit_account_async(to_user, amount, saga_id)
    
    # Step 3: Complete transfer (async)
    await complete_transfer_async(saga_id)
    
    return TransferResult(status="PROCESSING", saga_id=saga_id)

class PaymentService:
    def __init__(self):
        self.fraud_detector = FraudDetector()
        self.payment_gateway = PaymentGateway()
        self.notification_service = NotificationService()
        self.database = Database()
    
    async def process_payment(self, request):
        # All logic in single service
        fraud_result = self.fraud_detector.analyze(request)
        payment_result = await self.payment_gateway.charge(request)
        await self.database.save_transaction(payment_result)
        await self.notification_service.send_confirmation(request.user_id)
        
        return payment_result

# Separate services communicating via events
class PaymentOrchestrator:
    async def process_payment(self, request):
        # Publish event to start workflow
        await event_bus.publish('payment.initiated', {
            'payment_id': request.payment_id,
            'user_id': request.user_id,
            'amount': request.amount
        })
        
        return {"status": "PROCESSING", "payment_id": request.payment_id}

# Separate fraud detection service
class FraudDetectionService:
    async def handle_payment_initiated(self, event):
        fraud_score = await self.analyze_payment(event)
        
        if fraud_score > 0.8:
            await event_bus.publish('payment.declined', {
                'payment_id': event['payment_id'],
                'reason': 'FRAUD_DETECTED'
            })
        else:
            await event_bus.publish('fraud.check.passed', event)

-- Strong consistency for financial data
BEGIN;
UPDATE accounts SET balance = balance - 100 WHERE user_id = 'user123';
UPDATE accounts SET balance = balance + 100 WHERE user_id = 'user456';
INSERT INTO transactions (from_user, to_user, amount, timestamp) 
VALUES ('user123', 'user456', 100, NOW());
COMMIT;

// Document-based transaction storage
{
  "_id": ObjectId("..."),
  "transaction_id": "txn_123456",
  "type": "payment",
  "amount": {
    "value": 100.00,
    "currency": "USD"
  },
  "participants": [
    {"user_id": "user123", "role": "payer", "account_id": "acc_789"},
    {"user_id": "user456", "role": "payee", "account_id": "acc_012"}
  ],
  "metadata": {
    "payment_method": "credit_card",
    "gateway": "stripe",
    "fraud_score": 0.2
  },
  "status": "completed",
  "timestamps": {
    "created": ISODate("2024-01-01T10:00:00Z"),
    "completed": ISODate("2024-01-01T10:00:02Z")
  }
}

class SingleDatabaseApproach:
    def __init__(self):
        self.db = PostgreSQLConnection()
    
    async def save_transaction(self, transaction):
        # All data in PostgreSQL
        await self.db.execute("""
            INSERT INTO transactions (id, user_id, amount, status, metadata)
            VALUES ($1, $2, $3, $4, $5)
        """, transaction.id, transaction.user_id, transaction.amount, 
            transaction.status, json.dumps(transaction.metadata))
    
    async def search_transactions(self, user_id, filters):
        # Complex queries in SQL
        return await self.db.fetch("""
            SELECT * FROM transactions 
            WHERE user_id = $1 AND status = $2 
            ORDER BY created_at DESC
        """, user_id, filters.status)

class PolyglotApproach:
    def __init__(self):
        self.postgres = PostgreSQLConnection()  # ACID transactions
        self.mongodb = MongoDBConnection()      # Flexible documents
        self.redis = RedisConnection()          # Caching
        self.elasticsearch = ESConnection()     # Search
    
    async def save_transaction(self, transaction):
        # Financial data in PostgreSQL
        await self.postgres.execute("""
            INSERT INTO transactions (id, amount, status) 
            VALUES ($1, $2, $3)
        """, transaction.id, transaction.amount, transaction.status)
        
        # Metadata in MongoDB
        await self.mongodb.insert_one({
            'transaction_id': transaction.id,
            'metadata': transaction.metadata,
            'audit_trail': transaction.audit_trail
        })
        
        # Cache recent transactions
        await self.redis.setex(
            f"recent_txn:{transaction.user_id}", 
            3600, 
            json.dumps(transaction.to_dict())
        )
        
        # Index for search
        await self.elasticsearch.index(
            index='transactions',
            id=transaction.id,
            body=transaction.to_search_document()
        )

class SingleGatewayProcessor:
    def __init__(self):
        self.stripe = StripeClient(api_key=STRIPE_SECRET_KEY)
    
    async def process_payment(self, payment_request):
        try:
            charge = await self.stripe.charges.create(
                amount=int(payment_request.amount * 100),
                currency=payment_request.currency,
                source=payment_request.token
            )
            return PaymentResult(status="SUCCESS", gateway_id=charge.id)
        except StripeError as e:
            return PaymentResult(status="FAILED", error=str(e))

class MultiGatewayProcessor:
    def __init__(self):
        self.gateways = {
            'stripe': StripeGateway(),
            'paypal': PayPalGateway(),
            'square': SquareGateway()
        }
        self.router = GatewayRouter()
    
    async def process_payment(self, payment_request):
        # Route based on amount, region, payment method
        gateway_name = self.router.select_gateway(payment_request)
        gateway = self.gateways[gateway_name]
        
        try:
            result = await gateway.charge(payment_request)
            return result
        except GatewayError as e:
            # Fallback to alternative gateway
            fallback_gateway = self.router.get_fallback(gateway_name)
            if fallback_gateway:
                return await self.gateways[fallback_gateway].charge(payment_request)
            raise e

class RealtimeFraudDetector:
    def __init__(self):
        self.ml_model = load_fraud_model()
        self.rule_engine = RuleEngine()
    
    async def analyze_payment(self, payment_request):
        # Immediate analysis (< 100ms)
        features = self.extract_features(payment_request)
        ml_score = self.ml_model.predict_proba(features)[0][1]
        rule_score = await self.rule_engine.evaluate(payment_request)
        
        final_score = (ml_score * 0.7) + (rule_score * 0.3)
        
        return FraudResult(
            score=final_score,
            decision="APPROVE" if final_score < 0.5 else "DECLINE",
            processing_time_ms=85
        )

class BatchFraudAnalyzer:
    async def analyze_transactions_batch(self, transactions):
        # Process in batches for better accuracy
        enhanced_features = []
        
        for txn in transactions:
            # More complex feature engineering
            user_history = await self.get_user_transaction_history(txn.user_id)
            device_fingerprint = await self.get_device_analysis(txn.device_id)
            network_analysis = await self.analyze_network_patterns(txn.ip_address)
            
            features = self.create_enhanced_features(
                txn, user_history, device_fingerprint, network_analysis
            )
            enhanced_features.append(features)
        
        # Batch prediction with ensemble models
        scores = self.ensemble_model.predict_proba(enhanced_features)
        
        return [FraudResult(score=score[1]) for score in scores]

class ApplicationCache:
    def __init__(self):
        self.redis = RedisClient()
    
    async def get_user_payment_methods(self, user_id):
        cache_key = f"payment_methods:{user_id}"
        cached = await self.redis.get(cache_key)
        
        if cached:
            return json.loads(cached)
        
        # Fetch from database
        payment_methods = await self.db.get_payment_methods(user_id)
        
        # Cache for 1 hour
        await self.redis.setex(cache_key, 3600, json.dumps(payment_methods))
        
        return payment_methods

-- Materialized views for frequently accessed data
CREATE MATERIALIZED VIEW user_payment_summary AS
SELECT 
    user_id,
    COUNT(*) as total_transactions,
    SUM(amount) as total_amount,
    AVG(amount) as avg_amount,
    MAX(created_at) as last_transaction
FROM transactions 
WHERE status = 'completed'
GROUP BY user_id;

-- Refresh periodically
REFRESH MATERIALIZED VIEW CONCURRENTLY user_payment_summary;

class FieldLevelEncryption:
    def __init__(self):
        self.encryption_key = load_encryption_key()
    
    async def store_payment_method(self, payment_method):
        # Encrypt sensitive fields individually
        encrypted_data = {
            'user_id': payment_method.user_id,  # Not encrypted
            'card_number': self.encrypt(payment_method.card_number),
            'cvv': self.encrypt(payment_method.cvv),
            'expiry': self.encrypt(payment_method.expiry),
            'created_at': payment_method.created_at  # Not encrypted
        }
        
        await self.db.insert('payment_methods', encrypted_data)
    
    def encrypt(self, data):
        # AES-256 encryption for each field
        return aes_encrypt(data, self.encryption_key)

class DatabaseEncryption:
    def __init__(self):
        # Database handles encryption transparently
        self.db = PostgreSQLConnection(
            sslmode='require',
            encryption_at_rest=True
        )
    
    async def store_payment_method(self, payment_method):
        # Database encrypts entire row
        await self.db.execute("""
            INSERT INTO encrypted_payment_methods 
            (user_id, card_number, cvv, expiry) 
            VALUES ($1, $2, $3, $4)
        """, payment_method.user_id, payment_method.card_number,
            payment_method.cvv, payment_method.expiry)

# Lower cost but potential interruptions
spot_fleet:
  instance_types: ["m5.large", "m5.xlarge", "c5.large"]
  target_capacity: 20
  allocation_strategy: "diversified"
  spot_price: "$0.05"
  
  interruption_handling:
    - drain_connections: 30s
    - graceful_shutdown: 60s
    - fallback_to_on_demand: true

# Higher cost but guaranteed availability
reserved_capacity:
  instance_type: "c5.2xlarge"
  count: 10
  term: "1_year"
  payment_option: "partial_upfront"
  
  auto_scaling:
    min_capacity: 10
    max_capacity: 50
    target_cpu: 70%

class ArchitectureDecisionFramework:
    def __init__(self):
        self.criteria = {
            'consistency_requirement': 0.9,  # High for payments
            'availability_requirement': 0.95,
            'performance_requirement': 0.8,
            'cost_constraint': 0.6,
            'compliance_requirement': 0.95
        }
    
    def evaluate_options(self, options):
        scores = {}
        
        for option_name, option in options.items():
            score = 0
            for criterion, weight in self.criteria.items():
                criterion_score = option.get(criterion, 0)
                score += criterion_score * weight
            
            scores[option_name] = score
        
        return sorted(scores.items(), key=lambda x: x[1], reverse=True)

# Example usage
options = {
    'synchronous_processing': {
        'consistency_requirement': 0.9,
        'availability_requirement': 0.7,
        'performance_requirement': 0.6,
        'cost_constraint': 0.8,
        'compliance_requirement': 0.9
    },
    'asynchronous_processing': {
        'consistency_requirement': 0.7,
        'availability_requirement': 0.9,
        'performance_requirement': 0.9,
        'cost_constraint': 0.9,
        'compliance_requirement': 0.8
    }
}