using Microsoft.Extensions.Logging;
using MongoDB.Driver;
using Shared.Core.Entities;
using Shared.Core.Exceptions;
using Shared.Core.Interfaces.SPI;
using Shared.Core.Shared.Models;
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Text;

namespace Shared.Infrastructure.Services.Mongo
{
    public class MongoItemInfra<T> : IItemInfra<T> where T : BaseEntity
    {
        public readonly IMongoCollection<T> _dbSet;
        public readonly ILogger<MongoItemInfra<T>> _logger;

        public MongoItemInfra(
            IMongoDatabase database,
            ILogger<MongoItemInfra<T>> logger)
        {
            _dbSet = database.GetCollection<T>(typeof(T).Name.ToLower());
            _logger = logger;
        }
        public async Task AddItemAsync(T item)
        {
            try
            {
                await _dbSet.InsertOneAsync(item);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error while adding an item.");
                throw Errors.CannotQueryError;
            }
        }

        public async Task DeleteItemsAsync(List<Guid> ids)
        {
            try
            {
                // Build a filter to match all the IDs in the list
                var filter = Builders<T>.Filter.In("Id", ids);

                // Delete all matching documents
                var result = await _dbSet.DeleteManyAsync(filter);
                _logger.LogInformation($"Deleted {result.DeletedCount} items with the provided IDs.");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"Error while deleting items with IDs: {string.Join(", ", ids)}");
                throw Errors.CannotQueryError;
            }
        }

        public async Task<T> GetItemByIdAsync(Guid id, params Expression<Func<T, object>>[] includes)
        {
            try
            {
                return await _dbSet.Find(Builders<T>.Filter.Eq("Id", id)).FirstOrDefaultAsync();
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"Error while fetching item with Id {id}");
                throw Errors.CannotQueryError;
            }
        }

        public async Task<PagerData<T>> GetItemsAsync(
            PagingParams pagingParams,
            params Expression<Func<T, object>>[] includes)
        {
            try
            {
                int skipValues = (pagingParams.Page - 1) * pagingParams.Per_Page;
                var filter = Builders<T>.Filter.Empty;

                var totalRecords = await _dbSet.CountDocumentsAsync(filter);
                var items = await _dbSet
                    .Find(filter)
                    .Sort(Builders<T>.Sort.Descending("Id")) // Sort by descending Id, adjust field as needed
                    .Skip(skipValues)
                    .Limit(pagingParams.Per_Page)
                    .ToListAsync();

                return new PagerData<T>
                {
                    Items = items,
                    TotalRecords = (int)totalRecords
                };
            }
            catch (Exception ex)
            {
                // You can add logging here if needed
                throw Errors.CannotQueryError;
            }
        }

        public async Task UpdateItemAsync(T item)
        {
            try
            {
                var id = typeof(T).GetProperty("Id")?.GetValue(item);
                if (id == null)
                    throw Errors.CannotFindTheItem;

                await _dbSet.ReplaceOneAsync(Builders<T>.Filter.Eq("Id", id), item);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error while updating an item.");
                throw Errors.CannotQueryError;
            }
        }
    }
}