{
  "body": {
    "usage": [
      {
        "workosOrgId": "org_123456789",
        "envId": "env_prod_123456789",
        "totalVideos": 150,
        "totalVideoDurationSeconds": 45000.5,
        "totalSegmentsServed": 125000,
        "videosUploadedInPeriod": 25,
        "segmentsServedInPeriod": 15000,
        "firstVideoUploaded": "2024-01-01T10:00:00Z",
        "firstVideoUploadedValid": true,
        "lastSegmentServed": "2024-01-15T14:30:00Z",
        "lastSegmentServedValid": true
      }
    ]
  }
}

// Calculate views from segments
const calculateViews = (segmentsServed, videoDurationSeconds) => {
  return Math.round(segmentsServed / (videoDurationSeconds / 6));
};

// Calculate average video length
const avgVideoLength = totalVideoDurationSeconds / totalVideos;

// Calculate engagement rate
const engagementRate = segmentsServedInPeriod / videosUploadedInPeriod;

{
  "body": {
    "dailyUsage": [
      {
        "deliveryDate": "2024-01-15T00:00:00Z",
        "segmentsServed": 1250,
        "uniqueVideosServed": 45,
        "hdSegments": 800,
        "sdSegments": 350,
        "ldSegments": 100
      },
      {
        "deliveryDate": "2024-01-14T00:00:00Z",
        "segmentsServed": 980,
        "uniqueVideosServed": 32,
        "hdSegments": 650,
        "sdSegments": 250,
        "ldSegments": 80
      }
    ]
  }
}

// Calculate quality distribution percentages
const analyzeQualityDistribution = (dailyData) => {
  return dailyData.map(day => {
    const total = day.segmentsServed;
    return {
      date: day.deliveryDate,
      total: total,
      hdPercentage: (day.hdSegments / total) * 100,
      sdPercentage: (day.sdSegments / total) * 100,
      ldPercentage: (day.ldSegments / total) * 100
    };
  });
};

// Find peak usage days
const findPeakDays = (dailyData) => {
  return dailyData
    .sort((a, b) => b.segmentsServed - a.segmentsServed)
    .slice(0, 5);
};

// Calculate weekly averages
const calculateWeeklyAverage = (dailyData) => {
  const totalSegments = dailyData.reduce((sum, day) => sum + day.segmentsServed, 0);
  return totalSegments / dailyData.length;
};

{
  "body": {
    "storage": {
      "totalVideos": 150,
      "totalDurationSeconds": 45000.5,
      "avgVideoDuration": 300.0,
      "ultraQualityDuration": 15000.2,
      "highQualityDuration": 20000.1,
      "standardQualityDuration": 10000.2
    }
  }
}

// Calculate storage distribution percentages
const analyzeStorageDistribution = (storageData) => {
  const total = storageData.totalDurationSeconds;
  return {
    ultraPercentage: (storageData.ultraQualityDuration / total) * 100,
    highPercentage: (storageData.highQualityDuration / total) * 100,
    standardPercentage: (storageData.standardQualityDuration / total) * 100,
    totalHours: total / 3600,
    avgMinutes: storageData.avgVideoDuration / 60
  };
};

// Estimate storage costs (example rates)
const estimateStorageCosts = (storageData, costPerHour = 0.01) => {
  const totalHours = storageData.totalDurationSeconds / 3600;
  return {
    monthlyCost: totalHours * costPerHour,
    ultraCost: (storageData.ultraQualityDuration / 3600) * costPerHour,
    highCost: (storageData.highQualityDuration / 3600) * costPerHour,
    standardCost: (storageData.standardQualityDuration / 3600) * costPerHour
  };
};

// Identify optimization opportunities
const findOptimizationOpportunities = (storageData) => {
  const ultraRatio = storageData.ultraQualityDuration / storageData.totalDurationSeconds;
  const highRatio = storageData.highQualityDuration / storageData.totalDurationSeconds;

  return {
    ultraOptimization: ultraRatio > 0.5 ? "Consider reducing ultra quality usage" : "Ultra quality usage is reasonable",
    highOptimization: highRatio > 0.7 ? "High quality dominates - consider standard for some content" : "Good quality distribution",
    avgLengthOptimization: storageData.avgVideoDuration > 600 ? "Consider shorter videos" : "Video length is appropriate"
  };
};

