type StrategyExecutionLog = {
  id: string;
  strategyId: string;
  userId: string;
  executedAt: number;
  triggerReason: 'manual' | 'threshold' | 'price_target' | 'scheduled' | 'ai_signal';
  
  // Execution details
  marketId: string;
  marketName: string;
  outcome: 'Yes' | 'No';
  orderType: 'buy' | 'sell';
  shares: number;
  executionPrice: number;
  totalValue: number;
  
  // P&L tracking (populated on close)
  status: 'pending' | 'executed' | 'closed';
  pnl?: number;
  roi?: number;
  closedAt?: number;
  
  notes?: string;
  txHash?: string;
};

type StrategyPerformanceMetrics = {
  strategyId: string;
  totalExecutions: number;
  profitableExecutions: number;
  lossExecutions: number;
  winRate: number; // 0-100
  
  totalPnL: number;
  averagePnL: number;
  bestTrade: number;
  worstTrade: number;
  
  totalROI: number;
  averageROI: number;
  
  firstExecutionAt: number;
  lastExecutionAt: number;
  
  totalCapitalDeployed: number;
  averageTradeSize: number;
};

users/
  {userId}/
    strategies/
      {strategyId}/
        executionLogs/
          {executionId}
            - id, strategyId, userId
            - executedAt, triggerReason
            - marketId, marketName, outcome
            - orderType, shares, executionPrice, totalValue
            - status (pending|executed|closed)
            - pnl, roi, closedAt (populated on close)
        
        (strategy document contains)
        - metrics: StrategyPerformanceMetrics
        - metricsUpdatedAt: number

┌─ Performance ─────────────────────┐
│ Total Executions: 5              │
├──────────────────────────────────┤
│ Total P&L          +$1,234.56    │
│ Avg ROI            +5.2%         │
├──────────────────────────────────┤
│ ★ Win Rate         80%           │
│ ■■■■■■■□□ (4W / 1L)             │
├──────────────────────────────────┤
│ Avg Trade          $245.67       │
│ Best Trade         +$456.78      │
├──────────────────────────────────┤
│ Average P&L        +$246.91      │
│ Max Loss           -$123.45      │
└──────────────────────────────────┘

Execution History | [All triggered executions with P&L tracking]

Date         | Trigger | Market    | Order    | Price  | Shares | Value   | Status    | P&L      | ROI
2026-01-31   | 🤖      | Crypto X  | BUY YES  | 0.456  | 50     | $22.80  | CLOSED    | +$1.23   | +5.4%
2026-01-30   | ⏰      | Politics  | BUY NO   | 0.234  | 100    | $23.40  | EXECUTED  | -        | -
2026-01-29   | 📊      | Sports    | SELL YES | 0.789  | 30     | $23.67  | CLOSED    | -$0.78   | -3.3%

Summary:
├ Total Executions: 3
├ Closed Trades: 2
├ Total Capital: $69.87
└ Avg P&L: +$0.23

import { logStrategyExecution } from '@/services/strategyService';

const result = await logStrategyExecution(userId, strategyId, {
  executedAt: Date.now(),
  triggerReason: 'ai_signal',
  marketId: 'market-123',
  marketName: 'Will Bitcoin hit $100k?',
  outcome: 'Yes',
  orderType: 'buy',
  shares: 50,
  executionPrice: 0.45,
  totalValue: 22.50,
  status: 'executed',
  txHash: '0x...',
});

if (result.success) {
  console.log('Execution logged:', result.executionId);
}

import { closeStrategyExecution } from '@/services/strategyService';

const pnl = 25.00 - 22.50; // $2.50 profit
const roi = (pnl / 22.50) * 100; // 11.1% ROI

const result = await closeStrategyExecution(
  userId,
  strategyId,
  executionId,
  pnl,      // $2.50
  roi       // 11.1
);

// In StrategyList component (already integrated)
<StrategyMetricsCard 
  strategyId={strategy.id}
  userId={userId}
/>

// View detailed logs
<ExecutionLogsViewer
  strategyId={strategy.id}
  userId={userId}
/>

import { strategyMetricsService } from '@/services/strategyMetricsService';

const metrics = await strategyMetricsService.calculateMetrics(userId, strategyId);

if (metrics) {
  console.log(`Win Rate: ${metrics.winRate}%`);
  console.log(`Total P&L: $${metrics.totalPnL}`);
  console.log(`Average ROI: ${metrics.averageROI}%`);
}

// Could be run from Cloud Function or scheduled cron
import { strategyMetricsService } from '@/services/strategyMetricsService';

// Recalculate and cache all user's strategies
for (const strategy of userStrategies) {
  await strategyMetricsService.cacheMetrics(userId, strategy.id);
}

const cachedMetrics = await strategyMetricsService.getCachedMetrics(userId, strategyId);

if (cachedMetrics) {
  // Metrics already computed, use immediately
  displayMetrics(cachedMetrics);
} else {
  // No cache yet, fall back to real-time calculation
  const metrics = await strategyMetricsService.calculateMetrics(userId, strategyId);
  displayMetrics(metrics);
}

winRate = (profitableExecutions / closedTrades) * 100

totalPnL = sum of all pnl values from closed executions

averagePnL = totalPnL / closedTrades.length

totalROI = sum of all roi percentages
averageROI = totalROI / closedTrades.length

bestTrade = max(pnl values)
worstTrade = min(pnl values)

totalCapitalDeployed = sum of all totalValue
averageTradeSize = totalCapitalDeployed / totalExecutions

// functions/src/strategies/cache-metrics.ts
export const cacheStrategyMetrics = onSchedule(
  { schedule: 'every 5 minutes' },
  async (context) => {
    // For each strategy with executions this period
    // Call strategyMetricsService.cacheMetrics(userId, strategyId)
  }
);

errorEmitter.emit('error', {
  code: 'STRATEGY_LOG_EXECUTION_ERROR',
  message: 'Failed to log execution'
});