{
  "youtube": {
    "api_key": "${YOUTUBE_API_KEY}",
    "channel_id": "${YOUTUBE_CHANNEL_ID}"
  },
  "refresh_interval": 300,
  "data_retention_days": 90,
  "export": {
    "default_format": "csv",
    "output_directory": "./exports"
  },
  "dashboard": {
    "theme": "light",
    "auto_refresh": true
  }
}

YOUTUBE_API_KEY=your_youtube_api_key_here
YOUTUBE_CHANNEL_ID=your_channel_id_here
YOUTUBE_DATA_API_VERSION=v3

# Standard launch
.\YouTubeAnalytics.exe

# With custom config
.\YouTubeAnalytics.exe --config custom_config.json

# Debug mode
.\YouTubeAnalytics.exe --debug --verbose

# Export current analytics to CSV
.\YouTubeAnalytics.exe --export csv --output ./reports/analytics.csv

# Export specific date range
.\YouTubeAnalytics.exe --export pdf --from 2026-01-01 --to 2026-06-30

# Generate subscriber growth report
.\YouTubeAnalytics.exe --report subscribers --period 30d

# Fetch real-time stats only
.\YouTubeAnalytics.exe --realtime --format json

using YouTubeAnalytics.Core;
using YouTubeAnalytics.Models;

// Initialize the analytics client
var config = new AnalyticsConfig
{
    ApiKey = Environment.GetEnvironmentVariable("YOUTUBE_API_KEY"),
    ChannelId = Environment.GetEnvironmentVariable("YOUTUBE_CHANNEL_ID"),
    RefreshInterval = TimeSpan.FromMinutes(5)
};

var client = new YouTubeAnalyticsClient(config);

// Fetch real-time statistics
var stats = await client.GetRealtimeStatsAsync();
Console.WriteLine($"Current Subscribers: {stats.SubscriberCount}");
Console.WriteLine($"Total Views: {stats.TotalViews}");

// Get historical data
var history = await client.GetHistoricalDataAsync(
    startDate: DateTime.Now.AddDays(-30),
    endDate: DateTime.Now,
    metrics: new[] { "views", "subscribersGained", "estimatedRevenue" }
);

// Analyze top performing videos
var topVideos = await client.GetTopVideosAsync(
    period: TimePeriod.Last30Days,
    metric: VideoMetric.Views,
    limit: 10
);

foreach (var video in topVideos)
{
    Console.WriteLine($"{video.Title}: {video.Views:N0} views");
}

// Export to CSV
var exporter = new DataExporter(client);
await exporter.ExportToCsvAsync(
    "./exports/monthly_report.csv",
    startDate: DateTime.Now.AddMonths(-1),
    endDate: DateTime.Now
);

// Scheduled daily report generation
using YouTubeAnalytics.Automation;

var scheduler = new ReportScheduler(client);

scheduler.ScheduleDailyReport(
    time: new TimeSpan(9, 0, 0), // 9 AM
    reportType: ReportType.DailySummary,
    recipients: new[] { "team@example.com" },
    format: ExportFormat.PDF
);

// Alert on subscriber milestones
scheduler.AddAlert(new SubscriberMilestoneAlert
{
    Milestone = 10000,
    NotificationMethod = NotificationMethod.Email,
    Recipient = "notifications@example.com"
});

// Calculate growth rate
var growth = await client.GetSubscriberGrowthAsync(
    period: TimePeriod.Last90Days
);

var avgDailyGrowth = growth.Sum(d => d.NewSubscribers) / growth.Count;
var growthRate = (growth.Last().TotalSubscribers - growth.First().TotalSubscribers) 
                 / (double)growth.First().TotalSubscribers * 100;

Console.WriteLine($"Average daily growth: {avgDailyGrowth:F1} subscribers");
Console.WriteLine($"90-day growth rate: {growthRate:F2}%");

// Estimate revenue by video
var revenueData = await client.GetRevenueBreakdownAsync(
    startDate: DateTime.Now.AddMonths(-1),
    endDate: DateTime.Now,
    groupBy: RevenueGrouping.ByVideo
);