{
  "body": {
    "summary": {
      "vidId": "vid_123456789abcdef",
      "vidPublicId": "pubvid_AbCdEf",
      "vidName": "My Video",
      "vidNameValid": true,
      "vidLengthSeconds": 300.5,
      "availableResolutions": 3,
      "totalSegmentsServed": 1500,
      "totalDaysServed": 15,
      "firstServed": "2024-01-01T10:00:00Z",
      "firstServedValid": true,
      "lastServed": "2024-01-15T14:30:00Z",
      "lastServedValid": true,
      "mostPopularResolution": 1080,
      "mostPopularResolutionValid": true
    },
    "resolutions": [
      {
        "vidId": "vid_123456789abcdef",
        "vidPublicId": "pubvid_AbCdEf",
        "vidName": "My Video",
        "vidNameValid": true,
        "resolutionHeight": 1080,
        "timesServed": 800,
        "firstServed": "2024-01-01T10:00:00Z",
        "firstServedValid": true,
        "lastServed": "2024-01-15T14:30:00Z",
        "lastServedValid": true,
        "daysServed": 15
      },
      {
        "vidId": "vid_123456789abcdef",
        "vidPublicId": "pubvid_AbCdEf",
        "vidName": "My Video",
        "vidNameValid": true,
        "resolutionHeight": 720,
        "timesServed": 500,
        "firstServed": "2024-01-01T10:00:00Z",
        "firstServedValid": true,
        "lastServed": "2024-01-15T14:30:00Z",
        "lastServedValid": true,
        "daysServed": 12
      }
    ]
  }
}

// Calculate resolution distribution
const analyzeVideoResolutions = (videoData) => {
  const totalSegments = videoData.summary.totalSegmentsServed;

  return videoData.resolutions.map(res => ({
    resolution: res.resolutionHeight,
    segments: res.timesServed,
    percentage: (res.timesServed / totalSegments) * 100,
    daysActive: res.daysServed,
    avgSegmentsPerDay: res.timesServed / res.daysServed
  }));
};

// Calculate estimated views
const calculateVideoViews = (videoData) => {
  const videoLength = videoData.summary.vidLengthSeconds;
  const segmentsPerView = videoLength / 6; // 6 seconds per segment
  return Math.round(videoData.summary.totalSegmentsServed / segmentsPerView);
};

// Identify optimization opportunities
const findVideoOptimizations = (videoData) => {
  const resolutions = videoData.resolutions.sort((a, b) => b.timesServed - a.timesServed);
  const topResolution = resolutions[0];
  const topPercentage = (topResolution.timesServed / videoData.summary.totalSegmentsServed) * 100;

  return {
    dominantResolution: topResolution.resolutionHeight,
    dominantPercentage: topPercentage,
    optimization: topPercentage > 80 ?
      `Consider focusing on ${topResolution.resolutionHeight}p encoding` :
      "Good resolution distribution",
    engagement: videoData.summary.totalDaysServed > 30 ?
      "High engagement - evergreen content" :
      "Consider content refresh"
  };
};

{
  "body": {
    "distribution": [
      {
        "resolutionHeight": 1080,
        "segmentsServed": 50000,
        "uniqueVideos": 45,
        "daysActive": 30,
        "firstServed": "2024-01-01T10:00:00Z",
        "firstServedValid": true,
        "lastServed": "2024-01-15T14:30:00Z",
        "lastServedValid": true
      },
      {
        "resolutionHeight": 720,
        "segmentsServed": 35000,
        "uniqueVideos": 38,
        "daysActive": 28,
        "firstServed": "2024-01-01T10:00:00Z",
        "firstServedValid": true,
        "lastServed": "2024-01-15T14:30:00Z",
        "lastServedValid": true
      },
      {
        "resolutionHeight": 480,
        "segmentsServed": 15000,
        "uniqueVideos": 25,
        "daysActive": 20,
        "firstServed": "2024-01-01T10:00:00Z",
        "firstServedValid": true,
        "lastServed": "2024-01-15T14:30:00Z",
        "lastServedValid": true
      }
    ]
  }
}

// Calculate resolution market share
const calculateResolutionShare = (distributionData) => {
  const totalSegments = distributionData.reduce((sum, res) => sum + res.segmentsServed, 0);

  return distributionData.map(res => ({
    resolution: res.resolutionHeight,
    segments: res.segmentsServed,
    percentage: (res.segmentsServed / totalSegments) * 100,
    videos: res.uniqueVideos,
    avgSegmentsPerVideo: res.segmentsServed / res.uniqueVideos
  }));
};

