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

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

        protected T Entity { get; set; }
        protected String EntityGuid { get; set; }
        protected ObservablesContext Context { get; set; }

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

        public virtual TBuilder Set(Expression<Func<T, bool>> condition)
        {
            ThrowIfEntitySet();

            AddStep(0, () =>
             {
                 abort_build = false;

                 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);
                 }

                 Entity = query.FirstOrDefault();

                 abort_build = Entity == null;
             });

            _entity_set = true;

            return this as TBuilder;
        }

        public virtual TBuilder SetFirst()
        {
            ThrowIfEntitySet();

            AddStep(0, () =>
            {
                abort_build = false;

                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);
                }

                Entity = query.FirstOrDefault();

                abort_build = Entity == null;
            });

            _entity_set = true;

            return this as TBuilder;
        }

        public virtual TBuilder Set(T entity)
        {
            Entity = entity;
            EntityGuid = entity?.Guid;
            return Set(entity.Guid);
        }

        public TBuilder Set(string guid)
        {
            EntityGuid = guid;
            return Set(x => x.Guid == guid);
        }

        private void ThrowIfEntitySet()
        {
            if (_entity_set) throw new InvalidOperationException("Could not set entity. Entity was already set.");
        }

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

        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;
        }

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

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

            CommitSteps();

            return Entity;
        }

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