// Event-sourced aggregate root
public class UrlAggregate : AggregateRoot
{
    public string ShortCode { get; private set; }
    public string OriginalUrl { get; private set; }
    public DateTime CreatedAt { get; private set; }
    public DateTime? ExpiresAt { get; private set; }
    public long ClickCount { get; private set; }
    public bool IsActive { get; private set; } = true;
    
    // Event sourcing: all state changes through events
    public static UrlAggregate Create(string originalUrl, string? customAlias = null, DateTime? expiresAt = null)
    {
        var shortCode = customAlias ?? GenerateShortCode();
        var aggregate = new UrlAggregate();
        
        var @event = new UrlCreatedEvent
        {
            AggregateId = Guid.NewGuid().ToString(),
            ShortCode = shortCode,
            OriginalUrl = originalUrl,
            ExpiresAt = expiresAt,
            CreatedAt = DateTime.UtcNow,
            Version = 1
        };
        
        aggregate.RaiseEvent(@event);
        return aggregate;
    }
    
    public void RecordClick(string userAgent, string ipAddress, string referrer)
    {
        if (!IsActive || (ExpiresAt.HasValue && DateTime.UtcNow > ExpiresAt))
            throw new UrlExpiredException(ShortCode);
            
        var @event = new UrlClickedEvent
        {
            AggregateId = Id,
            ClickedAt = DateTime.UtcNow,
            UserAgent = userAgent,
            IpAddress = ipAddress,
            Referrer = referrer,
            Version = Version + 1
        };
        
        RaiseEvent(@event);
    }
    
    // Event handlers update internal state
    protected override void When(DomainEvent @event)
    {
        switch (@event)
        {
            case UrlCreatedEvent e: Apply(e); break;
            case UrlClickedEvent e: Apply(e); break;
        }
    }
}

public class GetUrlQueryHandler : IQueryHandler<GetUrlQuery, UrlReadModel>
{
    private readonly IMemoryCache _l1Cache;
    private readonly IDistributedCache _l2Cache;
    private readonly IReadModelRepository _repository;
    private readonly CircuitBreakerService _circuitBreaker;
    
    public async Task<UrlReadModel> Handle(GetUrlQuery query, CancellationToken ct)
    {
        // L1: Memory cache (1ms lookup, 95% hit rate)
        if (_l1Cache.TryGetValue($"url:{query.ShortCode}", out UrlReadModel cachedUrl))
        {
            _metrics.IncrementCounter("cache.l1.hit");
            return cachedUrl;
        }
        
        // L2: Redis cache (5-10ms lookup, 4% hit rate)
        var redisCached = await _l2Cache.GetStringAsync($"url:{query.ShortCode}");
        if (redisCached != null)
        {
            _metrics.IncrementCounter("cache.l2.hit");
            var url = JsonSerializer.Deserialize<UrlReadModel>(redisCached);
            
            // Populate L1 cache
            _l1Cache.Set($"url:{query.ShortCode}", url, TimeSpan.FromMinutes(5));
            return url;
        }
        
        // L3: Database with circuit breaker (50-100ms lookup, 1% hit rate)
        return await _circuitBreaker.ExecuteAsync(async () =>
        {
            _metrics.IncrementCounter("cache.miss");
            var urlFromDb = await _repository.GetByShortCodeAsync(query.ShortCode);
            
            if (urlFromDb != null)
            {
                // Populate both cache layers
                await _l2Cache.SetStringAsync(
                    $"url:{query.ShortCode}",
                    JsonSerializer.Serialize(urlFromDb),
                    new DistributedCacheEntryOptions { SlidingExpiration = TimeSpan.FromHours(24) });
                    
                _l1Cache.Set($"url:{query.ShortCode}", urlFromDb, TimeSpan.FromMinutes(5));
            }
            
            return urlFromDb;
        });
    }
}

[Route("api/analytics")]
public class AnalyticsController : ControllerBase
{
    private readonly IHubContext<AnalyticsHub> _hubContext;
    
    [HttpGet("stream/{shortCode}")]
    public async IAsyncEnumerable<ClickAnalytics> StreamAnalytics(
        string shortCode,
        [EnumeratorCancellation] CancellationToken ct)
    {
        await foreach (var analytics in _analyticsService.GetLiveAnalyticsAsync(shortCode, ct))
        {
            // Broadcast to SignalR clients for real-time dashboards
            await _hubContext.Clients.Group($"analytics-{shortCode}")
                .SendAsync("AnalyticsUpdate", analytics, ct);
                
            yield return analytics;
        }
    }
}

public class CircuitBreakerService
{
    private readonly IAsyncPolicy _circuitBreakerPolicy;
    
