using AutoMapper;
using Microsoft.Extensions.Logging;
using DigitalData.Core.Abstraction.Application.DTO;
using DigitalData.Core.Abstraction.Application.Repository;
using DigitalData.Core.Abstraction.Application;

namespace DigitalData.Core.Application
{
    /// <summary>
    /// Provides generic CRUD (Create, Read, Update, Delete) operations for a specified type of entity.
    /// </summary>
    /// <typeparam name="TCreateDto">The DTO type for create operations.</typeparam>
    /// <typeparam name="TReadDto">The DTO type for read operations.</typeparam>
    /// <typeparam name="TEntity">The entity type.</typeparam>
    /// <typeparam name="TId">The type of the identifier for the entity.</typeparam>
    /// 
    [Obsolete("Use MediatR")]
    public class CRUDService<TCRUDRepository, TCreateDto, TReadDto, TEntity, TId> : ReadService<TCRUDRepository, TReadDto, TEntity, TId>, ICRUDService<TCreateDto, TReadDto, TEntity, TId>
        where TCRUDRepository : ICRUDRepository<TEntity, TId> where TCreateDto : class where TReadDto : class where TEntity : class
    {

        /// <summary>
        /// Initializes a new instance of the CRUDService class with the specified repository, translation service, and mapper.
        /// </summary>
        /// <param name="repository">The CRUD repository for accessing the database.</param>
        /// <param name="mapper">The AutoMapper instance for mapping between DTOs and entity objects.</param>
        public CRUDService(TCRUDRepository repository, IMapper mapper) : base(repository: repository, mapper: mapper)
        {
        }

        /// <summary>
        /// Asynchronously creates an entity based on the provided create DTO.
        /// </summary>
        /// <param name="createDto">The DTO to create an entity from.</param>
        /// <returns>A service result indicating success or failure, including the entity DTO.</returns>
        public virtual async Task<DataResult<TReadDto>> CreateAsync(TCreateDto createDto)
        {
            var entity = _mapper.Map<TEntity>(createDto);
            var createdEntity = await _repository.CreateAsync(entity);
            var dto = _mapper.Map<TReadDto>(createdEntity);
            return createdEntity is null ? Result.Fail<TReadDto>() : Result.Success(dto);
        }

        /// <summary>
        /// Asynchronously updates an entity based on the provided update DTO.
        /// </summary>
        /// <param name="updateDto">The DTO to update an entity from.</param>
        /// <returns>A service message indicating success or failure.</returns>
        public virtual async Task<Result> UpdateAsync<TUpdateDto>(TUpdateDto updateDto)
        {
            var currentEntitiy = await _repository.ReadByIdAsync(updateDto.GetId<TId>());

            if (currentEntitiy is null)
                return Result.Fail().Notice(LogLevel.Warning, Flag.NotFound, $"{updateDto.GetIdOrDefault<TId>()} is not found in update process of {GetType()} entity.");
    
            var entity = _mapper.Map(updateDto, currentEntitiy);

            return await _repository.UpdateAsync(entity) 
                ? Result.Success() 
                : Result.Fail();
        }
    }
}