using System.Collections;
using System.Linq.Expressions;

namespace YLErp.Modules.DataCacheModule
{
    class DataCacheQueryable<T> : IOrderedQueryable<T>
    {
        private IQueryable _query;

        public DataCacheQueryable(IQueryable query)
        {
            _query = query ?? throw new ArgumentNullException(nameof(query));
        }

        public Expression Expression => _query.Expression;

        public Type ElementType => _query.ElementType;

        public IQueryProvider Provider => new DataCacheQueryProvider<T>(_query.Provider);

        public IEnumerator<T> GetEnumerator()
        {
            var em = Provider.Execute<IEnumerable<T>>(Expression);

            var t = typeof(T);
            if (t.IsClass && typeof(IClonable<T>).IsAssignableFrom(t))
            {
                em = em.Select(n => ((IClonable<T>)n).Clone());
            }

            return em.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
    }

    class DataCacheQueryProvider<T> : IQueryProvider
    {
        readonly IQueryProvider _baseProvider;

        public DataCacheQueryProvider(IQueryProvider baseProvider)
        {
            _baseProvider = baseProvider ?? throw new ArgumentNullException(nameof(baseProvider));
        }

        public IQueryable CreateQuery(Expression expression)
        {
            return new DataCacheQueryable<T>(_baseProvider.CreateQuery(expression));
        }

        public IQueryable<TElement> CreateQuery<TElement>(Expression expression)
        {
            var query = _baseProvider.CreateQuery<TElement>(expression);

            var t = typeof(TElement);
            if (t.IsClass && typeof(IClonable<TElement>).IsAssignableFrom(t))
            {
                return new DataCacheQueryable<TElement>(query);
            }

            return query;
        }

        public object Execute(Expression expression)
        {
            return Execute<T>(expression);
        }

        public TResult Execute<TResult>(Expression expression)
        {
            return _baseProvider.Execute<TResult>(expression);
        }
    }
}