using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Linq;
using System.Linq.Expressions;
using System.Threading;
using System.Threading.Tasks;
using Moq;

namespace Tests
{
    internal static class DbSetMock
    {
        private class AsyncEnumerator<T> : IDbAsyncEnumerator<T>
        {
            private readonly IEnumerator<T> _inner;
            public AsyncEnumerator(IEnumerator<T> inner)
            {
                _inner = inner;
            }
            public void Dispose() => _inner.Dispose();
            public Task<bool> MoveNextAsync(CancellationToken cancellationToken) => Task.FromResult(_inner.MoveNext());
            public T Current => _inner.Current;
            object IDbAsyncEnumerator.Current => Current;
        }

        class AsyncEnumerable<T> : EnumerableQuery<T>, IDbAsyncEnumerable<T>, IQueryable<T>
        {
            public AsyncEnumerable(Expression expression) : base(expression) { }
            public IDbAsyncEnumerator<T> GetAsyncEnumerator() => new AsyncEnumerator<T>(this.AsEnumerable().GetEnumerator());
            IDbAsyncEnumerator IDbAsyncEnumerable.GetAsyncEnumerator() => GetAsyncEnumerator();
            IQueryProvider IQueryable.Provider => new AsyncQueryProvider<T>(this);
        }

        class AsyncQueryProvider<TEntity> : IDbAsyncQueryProvider
        {
            private readonly IQueryProvider _inner;

            internal AsyncQueryProvider(IQueryProvider inner)
            {
                _inner = inner;
            }

            public IQueryable CreateQuery(Expression expression) => new AsyncEnumerable<TEntity>(expression);
            public IQueryable<TElement> CreateQuery<TElement>(Expression expression) => new AsyncEnumerable<TElement>(expression);
            public object Execute(Expression expression) => _inner.Execute(expression);
            public TResult Execute<TResult>(Expression expression) => _inner.Execute<TResult>(expression);
            public Task<object> ExecuteAsync(Expression expression, CancellationToken cancellationToken) => Task.FromResult(Execute(expression));
            public Task<TResult> ExecuteAsync<TResult>(Expression expression, CancellationToken cancellationToken) => Task.FromResult(Execute<TResult>(expression));
        }

        public static Mock<DbSet<T>> GetMockDbSet<T>(List<T> sourceList, Func<object[], T> findPredicateFunc) where T : class
        {
            var mockDbSet = new Mock<DbSet<T>>();
            var listQueryable = sourceList.AsQueryable();
            //mockDbSet.As<IQueryable<T>>().Setup(s => s.Provider).Returns(listQueryable.Provider);
            mockDbSet.As<IQueryable<T>>().Setup(s => s.Expression).Returns(listQueryable.Expression);
            mockDbSet.As<IQueryable<T>>().Setup(s => s.ElementType).Returns(listQueryable.ElementType);
            mockDbSet.As<IQueryable<T>>().Setup(s => s.GetEnumerator()).Returns(listQueryable.GetEnumerator());
            mockDbSet.Setup(d => d.Add(It.IsAny<T>())).Callback<T>(sourceList.Add).Returns((T t) => t);
            mockDbSet.Setup(d => d.Remove(It.IsAny<T>())).Callback<T>(s => sourceList.Remove(s));
            mockDbSet.Setup(d => d.RemoveRange(It.IsAny<IEnumerable<T>>())).Callback<IEnumerable<T>>(s =>
            {
                foreach (var i in s.ToList()) sourceList.Remove(i);
            });
            mockDbSet.As<IQueryable<T>>()
                .Setup(m => m.Provider)
                .Returns(new AsyncQueryProvider<T>(listQueryable.Provider));
            mockDbSet.As<IDbAsyncEnumerable<T>>()
                .Setup(m => m.GetAsyncEnumerator())
                .Returns(new AsyncEnumerator<T>(listQueryable.GetEnumerator()));
            mockDbSet.Setup(m => m.Find(It.IsAny<object[]>())).Returns(findPredicateFunc);
            mockDbSet.Setup(m => m.FindAsync(It.IsAny<object[]>())).Returns<object[]>(ids => Task.FromResult(findPredicateFunc(ids)));
            return mockDbSet;
        }

    }
}