using System.Text.Json.Serialization;

namespace StockApi.Response
{
    public class ApiResponse<T>
    {
        public int StatusCode { get; set; }
        public string Message { get; set; } = string.Empty;
        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
        public T? Data { get; set; }

        public ApiResponse(int statusCode, string message)
        {
            StatusCode = statusCode;
            Message = message;
        }

        public ApiResponse(int statusCode, string message, T? data)
        {
            StatusCode = statusCode;
            Message = message;
            Data = data;
        }
    }
}

namespace StockApi.Response
{
    public class PaginationResponse<T>
    {
        public int PageNumber { get; init; }
        public int PageSize { get; init; }
        public int TotalRecords { get; init; }
        public int TotalPages { get; init; }
        public bool HasNextPage => PageNumber < TotalPages;
        public bool HasPreviousPage => PageNumber > 1;
        public List<T> Data { get; init; }

        public PaginationResponse(List<T> data, int pageNumber, int pageSize, int totalRecords)
        {
            Data = data;
            PageNumber = pageNumber;
            PageSize = pageSize;
            TotalRecords = totalRecords;
            TotalPages = (int)Math.Ceiling((decimal)totalRecords / (decimal)pageSize);
        }
    }
}

namespace StockApi.Infrastructure.Repositories.Commons
{
    public class BaseFilterQuery<TBaseEntity> :
        IFilterQuery<TBaseEntity>
        where TBaseEntity : BaseEntity
    {
        /// <summary>
        /// Set the Filter Expression of the Query
        /// </summary>
        /// <param name="query">The base query to be executed.</param>
        /// <param name="filters">An object containing the filtering criteria for the query.</param>
        /// <returns>Returns a IQueryable of Entity to execute query.</returns>
        public IQueryable<TBaseEntity> Filter(IQueryable<TBaseEntity> query, Dictionary<string, string> filters)
        {
            foreach (var filter in filters)
            {
                // Product Property
                var property = typeof(TBaseEntity).GetProperty(filter.Key);

                if (property == null || filter.Value == null)
                {
                    // Go to next filter in Dictionary
                    continue;
                }

                // Lambda parameter
                var parameter = Expression.Parameter(typeof(TBaseEntity), "x");
                // Lamda pamaeter + property (x.Property)
                var propertyAccess = Expression.Property(parameter, property);
                // Convert Type Value for the Type in used in Entity
                object convertedValue = ConvertTypeValue(filter, property);
                // Constant Expression
                var constant = Expression.Constant(convertedValue);
                // Define condition filter in query
                Expression condition = SetQueryConditionFilter(property, propertyAccess, constant);
                // Creates the full lamda expression, ex: x => x.Property.Contains(value)
                var lambda = Expression.Lambda<Func<TBaseEntity, bool>>(condition, parameter);
                // Set the lambda in the Where condition
                query = query.Where(lambda);
            }

            return query;
        }

        /// <summary>
        /// Set the query condition based on property type.
        /// </summary>
        /// <param name="property">Entity property type.</param>
        /// <param name="propertyAccess">Entity property.</param>
        /// <param name="constant">Constante expression</param>
        /// <returns>Expression configured to condition based on property type.</returns>
        private static Expression SetQueryConditionFilter(PropertyInfo property, MemberExpression propertyAccess, ConstantExpression constant)
        {
            Expression condition;

            if (property.PropertyType == typeof(string))
            {
                // Set the Contains string method in the lamda expression
                var containsMethod = typeof(string).GetMethod("Contains", new[] { typeof(string) })!;
                // Ex: x.Property.Contains(value)
                condition = Expression.Call(propertyAccess, containsMethod, constant);
            }
            else if (property.PropertyType == typeof(DateTimeOffset))
            {
                DateTimeOffset startDate = DateTimeOffset.Parse(constant.Value!.ToString()!).Date;
                DateTimeOffset endDate = startDate.AddDays(1);

                // Set DateTime query based on interval of time
                condition = Expression.AndAlso(
                    Expression.GreaterThanOrEqual(propertyAccess, Expression.Constant(startDate)),
                    Expression.LessThan(propertyAccess, Expression.Constant(endDate))
                );
            }
            else
            {
                // Set the Equals method in the lamda expression
                condition = Expression.Equal(propertyAccess, constant);
            }

            return condition;
        }

        /// <summary>
        /// Convert value type based on entity property type.
        /// </summary>
        /// <param name="filters">An object containing the filtering criteria for the query.</param>
        /// <param name="property">PropertyInfo of entity.</param>
        /// <returns>Object type of entity property.</returns>
        private static object ConvertTypeValue(KeyValuePair<string, string> filter, PropertyInfo property)
        {
            if (property.PropertyType.IsEnum)
            {
                return Enum.Parse(property.PropertyType, filter.Value, true);
            }

            if (property.PropertyType == typeof(DateTimeOffset))
            {
                return DateTimeOffset.Parse(filter.Value);
            }

            if (property.PropertyType == typeof(Guid))
            {
                return Guid.Parse(filter.Value);
            }

            return Convert.ChangeType(filter.Value, property.PropertyType);
        }
    }
}

namespace StockApi.Infrastructure.Repositories.Commons
{
    public class BasePaginationQuery<TBaseEntity, TDto> :
        BaseFilterQuery<TBaseEntity>,
        IPaginationQuery<TDto>,
        IFilterQuery<TBaseEntity>
        where TBaseEntity : BaseEntity
        where TDto : BaseDto, new()
    {
        protected readonly AppDbContext _context;
        protected readonly DbSet<TBaseEntity> _dbSet;

        public BasePaginationQuery(AppDbContext context)
        {
            _context = context;
            _dbSet = _context.Set<TBaseEntity>();
        }

        /// <summary>
        /// Returns records in a pagination structure, based on the filter
        /// </summary>
        /// <param name="pageNumber">The number of the page to retrieve (starting from 1).</param>
        /// <param name="pageSize">The number of records per page.</param>
        /// <param name="filters">An object containing the filtering criteria for the query.</param>
        /// <returns>Returns a PaginationResponse with records that match the specified filters.</returns>
        public async Task<PaginationResponse<TDto>> Pagination(int pageNumber, int pageSize, Dictionary<string, string>? filters)
        {
            var query = _dbSet.AsQueryable();

            if (filters is not null)
            {
                query = this.Filter(query, filters);
            }

            var totalRecords = await query.CountAsync();
            var records = await ExecuteQuery(query, pageNumber, pageSize);
            return new PaginationResponse<TDto>(records, pageNumber, pageSize, totalRecords);
        }

        /// <summary>
        /// Convert the Entity to his DTO
        /// </summary>
        /// <returns>Lambda exression which convert Entity to DTO</returns>
        protected virtual Expression<Func<TBaseEntity, TDto>> ConvertToDto()
        {
            return x => (TDto)new TDto().ConvertToDto(x);
        }

        /// <summary>
        /// Executes a paginated query against the provided IQueryable source and converts the results to DTOs.
        /// </summary>
        /// <param name="query">The base query to be executed.</param>
        /// <param name="pageNumber">The number of the page to retrieve (starting from 1).</param>
        /// <param name="pageSize">The number of records to include per page.</param>
        /// <returns>A task that represents the asynchronous operation, containing a paginated list of DTOs.</returns>
        protected virtual async Task<List<TDto>> ExecuteQuery(IQueryable<TBaseEntity> query, int pageNumber, int pageSize)
        {
            return await query
                .AsNoTracking()
                .Select(ConvertToDto())
                .Skip((pageNumber - 1) * pageSize)
                .Take(pageSize)
                .ToListAsync();
        }
    }
}