    public CircuitBreakerService()
    {
        _circuitBreakerPolicy = Policy
            .Handle<Exception>(ex => !(ex is BusinessLogicException))
            .AdvancedCircuitBreakerAsync(
                handledEventsAllowedBeforeBreaking: 10,
                durationOfBreak: TimeSpan.FromSeconds(30),
                minimumThroughput: 20,
                failureThreshold: 0.5, // 50% failure rate triggers circuit
                onBreak: (exception, duration) =>
                {
                    _logger.LogWarning("Circuit breaker opened for {Duration}s", duration.TotalSeconds);
                    _metrics.IncrementCounter("circuit_breaker.opened");
                },
                onReset: () =>
                {
                    _logger.LogInformation("Circuit breaker reset - normal operation resumed");
                    _metrics.IncrementCounter("circuit_breaker.reset");
                });
    }
}

public class IntelligentCacheWarmingService : BackgroundService
{
    private readonly IMLPredictionService _mlService;
    private readonly ICacheManager _cacheManager;
    private readonly IAnalyticsRepository _analyticsRepository;
    
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            // ML-powered prediction of URLs likely to be accessed
            var predictedHotUrls = await _mlService.PredictHotUrlsAsync(
                lookAheadMinutes: 60,
                confidenceThreshold: 0.8);
            
            // Priority-based cache warming
            var warmingTasks = predictedHotUrls.Select(async prediction =>
            {
                var url = await _analyticsRepository.GetUrlAsync(prediction.ShortCode);
                if (url != null)
                {
                    // Warm all cache layers based on predicted traffic
                    await WarmCacheLayersAsync(url, prediction.PredictedTraffic);
                }
            });
            
            await Task.WhenAll(warmingTasks);
            
            // Adaptive warming interval based on system load
            var interval = await CalculateOptimalWarmingInterval();
            await Task.Delay(interval, stoppingToken);
        }
    }
    
    private async Task WarmCacheLayersAsync(UrlReadModel url, int predictedTraffic)
    {
        var cacheKey = $"url:{url.ShortCode}";
        var serializedUrl = JsonSerializer.Serialize(url);
        
        // L1: Memory cache with traffic-based TTL
        var l1Ttl = CalculateL1Ttl(predictedTraffic);
        _cacheManager.SetL1(cacheKey, url, l1Ttl);
        
        // L2: Redis with geographic distribution
        await _cacheManager.SetL2GlobalAsync(cacheKey, serializedUrl, TimeSpan.FromHours(24));
        
        _metrics.IncrementCounter("cache.warmed", new("layer", "all"));
    }
    
    private TimeSpan CalculateL1Ttl(int predictedTraffic)
    {
        // Higher traffic = longer L1 cache retention
        return predictedTraffic switch
        {
            > 10000 => TimeSpan.FromHours(2),  // Viral content
            > 1000 => TimeSpan.FromMinutes(30), // Popular content
            > 100 => TimeSpan.FromMinutes(10),  // Normal content
            _ => TimeSpan.FromMinutes(5)        // Default
        };
    }
}

public class SmartCacheInvalidationService
{
    private readonly IEventBus _eventBus;
    private readonly ICacheManager _cacheManager;
    private readonly IDistributedLock _distributedLock;
    
    public async Task InvalidateCacheAsync(string shortCode, InvalidationReason reason)
    {
        // Distributed lock prevents race conditions during invalidation
        using var lockHandle = await _distributedLock.AcquireAsync($"invalidate:{shortCode}", TimeSpan.FromSeconds(30));
        
        if (lockHandle != null)
        {
            // Invalidate all cache layers atomically
            await InvalidateAllLayersAsync(shortCode);
            
            // Publish invalidation event for other regions
            await _eventBus.PublishAsync(new CacheInvalidatedEvent
            {
                ShortCode = shortCode,
                Reason = reason,
                Timestamp = DateTime.UtcNow,
                Region = Environment.GetEnvironmentVariable("AWS_REGION")
            });
            
            _metrics.IncrementCounter("cache.invalidated", new("reason", reason.ToString()));
        }
    }
    
    private async Task InvalidateAllLayersAsync(string shortCode)
    {
        var cacheKey = $"url:{shortCode}";
        
        // L1: Remove from local memory
        _cacheManager.RemoveL1(cacheKey);
        
        // L2: Remove from Redis cluster with failover
        await _cacheManager.RemoveL2GlobalAsync(cacheKey);
        
        // Metrics for cache invalidation effectiveness
        _metrics.RecordValue("cache.invalidation.latency", 
            DateTimeOffset.UtcNow.ToUnixTimeMilliseconds());
    }
}

