Get Dashboard Data

Total Volume = Sum of all position sizes (entry value)

Total PnL = Sum of all realized profits and losses

Win Rate = (Profitable Trades / Total Closed Trades) × 100

Margin Utilization = (Reserved Balance / Total Balance) × 100

Available Capital = Withdrawable Balance

async function getDashboardSummary(walletAddress) {
  const response = await fetch(`https://api.strike.markets/dashboard/${walletAddress}`);
  const data = await response.json();
  
  return {
    totalBalance: parseFloat(data.balances.total),
    availableBalance: parseFloat(data.balances.withdrawable),
    openPositions: data.positions.openPositions.length,
    totalVolume: parseFloat(data.analytics.totalVolume),
    totalPnl: parseFloat(data.analytics.totalPnl),
    winRate: parseFloat(data.analytics.winRate),
    points: parseInt(data.points)
  };
}

async function getCurrentPositions(walletAddress) {
  const response = await fetch(`https://api.strike.markets/dashboard/${walletAddress}`);
  const data = await response.json();
  
  const openPositions = data.positions.openPositions;
  const totalUnrealizedPnl = openPositions.reduce((sum, pos) => 
    sum + parseFloat(pos.unrealizedPnl), 0
  );
  
  const totalMarginUsed = openPositions.reduce((sum, pos) => 
    sum + parseFloat(pos.margin), 0
  );
  
  return {
    positionCount: openPositions.length,
    totalUnrealizedPnl,
    totalMarginUsed,
    positions: openPositions.map(pos => ({
      symbol: pos.symbol,
      side: pos.side,
      pnl: parseFloat(pos.unrealizedPnl),
      margin: parseFloat(pos.margin)
    }))
  };
}

async function getPerformanceMetrics(walletAddress) {
  const response = await fetch(`https://api.strike.markets/dashboard/${walletAddress}`);
  const data = await response.json();
  
  const totalPositions = data.positions.closedPositions.length + 
                         data.positions.settledPositions.length;
                         
  const avgPositionSize = totalPositions > 0 ? 
    parseFloat(data.analytics.totalVolume) / totalPositions : 0;
  
  const profitFactor = calculateProfitFactor(data.positions.closedPositions);
  
  return {
    totalTrades: totalPositions,
    winRate: parseFloat(data.analytics.winRate),
    totalPnl: parseFloat(data.analytics.totalPnl),
    avgPositionSize,
    profitFactor,
    totalVolume: parseFloat(data.analytics.totalVolume)
  };
}

function calculateProfitFactor(closedPositions) {
  let totalWins = 0;
  let totalLosses = 0;
  
  closedPositions.forEach(pos => {
    // This would need to be calculated based on actual position data
    // For now, we'll estimate based on the position details
  });
  
  return totalLosses > 0 ? totalWins / totalLosses : 0;
}

async function assessAccountRisk(walletAddress) {
  const response = await fetch(`https://api.strike.markets/dashboard/${walletAddress}`);
  const data = await response.json();
  
  const marginUtilization = parseFloat(data.balances.reserved) / 
                           parseFloat(data.balances.total) * 100;
                           
  const openPositions = data.positions.openPositions;
  const avgLeverage = openPositions.length > 0 ? 
    openPositions.reduce((sum, pos) => sum + pos.leverage, 0) / openPositions.length : 0;
  
  const totalExposure = openPositions.reduce((sum, pos) => 
    sum + parseFloat(pos.size), 0
  );
  
  return {
    marginUtilization,
    avgLeverage,
    totalExposure,
    openPositionCount: openPositions.length,
    riskLevel: assessRiskLevel(marginUtilization, avgLeverage)
  };
}

function assessRiskLevel(marginUtil, avgLev) {
  if (marginUtil > 80 || avgLev > 50) return 'HIGH';
  if (marginUtil > 50 || avgLev > 20) return 'MEDIUM';
  return 'LOW';
}

function AccountSummaryWidget({ dashboardData }) {
  return {
    totalBalance: dashboardData.balances.total,
    availableBalance: dashboardData.balances.withdrawable,
    totalPnl: dashboardData.analytics.totalPnl,
    winRate: dashboardData.analytics.winRate + '%',
    points: dashboardData.points
  };
}

function ActivePositionsWidget({ dashboardData }) {
  const openPositions = dashboardData.positions.openPositions;
  
  return {
    count: openPositions.length,
    totalPnl: openPositions.reduce((sum, pos) => 
      sum + parseFloat(pos.unrealizedPnl), 0
    ),
    positions: openPositions.map(pos => ({
      id: pos.positionId,
      market: pos.symbol,
      side: pos.side,
      pnl: pos.unrealizedPnl
    }))
  };
}

function getPerformanceChartData(dashboardData) {
  // Combine closed and settled positions for historical performance
  const allClosedPositions = [
    ...dashboardData.positions.closedPositions,
    ...dashboardData.positions.settledPositions
  ];
  
  // Sort by close date for chronological chart
  allClosedPositions.sort((a, b) => 
    new Date(a.closedAt || a.settledAt) - new Date(b.closedAt || b.settledAt)
  );
  
  let cumulativePnl = 0;
  return allClosedPositions.map(pos => {
    // Calculate individual position PnL (would need additional data)
    const positionPnl = calculatePositionPnl(pos);
    cumulativePnl += positionPnl;
    
    return {
      date: pos.closedAt || pos.settledAt,
      pnl: positionPnl,
      cumulativePnl: cumulativePnl
    };
  });
}

class DashboardCache {
  constructor(ttl = 30000) { // 30 second TTL
    this.cache = new Map();
    this.ttl = ttl;
  }
  
  async getDashboard(walletAddress) {
    const key = `dashboard_${walletAddress}`;
    const cached = this.cache.get(key);
    
    if (cached && Date.now() - cached.timestamp < this.ttl) {
      return cached.data;
    }
    
    const response = await fetch(`https://api.strike.markets/dashboard/${walletAddress}`);
    const data = await response.json();
    
    this.cache.set(key, {
      data,
      timestamp: Date.now()
    });
    
    return data;
  }
}