// Identify encoding priorities
const identifyEncodingPriorities = (distributionData) => {
  const sorted = distributionData.sort((a, b) => b.segmentsServed - a.segmentsServed);
  const totalSegments = distributionData.reduce((sum, res) => sum + res.segmentsServed, 0);

  return {
    primaryResolution: sorted[0].resolutionHeight,
    primaryPercentage: (sorted[0].segmentsServed / totalSegments) * 100,
    recommendations: sorted.slice(0, 3).map(res => ({
      resolution: res.resolutionHeight,
      priority: sorted.indexOf(res) + 1,
      segments: res.segmentsServed,
      percentage: (res.segmentsServed / totalSegments) * 100
    }))
  };
};

// Analyze device preferences
const analyzeDevicePreferences = (distributionData) => {
  const hdSegments = distributionData.filter(r => r.resolutionHeight >= 1080)
    .reduce((sum, r) => sum + r.segmentsServed, 0);
  const sdSegments = distributionData.filter(r => r.resolutionHeight === 720)
    .reduce((sum, r) => sum + r.segmentsServed, 0);
  const ldSegments = distributionData.filter(r => r.resolutionHeight <= 480)
    .reduce((sum, r) => sum + r.segmentsServed, 0);

  const total = hdSegments + sdSegments + ldSegments;

  return {
    highEndDevices: (hdSegments / total) * 100,
    standardDevices: (sdSegments / total) * 100,
    mobileDevices: (ldSegments / total) * 100,
    recommendation: hdSegments > total * 0.6 ?
      "Focus on high-quality encoding" :
      "Balanced encoding strategy recommended"
  };
};

// Build comprehensive analytics dashboard
const buildAnalyticsDashboard = async (orgId, periodDays = 30) => {
  const endDate = new Date().toISOString().split('T')[0];
  const startDate = new Date(Date.now() - periodDays * 24 * 60 * 60 * 1000).toISOString().split('T')[0];

  // Example: Fetch all analytics data in parallel
  const [accountUsage, dailyUsage, storageUsage, resolutionDistribution] = await Promise.all([
    fetch(`/v1/api/${orgId}/analytics/usage?periodDays=${periodDays}`),
    fetch(`/v1/api/${orgId}/analytics/daily?startDate=${startDate}&endDate=${endDate}`),
    fetch(`/v1/api/${orgId}/analytics/storage`),
    fetch(`/v1/api/${orgId}/analytics/resolution-distribution?startDate=${startDate}&endDate=${endDate}`)
  ]);

  // Calculate key metrics
  const totalSegments = dailyUsage.body.dailyUsage.reduce((sum, day) => sum + day.segmentsServed, 0);
  const avgDailySegments = totalSegments / periodDays;
  const peakDay = dailyUsage.body.dailyUsage.reduce((max, day) =>
    day.segmentsServed > max.segmentsServed ? day : max
  );

  return {
    overview: {
      totalVideos: accountUsage.body.usage[0].totalVideos,
      totalSegments: accountUsage.body.usage[0].totalSegmentsServed,
      newVideosInPeriod: accountUsage.body.usage[0].videosUploadedInPeriod,
      segmentsInPeriod: accountUsage.body.usage[0].segmentsServedInPeriod
    },
    trends: {
      dailyAverage: avgDailySegments,
      peakDay: peakDay.deliveryDate,
      peakSegments: peakDay.segmentsServed,
      growthRate: calculateGrowthRate(dailyUsage.body.dailyUsage)
    },
    storage: {
      totalHours: storageUsage.body.storage.totalDurationSeconds / 3600,
      avgVideoLength: storageUsage.body.storage.avgVideoDuration / 60,
      qualityDistribution: {
        ultra: (storageUsage.body.storage.ultraQualityDuration / storageUsage.body.storage.totalDurationSeconds) * 100,
        high: (storageUsage.body.storage.highQualityDuration / storageUsage.body.storage.totalDurationSeconds) * 100,
        standard: (storageUsage.body.storage.standardQualityDuration / storageUsage.body.storage.totalDurationSeconds) * 100
      }
    },
    resolutionBreakdown: resolutionDistribution.body.distribution.map(d => ({
      resolution: d.resolutionHeight,
      segments: d.segmentsServed,
      percentage: (d.segmentsServed / totalSegments) * 100,
      videos: d.uniqueVideos
    }))
  };
};

