public  interface IDataBaseCore
    {
    }

public class BasicData : IDataBaseCore
    {
    }

public class Filter
    {
        public string Key { set; get; }

        public string Value { set; get; }

    }

/// <summary>
    /// 数据Context接口
    /// </summary>
    public interface IDataContext<T> where T : class
    {
        /// <summary>
        /// 客户端数据连接访问器
        /// </summary>
        T DbContext { set; get; }

    }

 public interface IDataBase<T> : IDataContext<MongoClient> where T : IDataBaseCore
    {
        /// <summary>
        /// 数据库
        /// </summary>
        IMongoDatabase DataBase { get;}
    }

public class MongodbContext<T> : IDataBase<T> where T : IDataBaseCore
    {
        public MongodbContext()
        {

        }

        public MongoClient DbContext { set; get; } = new MongoClient(new ConfigSetting().Mongodb);

        public IMongoDatabase DataBase { get => DbContext.GetDatabase(typeof(T).Name); }

        #region 具体的表操作
        /// <summary>
        /// 系统菜单
        /// </summary>
        public IMongoCollection<SysMenu> SysMenus { get => DbSet<SysMenu>(); }

        /// <summary>
        /// 用户
        /// </summary>
        public IMongoCollection<User> Users { set; get; }

        #endregion

        public IMongoCollection<K> DbSet<K>() where K : ICore => DataBase.GetCollection<K>(typeof(K).Name);

    }

    public static class MongodbExpansion
    {
        /// <summary>
        /// 单个对象添加
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="collection"></param>
        /// <param name="entity"></param>
        public static void Add<T>(this IMongoCollection<T> collection, T entity) where T : ICore
            => collection.InsertOne(entity);

        /// <summary>
        /// 单个对象异步操作
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="collection"></param>
        /// <param name="entity"></param>
        /// <returns></returns>
        public static async Task AddAsync<T>(this IMongoCollection<T> collection, T entity) where T : ICore
            => await collection.InsertOneAsync(entity);

        /// <summary>
        /// 集合添加
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="collection"></param>
        /// <param name="entitys"></param>
        public static void AddRange<T>(this IMongoCollection<T> collection, List<T> entitys) where T : ICore
            => collection.InsertMany(entitys);

        /// <summary>
        /// 集合异步操作
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="collection"></param>
        /// <param name="entitys"></param>
        public static void AddRangeAsync<T>(this IMongoCollection<T> collection, List<T> entitys) where T : ICore
           => collection.InsertManyAsync(entitys);
        /// <summary>
        /// entity mongodb需要更新的实体 properts需要更新的集合属性,大小写不限 默认更新整个对象 replace 默认空属性不修改
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="collection"></param>
        /// <param name="entity">mongodb需要更新的实体</param>
        /// <param name="properts">需要更新的集合属性,大小写不限 默认更新整个对象 </param>
        /// <param name="replace">默认空属性不修改</param>
        public static void Update<T>(this IMongoCollection<T> collection, T entity, List<string> properts = null, bool replace = false) where T : ICore
        {
            if (entity == null)
                throw new NullReferenceException();

            var type = entity.GetType();
            ///修改的属性集合
            var list = new List<UpdateDefinition<T>>();

            foreach (var propert in type.GetProperties())
            {
                if (propert.Name.ToLower() != "id")
                {
                     || properts.Any(o => o.ToLower() == propert.Name.ToLower()))
                    {
                        var replaceValue = propert.GetValue(entity);
                        if (replaceValue != null)
                            list.Add(Builders<T>.Update.Set(propert.Name, replaceValue));
                        else if (replace)
                            list.Add(Builders<T>.Update.Set(propert.Name, replaceValue));
                    }
                }
            }
            #region 有可修改的属性
            )
            {
                var builders = Builders<T>.Update.Combine(list);

                collection.UpdateOne(o => o.Id == entity.Id, builders);
            }
            #endregion

        }

        /// <summary>
        /// 异步等同Update方法
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="collection"></param>
        /// <param name="entity"></param>
        /// <param name="properts"></param>
        /// <param name="replace"></param>
        /// <returns></returns>
        public static async Task UpdateAsync<T>(this IMongoCollection<T> collection, T entity, List<string> properts = null, bool replace = false) where T : ICore
        {
            if (entity == null)
                throw new NullReferenceException();

            var type = entity.GetType();
            ///修改的属性集合
            var list = new List<UpdateDefinition<T>>();

            foreach (var propert in type.GetProperties())
            {
                if (propert.Name.ToLower() != "id")
                {
                     || properts.Any(o => o.ToLower() == propert.Name.ToLower()))
                    {
                        var replaceValue = propert.GetValue(entity);
                        if (replaceValue != null)
                            list.Add(Builders<T>.Update.Set(propert.Name, replaceValue));
                        else if (replace)
                            list.Add(Builders<T>.Update.Set(propert.Name, replaceValue));
                    }
                }
            }
            #region 有可修改的属性
            )
            {
                var builders = Builders<T>.Update.Combine(list);

                await collection.UpdateOneAsync(o => o.Id == entity.Id, builders);
            }
            #endregion

        }

        public static void Remove<T>(this IMongoCollection<T> collection, T entity) where T : ICore
            => collection.DeleteOne(o => o.Id == entity.Id);

        public static void RemoveById<T>(this IMongoCollection<T> collection, string id) where T : ICore
           => collection.DeleteOne(Builders<T>.Filter.Eq("Id", id));

        public static async Task RemoveAsync<T>(this IMongoCollection<T> collection, T entity) where T : ICore
            => await collection.DeleteOneAsync(o => o.Id == entity.Id);

        public static async Task RemoveAsyncById<T>(this IMongoCollection<T> collection, string id) where T : ICore
           => await collection.DeleteOneAsync(Builders<T>.Filter.Eq("Id", id));

        public static FilterDefinition<T> CombineToFilter<T>(this List<FilterDefinition<T>> list)
            => Builders<T>.Filter.And(list);

        public static void RemoveRange<T>(this IMongoCollection<T> collection, List<T> entitys) where T : ICore
        {
            )
                throw new NullReferenceException();
            collection.DeleteMany(Builders<T>.Filter.In("Id", entitys.Select(o => o.Id)));
        }

        public static async Task RemoveRangeAsync<T>(this IMongoCollection<T> collection, List<T> entitys) where T : ICore
        {
            )
                throw new NullReferenceException();
            await collection.DeleteManyAsync(Builders<T>.Filter.In("Id", entitys.Select(o => o.Id)));
        }

        public static T FindDefault<T>(this IMongoCollection<T> collection, string Id) where T : ICore
            => collection.Find(o => o.Id == Id).FirstOrDefault();

        public static IList<T> FindAll<T>(this IMongoCollection<T> collection, bool sort = false) where T : ICore
           => sort ? collection.Find(Builders<T>.Filter.Empty).SortBy(o => o.CreateTime).ToList() : collection.Find(Builders<T>.Filter.Empty).ToList();

        public static IList<T> FindAllSort<T>(this IMongoCollection<T> collection, Expression<Func<T, object>> sort = null) where T : ICore
           => sort == null ? collection.Find(Builders<T>.Filter.Empty).ToList() : collection.Find(Builders<T>.Filter.Empty).SortBy(sort).ToList();

        public static IFindFluent<T, T> FindDefault<T>(this IMongoCollection<T> collection) where T : ICore
           => collection.Find(Builders<T>.Filter.Empty);

        public static IFindFluent<T, T> Where<T>(this IMongoCollection<T> collection, Expression<Func<T, bool>> where) where T : ICore
          => where == null ? collection.Find(Builders<T>.Filter.Empty) : collection.Find(where);

        public static IFindFluent<TDocument, TNewProjection> Select<TDocument, TProjection, TNewProjection>(this IFindFluent<TDocument, TProjection> IQueryable, Expression<Func<TDocument, TNewProjection>> projection)
           => IQueryable.Project(projection);

        public static IFindFluent<TDocument, TNewProjection> PageSize<TDocument, TNewProjection>(this IFindFluent<TDocument, TNewProjection> IQueryable, Search search)
        => IQueryable.Skip((search.Args.PageIndex - ) * search.Args.PageSize).Limit(search.Args.PageSize);
    }

 public interface IRepository<T> where T : ICore
    {

        /// <summary>
        /// 查询单个对象
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        T FindById(string id);

        /// <summary>
        /// 查询单个对象
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        T FirstOrDefault(System.Linq.Expressions.Expression<Func<T, bool>> where);

        IFindFluent<T, T> FindFiter(FilterDefinition<T> filter);

        /// <summary>
        /// 获取所有
        /// </summary>
        /// <returns></returns>
        IList<T> GetList();

        /// <summary>
        /// 根据条件查询所有
        /// </summary>
        /// <param name="where"></param>
        /// <returns></returns>
        IList<T> GetList(System.Linq.Expressions.Expression<Func<T, bool>> where);

        IList<T> GetListOrderBy();

        /// <summary>
        /// 单个实体
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        void Insert(T entity);

        /// <summary>
        /// 批量添加
        /// </summary>
        /// <param name="entitys"></param>
        /// <returns></returns>
        void BulkInsert(List<T> entitys);

        /// <summary>
        /// 修改单个实体
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        void Update(T entity);

        /// <summary>
        /// 批量修改
        /// </summary>
        /// <param name="entitys"></param>
        /// <returns></returns>
        void BulkUpdate(List<T> entitys);

        Result AddResultEntity(T t);

        Result UpdateResultEntity(T t, List<string> propertys = null, bool replace = false);

        Result RemoveResultEntity(T t);

        FilterDefinition<T> ConverToFilter(Filter filter);

        PageArgs GetPageArgs(Search search);
    }

   public abstract class Repository<T, K> : IRepository<K> where T : IDataBaseCore where K : ICore
    {
        public Repository()
        {
            if (MongodbContext == null)
                MongodbContext = new MongodbContext<T>();
        }

        protected IMongoCollection<K> Collection { get => MongodbContext.DbSet<K>(); }

        protected FilterDefinition<K> FilterEmpty { set; get; } = Builders<K>.Filter.Empty;

        protected static MGDataChannel.Realize.MongodbContext<T> MongodbContext { set; get; }

        public K FindById(string id)
        => MongodbContext.DbSet<K>().FindDefault(id);

        public K FirstOrDefault(Expression<Func<K, bool>> where)
        => MongodbContext.DbSet<K>().Find(where).FirstOrDefault();

        public IFindFluent<K, K> FindFiter(FilterDefinition<K> filter)
        => MongodbContext.DbSet<K>().Find(filter);

        public async Task<IAsyncCursor<K>> FindFiterAsync(FilterDefinition<K> filter)
        => await MongodbContext.DbSet<K>().FindAsync(filter);

        public virtual IList<K> GetList()
        => MongodbContext.DbSet<K>().Find(Builders<K>.Filter.Empty).ToList();

        public virtual IList<K> GetListOrderBy()
       => MongodbContext.DbSet<K>().Find(Builders<K>.Filter.Empty).SortBy(o => o.CreateTime).ToList();

        public virtual IList<K> GetList(Expression<Func<K, bool>> where)
        => MongodbContext.DbSet<K>().Find(where).ToList();

        public virtual FilterDefinition<K> ConverToFilter(Filter filter)
        {
            if (!string.IsNullOrEmpty(filter.Value))
            {
                if (filter.Key.ToLower() == "id")
                    return Builders<K>.Filter.Eq("Id", filter.Value);
                else if (filter.Key.ToLower() == "name")
                    return Builders<K>.Filter.Where(o => o.Name.Contains(filter.Value.ToString()));
                else if (filter.Key.ToLower() == "stardate")
                    return Builders<K>.Filter.Gte("StarDate", Convert.ToDateTime(filter.Value));//$gte
                else if (filter.Key.ToLower() == "enddate")
                    return Builders<K>.Filter.Lte("EndDate", Convert.ToDateTime(filter.Value));//$gte
            }
            return Builders<K>.Filter.Empty;
        }

        protected virtual FilterDefinition<K> GetFilters(Search search, Func<Filter, FilterDefinition<K>> fun)
        {
            var filters = new List<FilterDefinition<K>>();
            search.Filters.ForEach(o =>
            {
                filters.Add(fun(o));
            });
            )
                return Builders<K>.Filter.Empty;
            ///过滤条件合并
            var filter = filters.CombineToFilter();

            return filter;
        }

        public virtual void Insert(K entity)
        => MongodbContext.DbSet<K>().Add(entity);

        public virtual void BulkInsert(List<K> entitys)
        => MongodbContext.DbSet<K>().AddRange(entitys);

        public virtual void Update(K entity)
        => MongodbContext.DbSet<K>().Update(entity);

        public virtual void Update(K entity, List<string> propertys = null, bool replace = false)
        => MongodbContext.DbSet<K>().Update(entity, propertys, replace);

        public virtual void BulkUpdate(List<K> entitys)
        {
            throw new NotImplementedException();
        }

        public virtual Result AddResultEntity(K t)
        {
            Insert(t);
            return new Result(true, t, "");
        }

        public virtual Result UpdateResultEntity(K t, List<string> propertys = null, bool replace = false)
        {
            Update(t, propertys, replace);
            return new Result(true, t, "");
        }

        public virtual Result RemoveResultEntity(K t)
        {
            throw new NotImplementedException();
        }

        public virtual PageArgs GetPageArgs(Search search)
        {
            ///获取过滤条件
            var filter = this.GetFilters(search, this.ConverToFilter);

            var query = this.FindFiter(filter);

            ///总记录数
            int recordCount = (int)query.Count();

            PageArgs args = new PageArgs(recordCount, search.Args.PageIndex, search.Args.PageSize);

            )
            {
                var data = query.PageSize(search).ToList();
                args.Data = data;
            }
            return args;
        }
    }