using DigitalData.Core.Contracts.Application;
using DigitalData.Core.Contracts.CultureServices;
using static System.Runtime.InteropServices.JavaScript.JSType;

namespace DigitalData.Core.Application
{
    public class ResponseService : IResponseService
    {
        protected readonly IKeyTranslationService _translationService;

        public ResponseService(IKeyTranslationService translationService)
        {
            _translationService = translationService;
        }

        #region WITHOUT_MESSAGE

        /// <summary>
        /// Creates a service message indicating success or failure without additional messages.
        /// </summary>
        /// <param name="isSuccess">Indicates if the operation was successful.</param>
        /// <returns>A service message reflecting the operation outcome.</returns>
        public IServiceMessage CreateMessage(bool isSuccess = false) => new ServiceMessage()
        {
            IsSuccess = isSuccess,
            KeyTranslator = _translationService.Translate
        };

        /// <summary>
        /// Creates a service result containing the provided data and a success flag, without additional messages.
        /// </summary>
        /// <typeparam name="T">The type of the data included in the result.</typeparam>
        /// <param name="data">The data to include in the result.</param>
        /// <param name="isSuccess">Indicates if the operation was successful.</param>
        /// <returns>A service result with the specified data and outcome.</returns>
        public IServiceResult<T> CreateResult<T>(T? data = default, bool isSuccess = false) => new ServiceResult<T>()
        {
            IsSuccess = isSuccess,
            Data = data,
            KeyTranslator = _translationService.Translate
        };

        /// <summary>
        /// Creates a service message indicating a successful operation without additional messages.
        /// </summary>
        /// <returns>A service message indicating a successful operation.</returns>
        public IServiceMessage Successful() => CreateMessage(true);

        /// <summary>
        /// Creates a service message indicating a failed operation without additional messages.
        /// </summary>
        /// <returns>A service message indicating a failed operation.</returns>
        public IServiceMessage Failed() => CreateMessage(false);

        /// <summary>
        /// Creates a successful service result with the specified data, without additional messages.
        /// </summary>
        /// <typeparam name="T">The type of data included in the result.</typeparam>
        /// <param name="data">The data to include in the result.</param>
        /// <returns>A successful service result containing the specified data.</returns>
        public IServiceResult<T> Successful<T>(T data) => CreateResult(data, true);

        /// <summary>
        /// Creates a failed service result with optional data, without additional messages.
        /// </summary>
        /// <typeparam name="T">The type of data the service result can contain.</typeparam>
        /// <param name="data">Optional data to include in the result.</param>
        /// <returns>A failed service result, which may or may not contain the specified data.</returns>
        public IServiceResult<T> Failed<T>(T? data = default) => CreateResult(data, false);

        #endregion
        #region WITH_STRING_MESSAGE
        [Obsolete("Deprecated: Use ClientMessages instead.")]
        /// <summary>
        /// Creates a service message with the specified success flag and messages.
        /// </summary>
        /// <param name="isSuccess">Indicates if the operation was successful.</param>
        /// <param name="messages">An array of messages associated with the operation.</param>
        /// <returns>A new instance of <see cref="ServiceMessage"/> reflecting the operation outcome.</returns>
        public virtual IServiceMessage CreateMessage(bool isSuccess, params string[] messages) => new ServiceMessage(isSuccess, messages);

        [Obsolete("Deprecated: Use ClientMessages instead.")]
        /// <summary>
        /// Creates a service result containing the provided data, success flag, and messages.
        /// </summary>
        /// <typeparam name="T">The type of the data included in the result.</typeparam>
        /// <param name="data">The data to include in the result.</param>
        /// <param name="isSuccess">Indicates if the operation was successful.</param>
        /// <param name="messages">An array of messages associated with the operation.</param>
        /// <returns>A new instance of <see cref="ServiceResult{T}"/> with the specified data and outcome.</returns>
        public virtual IServiceResult<T> CreateResult<T>(T? data = default, bool isSuccess = true, params string[] messages) => new ServiceResult<T>(data, isSuccess, messages);

        [Obsolete("Deprecated: Use ClientMessages instead.")]
        /// <summary>
        /// Creates a successful service message.
        /// </summary>
        /// <param name="messages">An array of success messages.</param>
        /// <returns>A successful service message.</returns>
        public virtual IServiceMessage Successful(params string[] messages) => CreateMessage(true, messages);

        [Obsolete("Deprecated: Use ClientMessages instead.")]
        /// <summary>
        /// Creates a failed service message.
        /// </summary>
        /// <param name="messages">An array of failure messages.</param>
        /// <returns>A failed service message.</returns>
        public virtual IServiceMessage Failed(params string[] messages) => CreateMessage(false, messages);

        [Obsolete("Deprecated: Use ClientMessages instead.")]
        /// <summary>
        /// Creates a successful service result with the provided data.
        /// </summary>
        /// <typeparam name="T">The type of data included in the result.</typeparam>
        /// <param name="data">The data to include in the result.</param>
        /// <param name="messages">An array of success messages.</param>
        /// <returns>A successful service result containing the specified data.</returns>
        public virtual IServiceResult<T> Successful<T>(T data, params string[] messages) => CreateResult(data, true, messages);

