using Microsoft.EntityFrameworkCore;
using Models.Interfaces;
using Domain.Entities;
using Models.Helpers;
using Models.Models;

namespace Models.Repositories
{
    public class PhSProductCategoryRepository(PhronCareOperationsHubContext context) : IPhSProductCategoryRepository
    {
        #region Declaraciones y Constructor
        private readonly PhronCareOperationsHubContext _context = context;
        #endregion
        #region Metodos de clase
        public async Task<IEnumerable<EProductCategory>> GetAllAsync()
        {
            var businessUnits = await _context.PhSProductCategories.ToListAsync();
            return businessUnits.Select(EntityMapper.MapEntity<PhSProductCategory, EProductCategory>);
        }
        public async Task<EProductCategory?> GetByIdAsync(int id)
        {
            var entity = await _context.PhSProductCategories.FindAsync(id);
            return entity is null ? null : EntityMapper.MapEntity<PhSProductCategory, EProductCategory>(entity);
        }
        public async Task<IEnumerable<EProductCategory>> SearchAsync(string term)
        {
            var query = _context.PhSProductCategories.AsQueryable();
            if (!string.IsNullOrWhiteSpace(term))
            {
                term = term.ToLower();
                query = query.Where(x =>
                    x.Description.ToLower().Contains(term) ||
                    x.Name.ToLower().Contains(term));
            }

            var result = await query.ToListAsync();
            return result.Select(EntityMapper.MapEntity<PhSProductCategory, EProductCategory>);
        }
        public async Task<EProductCategory> CreateAsync(EProductCategory unit)
        {
            if (unit == null) throw new ArgumentNullException(nameof(unit), "La categoria no puede ser nula.");
            try
            {
                var category = EntityMapper.MapEntity<EProductCategory, PhSProductCategory>(unit);

                await _context.PhSProductCategories.AddAsync(category);
                await _context.SaveChangesAsync();
                return EntityMapper.MapEntity<PhSProductCategory, EProductCategory>(category);
            }
            catch (DbUpdateException dbEx)
            {
                // Error relacionado con la base de datos (como violación de integridad referencial)
                throw new Exception("Error al guardar la categoria en la base de datos. Es posible que haya un problema con la integridad de los datos.", dbEx);
            }
            catch (Exception ex)
            {
                // Captura cualquier otro tipo de excepción
                throw new Exception("Error inesperado al crear la categoria: " + ex.Message, ex);
            }
        }
        public async Task<bool> UpdateAsync(EProductCategory category)
        {
            if (category == null || category.Id <= 0)
                throw new ArgumentNullException(nameof(category), "La categoría no puede ser nula o tener un ID inválido.");

            var existingCategory = await _context.PhSProductCategories
                .FirstOrDefaultAsync(c => c.Id == category.Id);

            if (existingCategory == null)
                return false;

            EntityMapper.MapEntityToExisting(category, existingCategory);
            await _context.SaveChangesAsync();
            return true;
        }
        public async Task<bool> DeleteAsync(int id)
        {
            var entity = await _context.PhSProductCategories.FindAsync(id);
            if (entity != null)
            {
                _context.PhSProductCategories.Remove(entity);
                await _context.SaveChangesAsync();
            }
            return true;
        }
        #endregion
    }
}