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

namespace Tango.BL.Builders
{
    public class RmlBuilder : EntityBuilderBase<Rml, RmlBuilder>
    {
        private List<Cct> _cctCache;

        public RmlBuilder(ObservablesContext context) : base(context)
        {
            _cctCache = new List<Cct>();
        }

        protected override IQueryable<Rml> OnSetQuery(IQueryable<Rml> query)
        {
            return query.
                Include(x => x.MediaMaterial).
                Include(x => x.MediaPurpose).
                Include(x => x.MediaCondition).
                Include(x => x.LinearMassDensityUnit).
                Include(x => x.FiberShape).
                Include(x => x.FiberSynth).
                Include(x => x.BtsrApplicationType).
                Include(x => x.BtsrYarnType);
        }

        public virtual RmlBuilder WithCctCache(List<Cct> cctCache)
        {
            if (cctCache != null)
            {
                _cctCache = cctCache;
            }
            return this;
        }

        public virtual RmlBuilder WithCCT()
        {
            if (Entity != null && _cctCache.Exists(x => x.Guid == Entity.CctGuid))
            {
                return this;
            }
            else if (EntityGuid != null)
            {
                var rml = Context.Rmls.Select(x => new { x.Guid, x.CctGuid }).FirstOrDefault(x => x.Guid == EntityGuid);

                if (rml != null && _cctCache.Exists(x => x.Guid == rml.CctGuid))
                {
                    return this;
                }
                else
                {
                    return AddQueryStep(1, (query) =>
                    {
                        return query.Include(x => x.Cct);
                    });
                }
            }
            else
            {
                return AddQueryStep(1, (query) =>
                {
                    return query.Include(x => x.Cct);
                });
            }
        }

        public virtual RmlBuilder WithGbdAndLub()
        {
            return AddQueryStep(2, (query) =>
            {
                return query.Include(x => x.Gbd).Include(x => x.Lub);
            });
        }

        public virtual RmlBuilder WithSpools()
        {
            return AddQueryStep(3, (query) =>
            {
                return query.Include(x => x.RmlsSpools).Include(x => x.RmlsSpools.Select(y => y.SpoolType));
            });
        }

        public virtual RmlBuilder WithAllParametersGroup()
        {
            return AddStep(1, () =>
            {
                Context.ProcessParametersTablesGroups.Where(x => x.RmlGuid == Entity.Guid).ToList();
                Context.ProcessParametersTables.Where(x => x.ProcessParametersTablesGroup.RmlGuid == Entity.Guid).OrderBy(x => x.TableIndex).ToList();
            });
        }

        public virtual RmlBuilder WithActiveParametersGroup()
        {
            return AddStep(2, () =>
            {
                var group = Context.ProcessParametersTablesGroups.Where(x => x.RmlGuid == Entity.Guid && x.Active).FirstOrDefault();

                if (group != null)
                {
                    Context.ProcessParametersTables.Where(x => x.ProcessParametersTablesGroupGuid == group.Guid).OrderBy(x => x.TableIndex).ToList();
                }
            });
        }

        public virtual RmlBuilder WithCAT(String machineGuid)
        {
            return AddStep(4, () =>
            {
                Context.Cats.Where(x => x.MachineGuid == machineGuid && x.RmlGuid == Entity.Guid).ToList();
            });
        }

        public virtual RmlBuilder WithLiquidFactors()
        {
            return AddStep(5, () =>
            {
                Context.LiquidTypesRmls.Where(x => x.RmlGuid == Entity.Guid).Include(x => x.LiquidType).OrderBy(x => x.LiquidType.Code).ToList();
            });
        }

        public virtual RmlBuilder WithRMLExtensions()
        {
            return AddStep(6, () =>
            {
                var rmlExt = Context.RmlsExtensions.Where(x => x.RmlsGuid == Entity.Guid).FirstOrDefault();
                if (rmlExt != null)
                    new RmlExtensionsBuilder(Context).Set(rmlExt.Guid).Build();
            });
        }

        public override Rml Build()
        {
            var rml = base.Build();
            if (rml != null)
            {
                if (rml.Cct != null)
                {
                    if (!_cctCache.Exists(x => x.Guid == rml.Cct.Guid))
                    {
                        _cctCache.Add(rml.Cct);
                    }
                }
                else
                {
                    var cacheCCT = _cctCache.SingleOrDefault(x => x.Guid == rml.CctGuid);

                    if (cacheCCT != null)
                    {
                        cacheCCT.Rmls.Clear();
                        var entry = Context.Entry(cacheCCT);
                        entry.State = EntityState.Added;
                        Context.Ccts.Attach(cacheCCT);
                        entry.State = EntityState.Unchanged;
                    }
                }
            }

            return rml;
        }
    }
}