using System.Linq.Expressions;
using MongoDB.Bson;
using MongoDB.Driver;
using MongoRepository;

namespace CommonService
{
    public class MongoBaseService<TDocument> : IMongoBaseService<TDocument> where TDocument : MongoBaseEntity, new()
    {
        public IMongoBaseRepository<TDocument> baseDal;

        public virtual IQueryable<TDocument> AsQueryable()
        {
            return baseDal.AsQueryable();
        }

        public virtual IEnumerable<TDocument> FilterBy(
            Expression<Func<TDocument, bool>> filterExpression)
        {
            return baseDal.FilterBy(filterExpression);
        }

        public virtual IEnumerable<TProjected> FilterBy<TProjected>(
            Expression<Func<TDocument, bool>> filterExpression,
            Expression<Func<TDocument, TProjected>> projectionExpression)
        {
            return baseDal.FilterBy(filterExpression, projectionExpression);
        }

        public virtual TDocument FindOne(Expression<Func<TDocument, bool>> filterExpression)
        {
            return baseDal.FindOne(filterExpression);
        }

        public virtual async Task<TDocument> FindOneAsync(Expression<Func<TDocument, bool>> filterExpression)
        {
            return await baseDal.FindOneAsync(filterExpression);
        }

        public virtual TDocument FindById(string id)
        {
            return baseDal.FindById(id);
        }

        public virtual async Task<TDocument> FindByIdAsync(string id)
        {
            return await baseDal.FindByIdAsync(id);
        }

        public virtual (long count, List<TDocument> list) QueryPage(Expression<Func<TDocument, bool>> filterExpression, Expression<Func<TDocument, object>> orderExpression, bool desc, int pageSize, int pageIndex)
        {
            return baseDal.QueryPage(filterExpression, orderExpression, desc, pageSize, pageIndex);
        }
        public virtual async Task<(long count, List<TDocument> list)> QueryPageAsync(Expression<Func<TDocument, bool>> filterExpression, Expression<Func<TDocument, object>> orderExpression, bool desc, int pageSize, int pageIndex)
        {

            return await baseDal.QueryPageAsync(filterExpression, orderExpression, desc, pageSize, pageIndex);
        }

        public virtual (bool ok, string message) InsertOne(TDocument document)
        {
            return baseDal.InsertOne(document);
        }       

        public virtual async Task<(bool ok, string message)> InsertOneAsync(TDocument document)
        {
            return await baseDal.InsertOneAsync(document);
        }

        public (bool ok, string message) InsertMany(ICollection<TDocument> documents)
        {
            return baseDal.InsertMany(documents);
        }

        public virtual async Task<(bool ok, string message)> InsertManyAsync(ICollection<TDocument> documents)
        {
            return await baseDal.InsertManyAsync(documents);
        }

        public virtual (bool ok, string message) UpdateById(string id, UpdateDefinition<TDocument> updateDefinition)
        {
            return baseDal.UpdateById(id, updateDefinition);
        }
        public virtual async Task<(bool ok, string message)> UpdateByIdAsync(string id, UpdateDefinition<TDocument> updateDefinition)
        {
            return await baseDal.UpdateByIdAsync(id, updateDefinition);
        }

        public virtual (bool ok, string message) UpdateMany(Expression<Func<TDocument, bool>> filterExpression, UpdateDefinition<TDocument> updateDefinition)
        {
            return baseDal.UpdateMany(filterExpression, updateDefinition);
        }
        public virtual async Task<(bool ok, string message)> UpdateManyAsync(Expression<Func<TDocument, bool>> filterExpression, UpdateDefinition<TDocument> updateDefinition)
        {
            return await baseDal.UpdateManyAsync(filterExpression, updateDefinition);
        }

        public (bool ok, string message) ReplaceOne(TDocument document)
        {
            return baseDal.ReplaceOne(document);
        }

        public virtual async Task<(bool ok, string message)> ReplaceOneAsync(TDocument document)
        {
            return await baseDal.ReplaceOneAsync(document);
        }

        public (bool ok, string message) DeleteOne(Expression<Func<TDocument, bool>> filterExpression)
        {
            return baseDal.DeleteOne(filterExpression);
        }

        public async Task<(bool ok, string message)> DeleteOneAsync(Expression<Func<TDocument, bool>> filterExpression)
        {
            return await baseDal.DeleteOneAsync(filterExpression);
        }

        public (bool ok, string message) DeleteById(string id)
        {
            return baseDal.DeleteById(id);
        }

        public async Task<(bool ok, string message)> DeleteByIdAsync(string id)
        {

            return await baseDal.DeleteByIdAsync(id);
        }

        public (bool ok, string message) DeleteMany(Expression<Func<TDocument, bool>> filterExpression)
        {
            return baseDal.DeleteMany(filterExpression);
        }

        public async Task<(bool ok, string message)> DeleteManyAsync(Expression<Func<TDocument, bool>> filterExpression)
        {
            return await baseDal.DeleteManyAsync(filterExpression);
        }
        public async Task<List<BsonDocument>> Aggregate(FilterDefinition<TDocument> filterExpression, ProjectionDefinition<TDocument, BsonDocument> group)
        {
            return await baseDal.Aggregate(filterExpression, group);
        }

    }
}