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

namespace Tango.BL
{
    /// <summary>
    /// Represents an <see cref="ObservablesContext"/> adapter for retrieving aggregated entities.
    /// </summary>
    public class ObservablesContextAdapter : IDisposable
    {
        private ObservablesContext _db;
        /// <summary>
        /// Gets the underlying <see cref="ObservablesContext"/>.
        /// </summary>
        public ObservablesContext Context
        {
            get { return _db; }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ObservablesContextAdapter"/> class.
        /// </summary>
        /// <param name="context">The context.</param>
        public ObservablesContextAdapter(ObservablesContext context)
        {
            _db = context;
        }

        /// <summary>
        /// Creates the a new instance of <see cref="ObservablesContextAdapter"/> wrapping a default <see cref="ObservablesContext"/>.
        /// </summary>
        /// <returns></returns>
        public static ObservablesContextAdapter CreateDefault()
        {
            var context = ObservablesContext.CreateDefault();
            return new ObservablesContextAdapter(context);
        }

        /// <summary>
        /// Loads the configuration with it's Ids packs.
        /// </summary>
        /// <param name="condition">The condition.</param>
        /// <returns></returns>
        public Configuration GetConfiguration(Expression<Func<Configuration, bool>> condition)
        {
            var config = _db.Configurations.SingleOrDefault(condition);

            var l = _db.IdsPacks.Where(x => x.ConfigurationGuid == config.Guid)
                .Include(x => x.LiquidType)
                .Include(x => x.MidTankType)
                .Include(x => x.CartridgeType)
                .Include(x => x.Dispenser)
                .Include(x => x.Dispenser.DispenserType)
                .Include(x => x.IdsPackFormula).OrderBy(x => x.PackIndex).ToList();

            return config;
        }

        /// <summary>
        /// Gets the hardware version by the specified condition.
        /// </summary>
        /// <param name="condition">The condition.</param>
        /// <returns></returns>
        public HardwareVersion GetHardwareVersion(Expression<Func<HardwareVersion, bool>> condition)
        {
            HardwareVersion version = _db.HardwareVersions.SingleOrDefault(condition);

            version.HardwareBlowers = _db.HardwareBlowers.Where(x => x.HardwareVersionGuid == version.Guid).Include(x => x.HardwareBlowerType).ToList().OrderBy(x => x.HardwareBlowerType.Code).ToSynchronizedObservableCollection();
            version.HardwareBreakSensors = _db.HardwareBreakSensors.Where(x => x.HardwareVersionGuid == version.Guid).Include(x => x.HardwareBreakSensorType).ToList().OrderBy(x => x.HardwareBreakSensorType.Code).ToSynchronizedObservableCollection();
            version.HardwareDancers = _db.HardwareDancers.Where(x => x.HardwareVersionGuid == version.Guid).Include(x => x.HardwareDancerType).ToList().OrderBy(x => x.HardwareDancerType.Code).ToSynchronizedObservableCollection();
            version.HardwareMotors = _db.HardwareMotors.Where(x => x.HardwareVersionGuid == version.Guid).Include(x => x.HardwareMotorType).ToList().OrderBy(x => x.HardwareMotorType.Code).ToSynchronizedObservableCollection();
            version.HardwarePidControls = _db.HardwarePidControls.Where(x => x.HardwareVersionGuid == version.Guid).Include(x => x.HardwarePidControlType).ToList().OrderBy(x => x.HardwarePidControlType.Code).ToSynchronizedObservableCollection();
            version.HardwareSpeedSensors = _db.HardwareSpeedSensors.Where(x => x.HardwareVersionGuid == version.Guid).Include(x => x.HardwareSpeedSensorType).ToList().OrderBy(x => x.HardwareSpeedSensorType.Code).ToSynchronizedObservableCollection();
            version.HardwareWinders = _db.HardwareWinders.Where(x => x.HardwareVersionGuid == version.Guid).Include(x => x.HardwareWinderType).ToList().OrderBy(x => x.HardwareWinderType.Code).ToSynchronizedObservableCollection();

            return version;
        }

        /// <summary>
        /// Gets the hardware version by machine.
        /// </summary>
        /// <param name="machineGuid">The machine unique identifier.</param>
        /// <returns></returns>
        public HardwareVersion GetHardwareVersionByMachine(String machineGuid)
        {
            var machine = _db.Machines.Where(x => x.Guid == machineGuid).Include(x => x.Configuration).FirstOrDefault();
            return GetHardwareVersion(x => x.Guid == machine.Configuration.HardwareVersionGuid);
        }

        /// <summary>
        /// Gets the active process parameters tables group.
        /// </summary>
        /// <param name="rmlGuid">The RML unique identifier.</param>
        /// <returns></returns>
        public ProcessParametersTablesGroup GetRmlActiveProcessParametersTablesGroup(String rmlGuid)
        {
            return _db.ProcessParametersTablesGroups.Where(x => x.RmlGuid == rmlGuid && x.Active).Include(x => x.ProcessParametersTables).FirstOrDefault();
        }

        /// <summary>
        /// Gets the RML process parameters tables groups.
        /// </summary>
        /// <param name="rmlGuid">The RML unique identifier.</param>
        /// <returns></returns>
        public List<ProcessParametersTablesGroup> GetRmlProcessParametersTablesGroups(String rmlGuid)
        {
            var groups = _db.ProcessParametersTablesGroups.Where(x => x.RmlGuid == rmlGuid).ToList();

            foreach (var group in groups)
            {
                group.ProcessParametersTables = _db.ProcessParametersTables.Where(x => x.ProcessParametersTablesGroupGuid == group.Guid).OrderBy(x => x.TableIndex).ToSynchronizedObservableCollection();
            }

            return groups;
        }

        /// <summary>
        /// Gets the RML CATS.
        /// </summary>
        /// <param name="rmlGuid">The RML unique identifier.</param>
        /// <param name="machineGuid">The machine unique identifier.</param>
        /// <returns></returns>
        public ObservableCollection<Cat> GetRmlCATs(String rmlGuid, String machineGuid)
        {
            return _db.Cats.Where(x => x.MachineGuid == machineGuid && x.RmlGuid == rmlGuid).ToObservableCollection();
        }

        /// <summary>
        /// Gets the RML liquid types factors.
        /// </summary>
        /// <param name="rmlGuid">The RML unique identifier.</param>
        /// <returns></returns>
        public ObservableCollection<LiquidTypesRml> GetRmlLiquidTypes(String rmlGuid)
        {
            return _db.LiquidTypesRmls.Where(x => x.RmlGuid == rmlGuid).ToObservableCollection();
        }

        /// <summary>
        /// Gets the job with all its segments and brush stops.
        /// </summary>
        /// <param name="jobGuid">The job unique identifier.</param>
        /// <returns></returns>
        public Job GetJob(String jobGuid)
        {
            Job job = _db.Jobs.Where(x => x.Guid == jobGuid)
                .Include(x => x.Machine)
                .Include(x => x.Rml)
                .Include(x => x.ColorSpace)
                .Include(x => x.WindingMethod)
                .Include(x => x.SpoolType).FirstOrDefault();

            job.Segments = _db.Segments.Where(x => x.JobGuid == jobGuid).OrderBy(x => x.SegmentIndex).ToSynchronizedObservableCollection();

            foreach (var segment in job.Segments)
            {
                segment.BrushStops = _db.BrushStops.Where(x => x.SegmentGuid == segment.Guid).OrderBy(x => x.StopIndex).ToSynchronizedObservableCollection();
            }

            GetMachine(job.Machine.SerialNumber);

            GetRmlActiveProcessParametersTablesGroup(job.RmlGuid);

            return job;
        }

        /// <summary>
        /// Gets the machine with its configuration and organization.
        /// </summary>
        /// <param name="serialNumber">The serial number.</param>
        /// <returns></returns>
        public Machine GetMachine(String serialNumber)
        {
            var machine = _db.Machines.SingleOrDefault(x => x.SerialNumber == serialNumber);

            machine.Organization = _db.Organizations.SingleOrDefault(x => x.Guid == machine.OrganizationGuid);
            machine.Configuration = GetConfiguration(x => x.Guid == machine.ConfigurationGuid);
            machine.Configuration.HardwareVersion = GetHardwareVersion(x => x.Guid == machine.Configuration.HardwareVersionGuid);

            return machine;
        }

        /// <summary>
        /// Disposes the underlying <see cref="ObservablesContext"/>.
        /// </summary>
        public void Dispose()
        {
            _db.Dispose();
        }
    }
}