namespace HowICode
{
    // Real-world data processing pipeline demonstrating my coding principles in production code
    // This isn't academic theory - it's how I architect systems that scale and maintain themselves

    #region Core Abstractions - DIP & OCP in action

    /// <summary>
    /// Contract for data processing operations. This abstraction allows the system to work with any data source
    /// without coupling to specific implementations. Critical for testing and future extensibility.
    /// </summary>
    internal interface IDataProcessor<TInput, TOutput>
    {
        Task<TOutput> ProcessAsync(TInput input, CancellationToken cancellationToken = default);
    }

    /// <summary>
    /// Logging abstraction - prevents tight coupling to specific logging frameworks.
    /// Can swap from Console to Serilog to Application Insights without changing business logic.
    /// </summary>
    internal interface ILogger
    {
        void LogInfo(string message);
        void LogError(string message, Exception exception = null);
        void LogPerformance(string operation, TimeSpan duration);
    }

    /// <summary>
    /// Caching abstraction - allows switching between in-memory, Redis, or database caching
    /// without touching the business logic that depends on it.
    /// </summary>
    internal interface ICache
    {
        Task<T> GetAsync<T>(string key) where T : class;
        Task SetAsync<T>(string key, T value, TimeSpan expiration) where T : class;
        Task RemoveAsync(string key);
    }

    #endregion

    #region Domain Models - SRP demonstrated

    /// <summary>
    /// Represents user data with validation rules. Single responsibility: model user data correctly.
    /// Immutable by design - prevents accidental mutations that cause bugs in multi-threaded environments.
    /// </summary>
    internal sealed record UserData(
        string Email,
        string FirstName,
        string LastName,
        DateTime CreatedAt)
    {
        // Fail Fast: Validate immediately upon creation
        public UserData(string email, string firstName, string lastName, DateTime createdAt) : this(email, firstName, lastName, createdAt)
        {
            if (string.IsNullOrWhiteSpace(email) || !email.Contains('@'))
                throw new ArgumentException("Invalid email format", nameof(email));
            
            if (string.IsNullOrWhiteSpace(firstName))
                throw new ArgumentException("First name is required", nameof(firstName));
            
            if (string.IsNullOrWhiteSpace(lastName))
                throw new ArgumentException("Last name is required", nameof(lastName));
            
            if (createdAt > DateTime.UtcNow)
                throw new ArgumentException("Creation date cannot be in the future", nameof(createdAt));
        }

        public string FullName => $"{FirstName} {LastName}"; // Computed property - no stored redundant data (DRY)
    }

    /// <summary>
    /// Processing result with metadata. Encapsulates both success/failure state and performance metrics.
    /// This pattern eliminates the need for exception handling in normal flow control.
    /// </summary>
    internal sealed record ProcessingResult<T>(
        T Data,
        bool IsSuccess,
        string ErrorMessage = null,
        TimeSpan ProcessingTime = default)
    {
        public static ProcessingResult<T> Success(T data, TimeSpan processingTime) =>
            new(data, true, null, processingTime);

        public static ProcessingResult<T> Failure(string errorMessage, TimeSpan processingTime) =>
            new(default, false, errorMessage, processingTime);
    }

    #endregion

    #region Infrastructure - Composition Over Inheritance

    /// <summary>
    /// High-performance in-memory cache implementation. Uses concurrent dictionary for thread safety.
    /// Demonstrates composition: USES ConcurrentDictionary instead of INHERITING from it.
    /// </summary>
    internal sealed class MemoryCache : ICache
    {
        private readonly ConcurrentDictionary<string, (object Value, DateTime Expiration)> _cache = new();
        private readonly Timer _cleanupTimer;

        public MemoryCache()
        {
            // Background cleanup every 5 minutes - prevents memory leaks
            _cleanupTimer = new Timer(CleanupExpiredEntries, null, TimeSpan.FromMinutes(5), TimeSpan.FromMinutes(5));
        }

        public Task<T> GetAsync<T>(string key) where T : class
        {
            if (_cache.TryGetValue(key, out var entry) && entry.Expiration > DateTime.UtcNow)
            {
                return Task.FromResult(entry.Value as T);
            }

            _cache.TryRemove(key, out _); // Remove expired entry immediately
            return Task.FromResult<T>(null);
        }

        public Task SetAsync<T>(string key, T value, TimeSpan expiration) where T : class
        {
            var expirationTime = DateTime.UtcNow.Add(expiration);
            _cache.AddOrUpdate(key, (value, expirationTime), (_, _) => (value, expirationTime));
            return Task.CompletedTask;
        }

        public Task RemoveAsync(string key)
        {
            _cache.TryRemove(key, out _);
            return Task.CompletedTask;
        }

        private void CleanupExpiredEntries(object state)
        {
            var now = DateTime.UtcNow;
            var expiredKeys = _cache
                .Where(kvp => kvp.Value.Expiration <= now)
                .Select(kvp => kvp.Key)
                .ToList();

            foreach (var key in expiredKeys)
            {
                _cache.TryRemove(key, out _);
            }
        }

        public void Dispose() => _cleanupTimer?.Dispose();
    }
        // partial code
        // to check full code click on green circle or click expand, you should not see this anyway, i triggered route redirect on 50%