// Calculate week-over-week growth rate
const calculateGrowthRate = (dailyData) => {
  if (dailyData.length < 14) return 0;

  const firstWeek = dailyData.slice(0, 7).reduce((sum, day) => sum + day.segmentsServed, 0);
  const secondWeek = dailyData.slice(7, 14).reduce((sum, day) => sum + day.segmentsServed, 0);

  return ((secondWeek - firstWeek) / firstWeek) * 100;
};

// Monitor video performance trends with alerting
const monitorVideoPerformance = async (videoId, orgId) => {
  const response = await fetch(`/v1/api/${orgId}/videos/${videoId}/analytics/resolution`);
  const analytics = await response.json();

  const performance = {
    videoId: videoId,
    totalViews: calculateVideoViews(analytics.body.summary),
    mostPopularResolution: analytics.body.summary.mostPopularResolution,
    activeDays: analytics.body.summary.totalDaysServed,
    resolutionBreakdown: analytics.body.resolutions.map(r => ({
      resolution: r.resolutionHeight,
      segments: r.timesServed,
      percentage: (r.timesServed / analytics.body.summary.totalSegmentsServed) * 100,
      avgSegmentsPerDay: r.timesServed / r.daysServed
    })),
    health: {
      engagement: analytics.body.summary.totalDaysServed > 30 ? 'high' : 'low',
      qualityDistribution: analyzeQualityDistribution(analytics.body.resolutions),
      recommendations: generateVideoRecommendations(analytics.body)
    }
  };

  // Check for performance alerts
  if (performance.totalViews < 100 && performance.activeDays > 7) {
    console.warn(`Low engagement alert for video ${videoId}: ${performance.totalViews} views over ${performance.activeDays} days`);
  }

  return performance;
};

// Analyze quality distribution health
const analyzeQualityDistribution = (resolutions) => {
  const totalSegments = resolutions.reduce((sum, r) => sum + r.timesServed, 0);
  const hdSegments = resolutions.filter(r => r.resolutionHeight >= 1080).reduce((sum, r) => sum + r.timesServed, 0);
  const hdPercentage = (hdSegments / totalSegments) * 100;

  return {
    hdPercentage: hdPercentage,
    status: hdPercentage > 60 ? 'high-quality-focused' : hdPercentage > 30 ? 'balanced' : 'mobile-focused',
    recommendation: hdPercentage > 80 ? 'Consider optimizing for mobile' : 'Good quality distribution'
  };
};

// Comprehensive cost optimization analysis
const analyzeStorageCosts = async (orgId) => {
  const endDate = new Date().toISOString().split('T')[0];
  const startDate = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString().split('T')[0];

  const [storage, resolutionDistribution, dailyUsage] = await Promise.all([
    fetch(`/v1/api/${orgId}/analytics/storage`),
    fetch(`/v1/api/${orgId}/analytics/resolution-distribution`),
    fetch(`/v1/api/${orgId}/analytics/daily?startDate=${startDate}&endDate=${endDate}`)
  ]);

  const storageData = storage.body.storage;
  const totalHours = storageData.totalDurationSeconds / 3600;
  const avgVideoLength = storageData.avgVideoDuration / 60;

  // Calculate estimated costs (example rates)
  const storageCostPerHour = 0.01; // $0.01 per hour per month
  const deliveryCostPerSegment = 0.0001; // $0.0001 per segment

  const totalDeliverySegments = dailyUsage.body.dailyUsage.reduce((sum, day) => sum + day.segmentsServed, 0);

  const analysis = {
    storage: {
      totalHours: totalHours,
      monthlyStorageCost: totalHours * storageCostPerHour,
      avgVideoLength: avgVideoLength,
      qualityBreakdown: {
        ultra: {
          hours: storageData.ultraQualityDuration / 3600,
          cost: (storageData.ultraQualityDuration / 3600) * storageCostPerHour,
          percentage: (storageData.ultraQualityDuration / storageData.totalDurationSeconds) * 100
        },
        high: {
          hours: storageData.highQualityDuration / 3600,
          cost: (storageData.highQualityDuration / 3600) * storageCostPerHour,
          percentage: (storageData.highQualityDuration / storageData.totalDurationSeconds) * 100
        },
        standard: {
          hours: storageData.standardQualityDuration / 3600,
          cost: (storageData.standardQualityDuration / 3600) * storageCostPerHour,
          percentage: (storageData.standardQualityDuration / storageData.totalDurationSeconds) * 100
        }
      }
    },
    delivery: {
      totalSegments: totalDeliverySegments,
      monthlyDeliveryCost: totalDeliverySegments * deliveryCostPerSegment,
      avgSegmentsPerDay: totalDeliverySegments / 30
    },
    optimization: {
      recommendations: generateOptimizationRecommendations(storageData, resolutionDistribution.body.distribution),
      potentialSavings: calculatePotentialSavings(storageData, resolutionDistribution.body.distribution)
    }
  };

  return analysis;
};

