adas-core/adas-core.Application/Services/Caching/NoCacheService.cs

using adas_core.Application.Services.Interfaces;
using adas_core.Domain.Models.GroupedObservations;
using MongoDB.Bson;

namespace adas_core.Application.Services.Caching
{
    /// <summary>
    /// Implementación nula de ICacheService.
    /// No almacena nada, no devuelve nada y no interfiere con el flujo.
    /// Se usa cuando el CacheMode es "None".
    /// </summary>
    public class NoCacheService : ICacheService
    {
        /// <summary>
        /// Stub implementation that performs no action. Intended as a placeholder for storing a value associated with the specified key.
        /// </summary>
        /// <param name="key">The identifier used to reference the value.</param>
        /// <param name="value">The value intended to be associated with the key.</param>
        public void SetValue(string key, string value)
                {
                    // No hacer nada
                }

        /// <summary>
        /// Retrieves the string value associated with the specified key.
        /// Returns <c>null</c> when no value is found for the given key.
        /// </summary>
        /// <param name="key">The key used to look up the associated value.</param>
        /// <returns>The value associated with <paramref name="key"/>, or <c>null</c> if no value is found.</returns>
        public string? GetValue(string key)
                {
                    return null;
                }

        /// <summary>
        /// Asynchronously retrieves an object of type <typeparamref name="T"/> associated with the specified <paramref name="key"/>.
        /// </summary>
        /// <param name="key">The identifier of the object to retrieve.</param>
        /// <param name="updateExpiration">Indicates whether the expiration of the entry should be updated upon retrieval.</param>
        /// <returns>A <see cref="Task{T}"/> that represents the asynchronous retrieval, containing the object associated with the key or the default value of <typeparamref name="T"/> if not found.</returns>
        public Task<T?> GetObjectAsync<T>(string key, bool updateExpiration = true)
                {
                    return Task.FromResult<T?>(default);
                }

        /// <summary>
        /// Asynchronously stores the specified object associated with the given key in the underlying data store.
        /// When <paramref name="updateExpiration"/> is true, the expiration of the entry is refreshed; otherwise the existing expiration is preserved.
        /// </summary>
        /// <param name="key">The unique identifier used to store and later retrieve the object.</param>
        /// <param name="obj">The object to store in the data store.</param>
        /// <param name="updateExpiration">Indicates whether the expiration time of the cached entry should be updated. Defaults to true.</param>
        public Task SetObjectAsync<T>(string key, T obj, bool updateExpiration = true)
                {
                    return Task.CompletedTask;
                }

        /// <summary>
        /// Asynchronously retrieves an object of type <typeparamref name="T"/> associated with the specified <paramref name="key"/>.
        /// Supports an optional time-to-live override and an option to update the expiration of the stored entry.
        /// </summary>
        /// <param name="key">The unique identifier used to look up the stored object.</param>
        /// <param name="ttlOverride">An optional time-to-live value that, when provided, overrides the default expiration for the entry.</param>
        /// <param name="updateExpiration">Indicates whether the expiration of the entry should be refreshed upon a successful retrieval.</param>
        /// <returns>A <see cref="Task{T}"/> that represents the asynchronous operation, containing the retrieved object or <c>null</c> if no value is found.</returns>
        public Task<T?> GetObjectAsync<T>(string key, TimeSpan? ttlOverride, bool updateExpiration)
                {
                    return Task.FromResult<T?>(default);
                }

        /// <summary>
        /// Asynchronously stores an object associated with the specified key, optionally overriding the time-to-live and updating the expiration.
        /// </summary>
        /// <param name="key">The identifier used to store and retrieve the object.</param>
        /// <param name="obj">The object to be stored.</param>
        /// <param name="ttlOverride">An optional time-to-live value that overrides the default expiration period; <c>null</c> uses the default.</param>
        /// <param name="updateExpiration">A value indicating whether the expiration time should be updated.</param>
        /// <returns>A task that represents the asynchronous set operation.</returns>
        public Task SetObjectAsync<T>(string key, T obj, TimeSpan? ttlOverride, bool updateExpiration)
                {
                    return Task.CompletedTask;
                }

        /// <summary>
        /// Asynchronously deletes items matching the specified pattern and returns the number of items removed.
        /// This implementation is a stub that always returns 0, performing no actual deletion regardless of the provided pattern.
        /// </summary>
        /// <param name="pattern">The pattern used to identify the items to delete.</param>
        /// <returns>A <see cref="Task{Int64}"/> representing the asynchronous operation, with a result of 0 indicating that no items were deleted.</returns>
        public Task<long> DeleteByPatternAsync(string pattern)
                {
                    return Task.FromResult(0L);
                }

        /// <summary>
        /// Asynchronously deletes the object identified by the specified key.
        /// The operation completes immediately without performing an actual deletion.
        /// </summary>
        /// <param name="key">The identifier of the object to delete.</param>
        /// <returns>A <see cref="Task"/> that represents the asynchronous delete operation.</returns>
        public Task DeleteObjectAsync(string key)
                {
                    return Task.CompletedTask;
                }

        /// <summary>
        /// Performs a cleanup operation on the cache. Currently, this method has no implementation and does not perform any cleanup actions.
        /// </summary>
        public void CleanCache()
                {
                    // Nada que limpiar
                }

        // ============================================================
        // GET OR SET - STRING KEY
        // ============================================================

        public async Task<T> GetOrSetObjectAsync<T>(
            string key,
            Func<Task<T>> factory,
            TimeSpan? ttl = null,
            CancellationToken cancellationToken = default)
        {
            // En modo NONE no hay caché → siempre ejecutar factory
            return await factory();
        }

        /// <summary>
        /// Asynchronously loads a value using the provided loader function.
        /// </summary>
        /// <param name="key">The key associated with the value to retrieve or set.</param>
        /// <param name="loader">The asynchronous function used to load the value.</param>
        /// <param name="ttl">An optional time-to-live duration for the value.</param>
        /// <returns>A task that represents the asynchronous operation, containing the loaded value as a nullable string.</returns>
        public async Task<string?> GetOrSetValueAsync(
                    string key,
                    Func<Task<string>> loader,
                    TimeSpan? ttl = null)
                {
                    var result = await loader();
                    return (string?)result;
                }

        // ============================================================
        // GET OR SET - GroupedField + patientId
        // ============================================================

        public async Task<T> GetOrSetObjectAsync<T>(
            GroupedField groupedField,
            ObjectId patientId,
            Func<Task<T>> factory,
            TimeSpan? ttl = null,
            CancellationToken cancellationToken = default)
        {
            // Igual que arriba: en modo NONE no hay caché
            return await factory();
        }
    }
}