public class PerformanceMonitoringService : BackgroundService
{
    private readonly IMetrics _metrics;
    private readonly ICacheManager _cacheManager;
    private readonly IAutoScalingService _autoScaler;
    
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            var performanceMetrics = await GatherPerformanceMetricsAsync();
            
            // Real-time cache performance analysis
            var cacheAnalysis = AnalyzeCachePerformance(performanceMetrics);
            
            // Auto-scale based on cache hit ratios and latency
            if (cacheAnalysis.L1HitRate < 0.90 || cacheAnalysis.AverageLatency > TimeSpan.FromMilliseconds(100))
            {
                await _autoScaler.ScaleL1CacheAsync(ScaleDirection.Up);
                _metrics.IncrementCounter("autoscale.triggered", new("component", "l1_cache"));
            }
            
            if (cacheAnalysis.L2HitRate < 0.95)
            {
                await _autoScaler.ScaleRedisClusterAsync(ScaleDirection.Up);
                _metrics.IncrementCounter("autoscale.triggered", new("component", "redis"));
            }
            
            // Publish metrics for observability
            PublishPerformanceMetrics(performanceMetrics, cacheAnalysis);
            
            await Task.Delay(TimeSpan.FromSeconds(30), stoppingToken);
        }
    }
    
    private async Task<PerformanceMetrics> GatherPerformanceMetricsAsync()
    {
        var now = DateTime.UtcNow;
        var oneMinuteAgo = now.AddMinutes(-1);
        
        return new PerformanceMetrics
        {
            L1HitRate = await _metrics.GetCounterRateAsync("cache.l1.hit", oneMinuteAgo, now),
            L2HitRate = await _metrics.GetCounterRateAsync("cache.l2.hit", oneMinuteAgo, now),
            CacheMissRate = await _metrics.GetCounterRateAsync("cache.miss", oneMinuteAgo, now),
            AverageResponseTime = await _metrics.GetAverageHistogramAsync("request.duration", oneMinuteAgo, now),
            RequestsPerSecond = await _metrics.GetCounterRateAsync("requests.total", oneMinuteAgo, now),
            DatabaseConnections = await _metrics.GetGaugeValueAsync("database.connections.active"),
            MemoryUsage = GC.GetTotalMemory(false) / (1024 * 1024) // MB
        };
    }
}

public class GeographicCacheManager
{
    private readonly Dictionary<string, IDistributedCache> _regionalCaches;
    private readonly IGeolocationService _geolocation;
    
    public GeographicCacheManager(IServiceProvider serviceProvider)
    {
        _regionalCaches = new Dictionary<string, IDistributedCache>
        {
            ["us-east-1"] = serviceProvider.GetKeyedService<IDistributedCache>("us-east-1"),
            ["eu-west-1"] = serviceProvider.GetKeyedService<IDistributedCache>("eu-west-1"),
            ["ap-southeast-1"] = serviceProvider.GetKeyedService<IDistributedCache>("ap-southeast-1")
        };
        _geolocation = serviceProvider.GetRequiredService<IGeolocationService>();
    }
    
    public async Task<string?> GetFromNearestRegionAsync(string key, string clientIpAddress)
    {
        // Get user's location for optimal cache selection
        var userLocation = await _geolocation.GetLocationAsync(clientIpAddress);
        var nearestRegion = DetermineNearestRegion(userLocation);
        
        // Try nearest region first
        var cache = _regionalCaches[nearestRegion];
        var value = await cache.GetStringAsync(key);
        
        if (value != null)
        {
            _metrics.IncrementCounter("cache.geo.hit", new("region", nearestRegion));
            return value;
        }
        
        // Fallback to other regions if nearest cache miss
        foreach (var (region, regionCache) in _regionalCaches.Where(r => r.Key != nearestRegion))
        {
            value = await regionCache.GetStringAsync(key);
            if (value != null)
            {
                _metrics.IncrementCounter("cache.geo.fallback", new("region", region));
                
                // Replicate to nearest region for future requests
                await cache.SetStringAsync(key, value, TimeSpan.FromHours(1));
                return value;
            }
        }
        
        _metrics.IncrementCounter("cache.geo.miss");
        return null;
    }
    
    private string DetermineNearestRegion(GeoLocation location)
    {
        // Simple distance calculation - in production, use proper geo-distance algorithms
        return location.Continent switch
        {
            "North America" => "us-east-1",
            "Europe" => "eu-west-1",
            "Asia" => "ap-southeast-1",
            _ => "us-east-1" // Default fallback
        };
    }
}