// Generate optimization recommendations
const generateOptimizationRecommendations = (storageData, resolutionDistribution) => {
  const recommendations = [];

  const ultraRatio = storageData.ultraQualityDuration / storageData.totalDurationSeconds;
  if (ultraRatio > 0.5) {
    recommendations.push({
      type: 'storage',
      priority: 'high',
      message: 'High ultra-quality usage detected. Consider reducing ultra quality for non-premium content.',
      potentialSavings: `${Math.round(ultraRatio * 100)}% of storage costs`
    });
  }

  const avgLength = storageData.avgVideoDuration;
  if (avgLength > 600) { // 10 minutes
    recommendations.push({
      type: 'content',
      priority: 'medium',
      message: 'Long average video length. Consider creating shorter, more focused content.',
      potentialSavings: 'Reduced storage and processing costs'
    });
  }

  return recommendations;
};

// Generate comprehensive business intelligence report
const generateBusinessIntelligenceReport = async (orgId, periodDays = 90) => {
  const endDate = new Date().toISOString().split('T')[0];
  const startDate = new Date(Date.now() - periodDays * 24 * 60 * 60 * 1000).toISOString().split('T')[0];

  const [accountUsage, dailyUsage, storageUsage, resolutionDistribution] = await Promise.all([
    fetch(`/v1/api/${orgId}/analytics/usage?periodDays=${periodDays}`),
    fetch(`/v1/api/${orgId}/analytics/daily?startDate=${startDate}&endDate=${endDate}`),
    fetch(`/v1/api/${orgId}/analytics/storage`),
    fetch(`/v1/api/${orgId}/analytics/resolution-distribution?startDate=${startDate}&endDate=${endDate}`)
  ]);

  const report = {
    executiveSummary: {
      period: `${startDate} to ${endDate}`,
      totalVideos: accountUsage.body.usage[0].totalVideos,
      totalViews: calculateTotalViews(dailyUsage.body.dailyUsage),
      growthRate: calculateGrowthRate(dailyUsage.body.dailyUsage),
      avgEngagement: calculateAverageEngagement(dailyUsage.body.dailyUsage)
    },
    contentPerformance: {
      topPerformingDays: findTopPerformingDays(dailyUsage.body.dailyUsage, 5),
      qualityPreferences: analyzeQualityPreferences(resolutionDistribution.body.distribution),
      contentStrategy: generateContentStrategyRecommendations(storageUsage.body.storage, dailyUsage.body.dailyUsage)
    },
    technicalInsights: {
      deviceAnalysis: analyzeDeviceCapabilities(resolutionDistribution.body.distribution),
      bandwidthOptimization: analyzeBandwidthUsage(dailyUsage.body.dailyUsage),
      storageEfficiency: analyzeStorageEfficiency(storageUsage.body.storage)
    },
    recommendations: {
      shortTerm: generateShortTermRecommendations(dailyUsage.body.dailyUsage),
      longTerm: generateLongTermRecommendations(accountUsage.body.usage[0], storageUsage.body.storage)
    }
  };

  return report;
};

// Calculate total estimated views
const calculateTotalViews = (dailyData) => {
  const totalSegments = dailyData.reduce((sum, day) => sum + day.segmentsServed, 0);
  const avgSegmentsPerView = 50; // Estimated based on average video length
  return Math.round(totalSegments / avgSegmentsPerView);
};

// Find top performing days
const findTopPerformingDays = (dailyData, count = 5) => {
  return dailyData
    .sort((a, b) => b.segmentsServed - a.segmentsServed)
    .slice(0, count)
    .map(day => ({
      date: day.deliveryDate,
      segments: day.segmentsServed,
      videos: day.uniqueVideosServed,
      qualityBreakdown: {
        hd: day.hdSegments,
        sd: day.sdSegments,
        ld: day.ldSegments
      }
    }));
};