var topEarners = revenueData
    .OrderByDescending(v => v.EstimatedRevenue)
    .Take(10);

foreach (var video in topEarners)
{
    Console.WriteLine($"{video.Title}: ${video.EstimatedRevenue:F2}");
}

// Analyze audience location
var demographics = await client.GetAudienceDemographicsAsync();

var topCountries = demographics.Geography
    .OrderByDescending(g => g.ViewPercentage)
    .Take(5);

Console.WriteLine("Top 5 Countries:");
foreach (var country in topCountries)
{
    Console.WriteLine($"  {country.Name}: {country.ViewPercentage:F1}%");
}

// Age distribution
var ageGroups = demographics.AgeDistribution;
Console.WriteLine($"Primary audience age: {ageGroups.MaxBy(a => a.Percentage).AgeRange}");

// Define a custom dashboard layout
var dashboard = new DashboardLayout();

dashboard.AddPanel(new Panel
{
    Type = PanelType.LineChart,
    Title = "Subscriber Growth",
    DataSource = DataSource.SubscriberHistory,
    Position = new Position(0, 0),
    Size = new Size(2, 1)
});

dashboard.AddPanel(new Panel
{
    Type = PanelType.Gauge,
    Title = "Real-time Views",
    DataSource = DataSource.RealtimeViews,
    Position = new Position(2, 0),
    Size = new Size(1, 1)
});

dashboard.AddPanel(new Panel
{
    Type = PanelType.Map,
    Title = "Audience Geography",
    DataSource = DataSource.Geography,
    Position = new Position(0, 1),
    Size = new Size(3, 1)
});

await dashboard.SaveAsync("custom_layout.json");

# Export all metrics
.\YouTubeAnalytics.exe --export csv --metrics all --output report.csv

# Export specific metrics
.\YouTubeAnalytics.exe --export csv --metrics views,subscribers,revenue --from 2026-01-01

using YouTubeAnalytics.Reporting;

var reportGenerator = new PdfReportGenerator(client);

var report = await reportGenerator.GenerateAsync(new ReportOptions
{
    Title = "Monthly Performance Report",
    Period = new DateRange(DateTime.Now.AddMonths(-1), DateTime.Now),
    Sections = new[]
    {
        ReportSection.Overview,
        ReportSection.SubscriberGrowth,
        ReportSection.TopVideos,
        ReportSection.AudienceDemographics,
        ReportSection.RevenueEstimate
    },
    IncludeCharts = true,
    BrandingLogo = "./logo.png"
});

await report.SaveAsync("./reports/monthly_report.pdf");

# Test API connection
.\YouTubeAnalytics.exe --test-connection --verbose

// Force data refresh
await client.RefreshAllMetricsAsync(forceUpdate: true);

# Export with limited data
.\YouTubeAnalytics.exe --export csv --metrics views,subscribers --limit 1000

{
  "performance": {
    "enable_caching": true,
    "cache_max_size_mb": 500,
    "auto_cleanup": true
  }
}

// Set up webhook for real-time alerts
var webhookConfig = new WebhookConfig
{
    Url = "https://your-server.com/youtube-webhook",
    Events = new[] { "subscriber_milestone", "viral_video", "revenue_threshold" },
    Secret = Environment.GetEnvironmentVariable("WEBHOOK_SECRET")
};

await client.ConfigureWebhookAsync(webhookConfig);

// Compare two time periods
var comparison = await client.ComparePeriodsAsync(
    period1: new DateRange(DateTime.Now.AddMonths(-2), DateTime.Now.AddMonths(-1)),
    period2: new DateRange(DateTime.Now.AddMonths(-1), DateTime.Now),
    metrics: new[] { "views", "subscribers", "watchTime" }
);

Console.WriteLine($"Views change: {comparison.Views.PercentChange:F1}%");
Console.WriteLine($"Subscriber change: {comparison.Subscribers.PercentChange:F1}%");