using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
using Tango.Core;

namespace Tango.BL.Builders
{
    public class EntityCollectionBuilderBase<T, TBuilder> : IEntityCollectionBuilder<T> where T : ObservableEntity<T> where TBuilder : EntityCollectionBuilderBase<T, TBuilder>
    {
        private List<KeyValuePair<int, Action>> _steps;
        private List<KeyValuePair<int, Func<IQueryable<T>, IQueryable<T>>>> _querySteps;
        private bool _entity_set;
        private Func<IQueryable<T>, IQueryable<T>> _appendQuery;

        protected IEnumerable<T> Entities { get; set; }

        protected ObservablesContext Context { get; set; }

        public EntityCollectionBuilderBase(ObservablesContext context)
        {
            Entities = new List<T>();
            _steps = new List<KeyValuePair<int, Action>>();
            _querySteps = new List<KeyValuePair<int, Func<IQueryable<T>, IQueryable<T>>>>();
            Context = context;
        }

        public virtual TBuilder SetAll()
        {
            AddStep(0, () =>
            {
                IQueryable<T> query = Context.Set<T>();
                query = OnSetQuery(query);

                foreach (var queryStep in _querySteps.ToList().DistinctBy(x => x.Key).OrderBy(x => x.Key))
                {
                    query = queryStep.Value(query);
                }

                if (_appendQuery != null)
                {
                    query = _appendQuery(query);
                }

                Entities = query.ToList();
            });

            _entity_set = true;

            return this as TBuilder;
        }

        public virtual TBuilder Set(Expression<Func<T, bool>> condition)
        {
            AddStep(0, () =>
            {
                IQueryable<T> query = Context.Set<T>().Where(condition);
                query = OnSetQuery(query);

                foreach (var queryStep in _querySteps.ToList().DistinctBy(x => x.Key).OrderBy(x => x.Key))
                {
                    query = queryStep.Value(query);
                }

                if (_appendQuery != null)
                {
                    query = _appendQuery(query);
                }

                Entities = query.ToList();
            });

            _entity_set = true;

            return this as TBuilder;
        }

        protected virtual IQueryable<T> OnSetQuery(IQueryable<T> query)
        {
            return query;
        }

        public TBuilder Query(Func<IQueryable<T>, IQueryable<T>> query)
        {
            _appendQuery = query;
            return this as TBuilder;
        }

        protected void CommitSteps()
        {
            foreach (var step in _steps.ToList().DistinctBy(x => x.Key).OrderBy(x => x.Key))
            {
                step.Value();
                _steps.Remove(step);
            }
        }

        protected TBuilder AddStep(int index, Action action)
        {
            _steps.Add(new KeyValuePair<int, Action>(index, action));
            return this as TBuilder;
        }

        protected TBuilder AddQueryStep(int index, Func<IQueryable<T>, IQueryable<T>> func)
        {
            _querySteps.Add(new KeyValuePair<int, Func<IQueryable<T>, IQueryable<T>>>(index, func));
            return this as TBuilder;
        }

        public SynchronizedObservableCollection<T> Build()
        {
            if (!_entity_set)
            {
                throw new InvalidOperationException("Could not build entity. Entity was not set.");
            }

            CommitSteps();

            return Entities.ToSynchronizedObservableCollection();
        }

        public List<T> BuildList()
        {
            if (!_entity_set)
            {
                throw new InvalidOperationException("Could not build entity. Entity was not set.");
            }

            CommitSteps();

            return Entities.ToList();
        }

        public Task<SynchronizedObservableCollection<T>> BuildAsync()
        {
            return Task.Factory.StartNew<SynchronizedObservableCollection<T>>(() =>
            {
                return Build();
            });
        }

        public Task<List<T>> BuildListAsync()
        {
            return Task.Factory.StartNew<List<T>>(() =>
            {
                return BuildList();
            });
        }
    }
}