using Entity;
using Microsoft.EntityFrameworkCore;
using Shared;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Contextlib
{
    public class DbCharacterManager : ICharacterService<Character>
    {
        private WTFContext _context;

        /// <summary>
        /// Initializes a new instance of the <see cref="DbCharacterManager"/> class.
        /// </summary>
        /// <param name="context">The <see cref="WTFContext"/> instance used to interact with the database.</param>
        public DbCharacterManager(WTFContext context)
        {
            _context = context ?? throw new ArgumentNullException(nameof(context), "Database context cannot be null.");
        }

        /// <summary>
        /// Adds a new character to the database.
        /// </summary>
        /// <param name="character">The character to be added to the database.</param>
        /// <returns>A task that represents the asynchronous operation.</returns>
        /// <exception cref="ArgumentNullException">Thrown when the provided character is null.</exception>
        public async Task AddCharacter(Character character)
        {
            if (character == null)
            {
                throw new ArgumentNullException(nameof(character), "Character cannot be null.");
            }

            await _context.AddAsync(character);
            await _context.SaveChangesAsync();
        }

        /// <summary>
        /// Retrieves all characters from the database and returns them in a paginated format.
        /// </summary>
        /// <returns>A task representing the asynchronous operation, with a <see cref="PaginationResult{Character}"/> as its result containing the full list of characters and pagination information.</returns>
        public Task<PaginationResult<Character>> GetAll()
        {
            List<Character> charLst = _context.characters.ToList();

            return Task.FromResult(new PaginationResult<Character>(
                charLst.Count,  // Total count of characters in the database
                0,              // Current page (in this case, no pagination logic implemented)
                charLst.Count,  // Total number of items (same as count for no pagination)
                charLst         // The list of characters
            ));
        }

        /// <summary>
        /// Retrieves a character by its ID from the database.
        /// </summary>
        /// <param name="id">The unique identifier of the character to retrieve.</param>
        /// <returns>A task that represents the asynchronous operation, with a <see cref="Character"/> as its result.</returns>
        /// <exception cref="KeyNotFoundException">Thrown when no character is found with the given ID.</exception>
        public async Task<Character> GetCharById(int id)
        {
            Character? character = await _context.characters
                .FirstOrDefaultAsync(x => x.Id == id);

            if (character == null)
            {
                throw new KeyNotFoundException($"Error : No character found with the ID: {id}.");
            }

            return character;
        }

        /// <summary>
        /// Retrieves a character by its name from the database.
        /// </summary>
        /// <param name="name">The name of the character to retrieve.</param>
        /// <returns>A task that represents the asynchronous operation, with a <see cref="Character"/> as its result.</returns>
        /// <exception cref="KeyNotFoundException">Thrown when no character is found with the given name.</exception>
        public async Task<Character> GetCharByName(string name)
        {
            Character? character = await _context.characters
                .FirstOrDefaultAsync(x => x.Name.Equals(name, StringComparison.OrdinalIgnoreCase));

            if (character == null)
            {
                throw new KeyNotFoundException($"Error : No character found with the name: {name}.");
            }

            return character;
        }

        /// <summary>
        /// Retrieves the highest character ID from the database.
        /// </summary>
        /// <returns>The highest character ID in the database. 0 if there is no character in the database</returns>
        public async Task<int> GetLastCharId()
        {
            int id = await _context.characters
                .OrderByDescending(x => x.Id)
                .Select(x => x.Id)
                .FirstOrDefaultAsync();
            return id;
        }

        /// <summary>
        /// Removes a character from the database by its ID.
        /// </summary>
        /// <param name="id">The ID of the character to remove.</param>
        /// <returns>A task representing the asynchronous operation.</returns>
        /// <exception cref="KeyNotFoundException">Thrown when no character is found with the given ID.</exception>
        public async Task RemoveCharacter(int id)
        {
            Character? character = await _context.characters.FirstOrDefaultAsync(x => x.Id == id);
            if (character == null)
            {
                throw new KeyNotFoundException($"Error : Unable to delete, no character found with the ID: {id}.");
            }

            _context.characters.Remove(character);
            await _context.SaveChangesAsync();
        }

        /// <summary>
        /// Updates a character's details by its ID.
        /// </summary>
        /// <param name="id">The ID of the character to update.</param>
        /// <param name="character">The updated character information.</param>
        /// <returns>A task representing the asynchronous operation.</returns>
        /// /// <exception cref="ArgumentNullException">Thrown when the provided character is null.</exception>
        /// <exception cref="KeyNotFoundException">Thrown when no character is found with the given ID.</exception>
        public async Task UpdateCharacter(int id, Character character)
        {
            if (character == null)
            {
                throw new ArgumentNullException(nameof(character), "The updated character data cannot be null.");
            }

            Character? charUpdated = await _context.characters.FirstOrDefaultAsync(x => x.Id == id);
            if (charUpdated == null)
            {
                throw new KeyNotFoundException($"Error : Unable to update, no character found with the ID:  {id} .");
            }

            charUpdated.IdImage = character.IdImage;
            charUpdated.Name = character.Name;

            await _context.SaveChangesAsync();
        }
    }
}