        [Obsolete("Deprecated: Use ClientMessages instead.")]
        /// <summary>
        /// Creates a failed service result, optionally including data.
        /// </summary>
        /// <typeparam name="T">The type of data the service result can contain.</typeparam>
        /// <param name="data">Optional data to include in the failed result.</param>
        /// <param name="messages">An array of failure messages.</param>
        /// <returns>A failed service result, which may or may not contain the specified data.</returns>
        public virtual IServiceResult<T> Failed<T>(T? data = default, params string[] messages) => CreateResult(data, false, messages);

        [Obsolete("Deprecated: Use ClientMessages instead.")]
        /// <summary>
        /// Creates a failed service result using only failure messages, without explicitly including data.
        /// </summary>
        /// <remarks>
        /// This method provides a convenient way to create a failed service result when the failure does not pertain to any specific data, 
        /// or when the inclusion of data is not necessary to convey the failure reason. The data part of the result will be set to its default value.
        /// </remarks>
        /// <typeparam name="T">The type of data the service result can contain. The result will contain the default value for this type.</typeparam>
        /// <param name="messages">An array of failure messages that provide details about the reasons for the operation's failure.</param>
        /// <returns>A failed service result. The data part of the result will be set to the default value for the specified type, 
        /// and it will include the provided failure messages.</returns>
        public virtual IServiceResult<T> Failed<T>(params string[] messages) => Failed<T>(default, messages);

        #endregion
        #region WITH_ENUM_MESSAGE

        [Obsolete("Deprecated: Use ClientMessages instead.")]
        /// <summary>
        /// Creates a service message with the specified success flag and enumeration messages.
        /// </summary>
        /// <param name="isSuccess">Indicates if the operation was successful.</param>
        /// <param name="messages">An array of enumeration values associated with the operation.</param>
        /// <returns>A new instance of <see cref="ServiceMessage"/> reflecting the operation outcome with enumeration messages.</returns>
        public IServiceMessage CreateMessage(bool isSuccess, params Enum[] messages) => CreateMessage(isSuccess, messages.Select(m => m.ToString()).ToArray());

        [Obsolete("Deprecated: Use ClientMessages instead.")]
        /// <summary>
        /// Creates a service result containing the provided data, success flag, and enumeration messages.
        /// </summary>
        /// <typeparam name="T">The type of the data included in the result.</typeparam>
        /// <param name="data">The data to include in the result.</param>
        /// <param name="isSuccess">Indicates if the operation was successful.</param>
        /// <param name="messages">An array of enumeration values associated with the operation.</param>
        /// <returns>A new instance of <see cref="ServiceResult{T}"/> with the specified data and outcome using enumeration messages.</returns>
        public IServiceResult<T> CreateResult<T>(T? data, bool isSuccess, params Enum[] messages) => CreateResult(data, isSuccess, messages.Select(m => m.ToString()).ToArray());

        [Obsolete("Deprecated: Use ClientMessages instead.")]
        /// <summary>
        /// Creates a successful service message using enumeration messages.
        /// </summary>
        /// <param name="messages">An array of success enumeration values.</param>
        /// <returns>A successful service message.</returns>
        public IServiceMessage Successful(params Enum[] messages) => CreateMessage(true, messages.Select(m => m.ToString()).ToArray());

        [Obsolete("Deprecated: Use ClientMessages instead.")]
        /// <summary>
        /// Creates a failed service message using enumeration messages.
        /// </summary>
        /// <param name="messages">An array of failure enumeration values.</param>
        /// <returns>A failed service message.</returns>
        public IServiceMessage Failed(params Enum[] messages) => CreateMessage(false, messages.Select(m => m.ToString()).ToArray());

        [Obsolete("Deprecated: Use ClientMessages instead.")]
        /// <summary>
        /// Creates a successful service result with the provided data using enumeration messages.
        /// </summary>
        /// <typeparam name="T">The type of data included in the result.</typeparam>
        /// <param name="data">The data to include in the result.</param>
        /// <param name="messages">An array of success enumeration values.</param>
        /// <returns>A successful service result containing the specified data.</returns>
        public IServiceResult<T> Successful<T>(T data, params Enum[] messages) => CreateResult(data, true, messages.Select(m => m.ToString()).ToArray());

        [Obsolete("Deprecated: Use ClientMessages instead.")]
        /// <summary>
        /// Creates a failed service result, optionally including data, using enumeration messages.
        /// </summary>
        /// <typeparam name="T">The type of data the service result can contain.</typeparam>
        /// <param name="data">Optional data to include in the failed result.</param>
        /// <param name="messages">An array of failure enumeration values.</param>
        /// <returns>A failed service result, which may or may not contain the specified data.</returns>
        public IServiceResult<T> Failed<T>(T? data = default, params Enum[] messages) => CreateResult(data, false, messages.Select(m => m.ToString()).ToArray());

        [Obsolete("Deprecated: Use ClientMessages instead.")]
        /// <summary>
        /// Creates a failed service result using only failure messages, without explicitly including data.
        /// </summary>
        /// <typeparam name="T">The type of data the service result can contain. The result will contain the default value for this type.</typeparam>
        /// <param name="messages">An array of failure enumeration values that provide details about the reasons for the operation's failure.</param>
        /// <returns>A failed service result. The data part of the result will be set to the default value for the specified type, 
        /// and it will include the provided failure messages.</returns>
        public IServiceResult<T> Failed<T>(params Enum[] messages) => Failed<T>(default(T), messages);

        #endregion
    }
}