// Implement intelligent caching for analytics data
class AnalyticsCache {
  constructor() {
    this.cache = new Map();
    this.cacheExpiry = {
      accountUsage: 5 * 60 * 1000,      // 5 minutes
      dailyUsage: 15 * 60 * 1000,       // 15 minutes
      storageUsage: 30 * 60 * 1000,     // 30 minutes
      videoResolution: 10 * 60 * 1000,  // 10 minutes
      resolutionDistribution: 20 * 60 * 1000 // 20 minutes
    };
  }

  async getCachedData(endpoint, params) {
    const key = `${endpoint}_${JSON.stringify(params)}`;
    const cached = this.cache.get(key);

    if (cached && Date.now() - cached.timestamp < this.cacheExpiry[endpoint]) {
      return cached.data;
    }

    return null;
  }

  setCachedData(endpoint, params, data) {
    const key = `${endpoint}_${JSON.stringify(params)}`;
    this.cache.set(key, {
      data: data,
      timestamp: Date.now()
    });
  }
}

// Batch multiple analytics requests for efficiency
const batchAnalyticsRequests = async (orgId, requests) => {
  const results = await Promise.allSettled(requests.map(req => {
    switch(req.type) {
      case 'accountUsage':
        return fetch(`/v1/api/${orgId}/analytics/usage?periodDays=${req.periodDays}`);
      case 'dailyUsage':
        return fetch(`/v1/api/${orgId}/analytics/daily?startDate=${req.startDate}&endDate=${req.endDate}`);
      case 'storageUsage':
        return fetch(`/v1/api/${orgId}/analytics/storage`);
      case 'videoResolution':
        return fetch(`/v1/api/${orgId}/videos/${req.videoId}/analytics/resolution?startDate=${req.startDate}&endDate=${req.endDate}`);
      case 'resolutionDistribution':
        return fetch(`/v1/api/${orgId}/analytics/resolution-distribution?startDate=${req.startDate}&endDate=${req.endDate}`);
      default:
        throw new Error(`Unknown request type: ${req.type}`);
    }
  }));

  return results.map((result, index) => ({
    request: requests[index],
    success: result.status === 'fulfilled',
    data: result.status === 'fulfilled' ? result.value : null,
    error: result.status === 'rejected' ? result.reason : null
  }));
};

// Implement real-time analytics dashboard
class AnalyticsDashboard {
  constructor(orgId, updateInterval = 300000) { // 5 minutes
    this.orgId = orgId;
    this.updateInterval = updateInterval;
    this.subscribers = [];
    this.isRunning = false;
  }

  subscribe(callback) {
    this.subscribers.push(callback);
    if (!this.isRunning) {
      this.start();
    }
  }

  unsubscribe(callback) {
    this.subscribers = this.subscribers.filter(sub => sub !== callback);
    if (this.subscribers.length === 0) {
      this.stop();
    }
  }

  async start() {
    this.isRunning = true;
    this.updateLoop();
  }

  stop() {
    this.isRunning = false;
    if (this.updateTimer) {
      clearTimeout(this.updateTimer);
    }
  }

  async updateLoop() {
    if (!this.isRunning) return;

    try {
      const data = await this.fetchDashboardData();
      this.subscribers.forEach(callback => callback(data));
    } catch (error) {
      console.error('Dashboard update failed:', error);
    }

    this.updateTimer = setTimeout(() => this.updateLoop(), this.updateInterval);
  }

  async fetchDashboardData() {
    const endDate = new Date().toISOString().split('T')[0];
    const startDate = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString().split('T')[0];

    const [accountUsage, dailyUsage, storageUsage] = await Promise.all([
      fetch(`/v1/api/${this.orgId}/analytics/usage?periodDays=7`),
      fetch(`/v1/api/${this.orgId}/analytics/daily?startDate=${startDate}&endDate=${endDate}`),
      fetch(`/v1/api/${this.orgId}/analytics/storage`)
    ]);

    return {
      timestamp: new Date().toISOString(),
      accountUsage: accountUsage.body.usage[0],
      dailyUsage: dailyUsage.body.dailyUsage,
      storageUsage: storageUsage.body.storage
    };
  }
}