Campaign Analytics

// Get detailed campaign analytics
const campaignId = "camp_1234567890";
const campaign = await campaignClient.getCampaign(campaignId);

// Calculate campaign metrics
const analytics = {
  campaignId: campaign.id,
  name: campaign.name,
  status: campaign.status,
  
  // Time metrics
  createdAt: campaign.createdAt,
  startDate: campaign.startDate,
  endDate: campaign.endDate,
  duration: calculateDuration(campaign.startDate, campaign.endDate),
  
  // Financial metrics
  budget: campaign.budget,
  spent: campaign.spent || 0,
  remainingBudget: campaign.budget - (campaign.spent || 0),
  
  // Performance metrics
  impressions: campaign.metrics?.impressions || 0,
  clicks: campaign.metrics?.clicks || 0,
  conversions: campaign.metrics?.conversions || 0,
  clickThroughRate: campaign.metrics?.ctr || 0,
  conversionRate: campaign.metrics?.conversionRate || 0,
  
  // Engagement metrics
  engagementRate: campaign.metrics?.engagementRate || 0,
  bounceRate: campaign.metrics?.bounceRate || 0,
  avgSessionDuration: campaign.metrics?.avgSessionDuration || 0
};

console.log("Campaign Analytics:", analytics);

// Track campaign executions
const executionHistory = [];

// Execute campaign and track
const execution = await campaignClient.executeCampaign(campaignId, {
  userId: "user_123",
  location: { lat: 40.7128, lng: -74.0060 },
  eventType: "store_visit",
  timestamp: new Date().toISOString()
});

// Store execution data
executionHistory.push({
  executionId: execution.executionId,
  campaignId: execution.campaignId,
  timestamp: execution.timestamp,
  triggerData: execution.triggerData,
  result: execution.result
});

// Analyze execution patterns
const executionAnalytics = {
  totalExecutions: executionHistory.length,
  successfulExecutions: executionHistory.filter(e => e.result.success).length,
  failedExecutions: executionHistory.filter(e => !e.result.success).length,
  avgExecutionTime: calculateAvgExecutionTime(executionHistory),
  mostCommonTriggers: getMostCommonTriggers(executionHistory)
};

console.log("Execution Analytics:", executionAnalytics);

// Time-based campaign analysis
const campaigns = await campaignClient.listCampaigns();

// Group campaigns by time periods
const timeAnalysis = {
  thisMonth: campaigns.filter(c => isThisMonth(c.createdAt)),
  lastMonth: campaigns.filter(c => isLastMonth(c.createdAt)),
  thisQuarter: campaigns.filter(c => isThisQuarter(c.createdAt)),
  thisYear: campaigns.filter(c => isThisYear(c.createdAt))
};

// Calculate growth metrics
const monthlyGrowth = {
  campaignCount: {
    current: timeAnalysis.thisMonth.length,
    previous: timeAnalysis.lastMonth.length,
    growth: calculateGrowthRate(
      timeAnalysis.thisMonth.length, 
      timeAnalysis.lastMonth.length
    )
  },
  totalBudget: {
    current: sumBudgets(timeAnalysis.thisMonth),
    previous: sumBudgets(timeAnalysis.lastMonth),
    growth: calculateGrowthRate(
      sumBudgets(timeAnalysis.thisMonth), 
      sumBudgets(timeAnalysis.lastMonth)
    )
  }
};

console.log("Monthly Growth:", monthlyGrowth);

// Custom analytics helper functions
class CampaignAnalytics {
  constructor(campaignClient) {
    this.client = campaignClient;
  }

  async getTopPerformingCampaigns(limit = 10) {
    const campaigns = await this.client.listCampaigns();
    return campaigns
      .filter(c => c.metrics)
      .sort((a, b) => (b.metrics.conversionRate || 0) - (a.metrics.conversionRate || 0))
      .slice(0, limit);
  }

  async getCampaignsByIndustry() {
    const campaigns = await this.client.listCampaigns();
    return campaigns.reduce((acc, campaign) => {
      const industry = campaign.industry || 'unknown';
      if (!acc[industry]) acc[industry] = [];
      acc[industry].push(campaign);
      return acc;
    }, {});
  }

  async getBudgetUtilization() {
    const campaigns = await this.client.listCampaigns();
    const totalBudget = campaigns.reduce((sum, c) => sum + (c.budget || 0), 0);
    const totalSpent = campaigns.reduce((sum, c) => sum + (c.spent || 0), 0);
    
    return {
      totalBudget,
      totalSpent,
      utilizationRate: (totalSpent / totalBudget) * 100,
      remainingBudget: totalBudget - totalSpent
    };
  }

  async getCampaignDurationAnalysis() {
    const campaigns = await this.client.listCampaigns()
      .filter(c => c.startDate && c.endDate);
    
    const durations = campaigns.map(c => 
      new Date(c.endDate) - new Date(c.startDate)
    );
    
    return {
      avgDuration: durations.reduce((sum, d) => sum + d, 0) / durations.length,
      minDuration: Math.min(...durations),
      maxDuration: Math.max(...durations),
      totalCampaigns: durations.length
    };
  }
}

// Usage
const analytics = new CampaignAnalytics(campaignClient);
const topCampaigns = await analytics.getTopPerformingCampaigns(5);
const budgetStats = await analytics.getBudgetUtilization();

console.log("Top campaigns:", topCampaigns);
console.log("Budget utilization:", budgetStats);