using Microsoft.EntityFrameworkCore;
using Blueprint.Core.Entities;
using Blueprint.Core.Errors;
using Blueprint.Core.Interfaces.SPI;
using Blueprint.Core.Models;
using Blueprint.Infra.Database;
using System.Linq.Expressions;

namespace Blueprint.Infra.Services
{
    public class MySQLItemInfra<T> : IItemInfra<T> where T : BaseEntity
    {
        public readonly DbContext _dbContext;
        public readonly DbSet<T> _dbSet;
        public ILogger _logger;
        public MySQLItemInfra
        (
            MyDbContext dbContext,
            ILogger<MySQLItemInfra<T>> logger
        )
        {
            _dbContext = dbContext;
            _logger = logger;
            _dbSet = _dbContext.Set<T>();
        }
        public async Task AddItemAsync(T item)
        {
            try
            {
                _dbSet.Add(item);
                await _dbContext.SaveChangesAsync();
            }
            catch (Exception)
            {
                _logger.LogError($"Cannot add an item");
                throw Errors.CannotQueryError;
            }
        }

        public async Task DeleteItemsAsync(List<int> ids)
        {
            try
            {
                List<T> items = _dbSet.Where(p => ids.Contains(p.Id)).ToList();
                items.ForEach(i => i.Status = false);
                _dbSet.UpdateRange(items);
                await _dbContext.SaveChangesAsync();
            }
            catch (Exception)
            {
                _logger.LogError($"Cannot delete items");
                throw Errors.CannotQueryError;
            }
        }

        public virtual async Task<T?> GetItemByIdAsync(int id, params Expression<Func<T, object>>[] includes)
        {
            try
            {
                IQueryable<T> query = _dbSet;

                // Apply includes dynamically
                foreach (var include in includes)
                {
                    query = query.Include(include);
                }

                return await query.FirstOrDefaultAsync(p => p.Id == id);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Cannot get item with ID: {Id}", id);
                throw Errors.CannotQueryError;
            }
        }

        public virtual async Task<PagerData<T>> GetItemsAsync(
            PagingParams pagingParams,
            params Expression<Func<T, object>>[] includes)
        {
            try
            {
                int skipValues = (pagingParams.Page - 1) * pagingParams.Per_Page;
                IQueryable<T> query = _dbSet
                    .Where(p => p.Status == true)
                    .OrderByDescending(p => p.Id);

                // Apply includes dynamically
                if (includes != null)
                {
                    foreach (var include in includes)
                    {
                        query = query.Include(include);
                    }
                }

                List<T> items = await query
                    .Skip(skipValues)
                    .Take(pagingParams.Per_Page)
                    .ToListAsync();

                PagerData<T> pagerData = new PagerData<T>
                {
                    Items = items,
                    TotalRecords = (await query.ToListAsync()).Count()
                };

                return pagerData;
            }
            catch (Exception)
            {
                _logger.LogError($"Cannot get items");
                throw Errors.CannotQueryError;
            }
        }

        public async Task UpdateItemAsync(T item)
        {
            try
            {
                _dbSet.Update(item);
                await _dbContext.SaveChangesAsync();
            }
            catch (Exception)
            {
                _logger.LogError($"Cannot update an item");
                throw Errors.CannotQueryError;
            }
        }
    }
}