using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Data;
using Tango.BL;
using Tango.BL.Entities;
using Tango.BL.Enumerations;
using Tango.BL.ValueObjects;
using Tango.Core;
using Tango.Core.Commands;
using Tango.MachineStudio.Common.Notifications;
using Tango.MachineStudio.MachineDesigner.Models;
using Tango.SharedUI;

namespace Tango.MachineStudio.MachineDesigner.ViewModels
{
    public class HardwareConfigurationViewVM : ViewModel
    {
        private INotificationProvider _notification;
        private HardwareConfiguration _hwConfig;

        #region Properties

        public SynchronizedObservableCollection<HardwareCollection> Collections { get; set; }

        private bool _isShowDifference;
        public bool IsShowDifference
        {
            get { return _isShowDifference; }
            set
            {
                _isShowDifference = value;
                RaisePropertyChangedAuto();
            }
        }

        private ICollectionView _collectionViewSource;
        public ICollectionView CollectionsViewSource
        {
            get { return _collectionViewSource; }
            set { _collectionViewSource = value; RaisePropertyChangedAuto(); }
        }

        private String _PropertyFilter;
        public String PropertyFilter
        {
            get { return _PropertyFilter; }
            set
            {
                _PropertyFilter = value;
                RaisePropertyChangedAuto();
                OnFilterChanged();
            }
        }

        private String _componentFilter;
        public String ComponentFilter
        {
            get { return _componentFilter; }
            set
            {
                _componentFilter = value;
                RaisePropertyChangedAuto();
                OnFilterChanged();
            }
        }

        #endregion

        private void OnFilterChanged()
        {
            CollectionsViewSource.Refresh();
        }

        public HardwareConfigurationViewVM(INotificationProvider notification)
        {
            _notification = notification;
            Collections = new SynchronizedObservableCollection<HardwareCollection>();
            CollectionsViewSource = CollectionViewSource.GetDefaultView(Collections);
            CollectionsViewSource.Filter = new Predicate<object>(FilterCollection);

            //Test();
        }

        #region Build Collection

        public void Init(Configuration configuration)
        {
            HardwareVersion hardwareVersion = configuration.HardwareVersion;

            if (hardwareVersion != null)
            {
                _hwConfig = configuration.GetHardwareConfiguration();

                Collections.Clear();
                Collections.Add(CreateMotorsCollection(hardwareVersion));
                Collections.Add(CreateDancerCollection(hardwareVersion));
                Collections.Add(CreatePidCollection(hardwareVersion));
                Collections.Add(CreateWindersCollection(hardwareVersion));
                Collections.Add(CreateSpeedSensorsCollection(hardwareVersion));
                Collections.Add(CreateBlowersCollection(hardwareVersion));
                Collections.Add(CreateBreakSensorCollection(hardwareVersion));
            }
        }

        private HardwareCollection CreateMotorsCollection(HardwareVersion hardwareVersion)
        {
            HardwareCollection collection = new HardwareCollection()
            {
                CollectionName = "MOTORS"
            };
            foreach (var motorTypeCode in Enum.GetValues(typeof(HardwareMotorTypes)).Cast<HardwareMotorTypes>())
            {
                var motor = hardwareVersion.HardwareMotors.SingleOrDefault(x => x.HardwareMotorType.Code == motorTypeCode.ToInt32());
                if (motor != null)
                {
                    var componentResult = CreateComponent(
                      motor.HardwareMotorType.Name,
                      motorTypeCode.ToDescription(),
                      GetComponentProperties(typeof(HardwareMotorBase)),
                      motor);

                    collection.Components.Add(componentResult);
                }
            }
            collection.Components = collection.Components.OrderByAlphaNumeric(x => x.Description).ToSynchronizedObservableCollection();
            return collection;
        }
        private HardwareCollection CreateDancerCollection(HardwareVersion hardwareVersion)
        {
            HardwareCollection collection = new HardwareCollection()
            {
                CollectionName = "DANCERS"
            };
            foreach (var dancerTypeCode in Enum.GetValues(typeof(HardwareDancerTypes)).Cast<HardwareDancerTypes>())
            {
                var dancer = hardwareVersion.HardwareDancers.SingleOrDefault(x => x.HardwareDancerType.Code == dancerTypeCode.ToInt32());
                if (dancer != null)
                {
                    var componentResult = CreateComponent(
                      dancer.HardwareDancerType.Name,
                      dancerTypeCode.ToDescription(),
                      GetComponentProperties(typeof(HardwareDancerBase)),
                      dancer);

                    collection.Components.Add(componentResult);
                }
            }
            collection.Components = collection.Components.OrderByAlphaNumeric(x => x.Description).ToSynchronizedObservableCollection();
            return collection;
        }
        private HardwareCollection CreatePidCollection(HardwareVersion hardwareVersion)
        {
            HardwareCollection collection = new HardwareCollection()
            {
                CollectionName = "PID CONTROLS"
            };
            foreach (var pidTypeCode in Enum.GetValues(typeof(HardwarePidControlTypes)).Cast<HardwarePidControlTypes>())
            {
                var pidControl = hardwareVersion.HardwarePidControls.SingleOrDefault(x => x.HardwarePidControlType.Code == pidTypeCode.ToInt32());
                if (pidControl != null)
                {
                    var componentResult = CreateComponent(
                      pidControl.HardwarePidControlType.Name,
                      pidTypeCode.ToDescription(),
                      GetComponentProperties(typeof(HardwarePidControlBase)),
                      pidControl);

                    collection.Components.Add(componentResult);
                }
            }
            collection.Components = collection.Components.OrderByAlphaNumeric(x => x.Description).ToSynchronizedObservableCollection();
            return collection;
        }
        private HardwareCollection CreateWindersCollection(HardwareVersion hardwareVersion)
        {
            HardwareCollection collection = new HardwareCollection()
            {
                CollectionName = "WINDERS"
            };
            foreach (var winderTypeCode in Enum.GetValues(typeof(HardwareWinderTypes)).Cast<HardwareWinderTypes>())
            {
                var winderControl = hardwareVersion.HardwareWinders.SingleOrDefault(x => x.HardwareWinderType.Code == winderTypeCode.ToInt32());
                if (winderControl != null)
                {
                    var componentResult = CreateComponent(
                      winderControl.HardwareWinderType.Name,
                      winderTypeCode.ToDescription(),
                      GetComponentProperties(typeof(HardwareWinderBase)),
                      winderControl);

                    collection.Components.Add(componentResult);
                }
            }
            collection.Components = collection.Components.OrderByAlphaNumeric(x => x.Description).ToSynchronizedObservableCollection();
            return collection;
        }
        private HardwareCollection CreateSpeedSensorsCollection(HardwareVersion hardwareVersion)
        {
            HardwareCollection collection = new HardwareCollection()
            {
                CollectionName = "SPEED SENSORS"
            };
            foreach (var speedSensorTypeCode in Enum.GetValues(typeof(HardwareSpeedSensorTypes)).Cast<HardwareSpeedSensorTypes>())
            {
                var speedSensor = hardwareVersion.HardwareSpeedSensors.SingleOrDefault(x => x.HardwareSpeedSensorType.Code == speedSensorTypeCode.ToInt32());
                if (speedSensor != null)
                {
                    var componentResult = CreateComponent(
                      speedSensor.HardwareSpeedSensorType.Name,
                      speedSensorTypeCode.ToDescription(),
                      GetComponentProperties(typeof(HardwareSpeedSensorBase)),
                      speedSensor);

                    collection.Components.Add(componentResult);
                }
            }
            collection.Components = collection.Components.OrderByAlphaNumeric(x => x.Description).ToSynchronizedObservableCollection();
            return collection;
        }
        private HardwareCollection CreateBlowersCollection(HardwareVersion hardwareVersion)
        {
            HardwareCollection collection = new HardwareCollection()
            {
                CollectionName = "BLOWERS"
            };
            foreach (var blowersTypeCode in Enum.GetValues(typeof(HardwareBlowerTypes)).Cast<HardwareBlowerTypes>())
            {
                var blower = hardwareVersion.HardwareBlowers.SingleOrDefault(x => x.HardwareBlowerType.Code == blowersTypeCode.ToInt32());
                if (blower != null)
                {
                    var componentResult = CreateComponent(
                      blower.HardwareBlowerType.Name,
                      blowersTypeCode.ToDescription(),
                      GetComponentProperties(typeof(HardwareBlowerBase)),
                      blower);

                    collection.Components.Add(componentResult);
                }
            }
            collection.Components= collection.Components.OrderByAlphaNumeric(x => x.Description).ToSynchronizedObservableCollection();
            return collection;
        }
        private HardwareCollection CreateBreakSensorCollection(HardwareVersion hardwareVersion)
        {
            HardwareCollection collection = new HardwareCollection()
            {
                CollectionName = "BREAK SENSOR"
            };
            foreach (var breakSensorsTypeCode in Enum.GetValues(typeof(HardwareBreakSensorTypes)).Cast<HardwareBreakSensorTypes>())
            {
                var breakSensor = hardwareVersion.HardwareBreakSensors.SingleOrDefault(x => x.HardwareBreakSensorType.Code == breakSensorsTypeCode.ToInt32());
                if (breakSensor != null)
                {
                    var componentResult = CreateComponent(
                      breakSensor.HardwareBreakSensorType.Name,
                      breakSensorsTypeCode.ToDescription(),
                      GetComponentProperties(typeof(HardwareBreakSensorBase)),
                      breakSensor);

                    collection.Components.Add(componentResult);
                }
            }
            collection.Components = collection.Components.OrderByAlphaNumeric(x => x.Description).ToSynchronizedObservableCollection();
            return collection;
        }
        private HardwareComponent CreateComponent(String name, String description, List<PropertyInfo> properties, Object component)
        {
            HardwareComponent hwComponent = new HardwareComponent()
            {
                Description = description,
                ComponentName = name
            };
            
            foreach (var prop in properties)
            {
                var hProp = new HardwareParameter();
                hProp.Component = hwComponent;
                hProp.PropertyName = prop.Name;
                hProp.DefaultValue = prop.GetValue(component);
                hProp.Selected -= HProp_Selected;
                hProp.Selected += HProp_Selected;

                var configParam = _hwConfig.Parameters.SingleOrDefault(x => x.ComponentName == name && x.ParameterName == prop.Name);
                hProp.ActualValue = configParam != null ? configParam.Value : null;
                hwComponent.Properties.Add(hProp);
            }
            return hwComponent;
        }

        private void HProp_Selected(object sender, EventArgs e)
        {
            if (Collections != null)
            {
                Collections.SelectMany(x => x.Components).SelectMany(x => x.Properties).Where(x => x != sender).ToList().ForEach(x => x.IsSelected = false);
            }
        }

        public void ClearSelections()
        {
            if (Collections != null)
            {
                Collections.SelectMany(x => x.Components).SelectMany(x => x.Properties).ToList().ForEach(x => x.IsSelected = false);
            }
        }

        private List<PropertyInfo> GetComponentProperties(Type componentType)
        {
            List<String> exclude = new List<string>()
            {
                 "Guid",
                 "ID",
                 "LastUpdated",
                 "Parameters",
            };
            return componentType.GetProperties(BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public).Where(x => !x.PropertyType.IsClass && !exclude.Contains(x.Name)).ToList();
        }

        #endregion

        public HardwareConfiguration GetResultingHardwareConfiguration()
        {
            HardwareConfiguration hwConfig = new HardwareConfiguration();

            foreach (var parameter in Collections.SelectMany(x => x.Components).SelectMany(x => x.Properties).Where(x => x.HasDifferences))
            {
                hwConfig.Parameters.Add(new HardwareConfiguration.HardwareConfigurationParameter()
                {
                    ComponentName = parameter.Component.ComponentName,
                    ParameterName = parameter.PropertyName,
                    Value = parameter.ActualValue
                });
            }

            return hwConfig;
        }

        #region Filter

        private bool FilterCollection(object obj)
        {
            HardwareCollection collection = obj as HardwareCollection;
            var components = CollectionViewSource.GetDefaultView(collection.Components);
            components.Filter = new Predicate<object>(FilterComponent);
            return true;
        }
        private bool FilterComponent(object obj)
        {
            HardwareComponent component = obj as HardwareComponent;
            var properties = CollectionViewSource.GetDefaultView(component.Properties);
            properties.Filter = new Predicate<object>(FilterProperty);

            if (!String.IsNullOrWhiteSpace(ComponentFilter))
            {
                var words = ComponentFilter.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).ToList();
                return words.Any(x => component.Description.ToLower().Contains(x.ToLower()));
            }
            else
            {
                return true;
            }
        }
        private bool FilterProperty(object obj)
        {
            HardwareParameter hparameter = obj as HardwareParameter;

            if (!String.IsNullOrWhiteSpace(PropertyFilter))
            {
                var words = PropertyFilter.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).ToList();
                return words.Any(x => hparameter.PropertyName.ToLower().Contains(x.ToLower()));
            }
            else
            {
                return true;
            }

        }

        #endregion

        #region test

        private void Test()
        {
            HardwareCollection col1 = new HardwareCollection()
            {
                CollectionName = "Motors",

            };
            HardwareParameter par1 = new HardwareParameter()
            {
                PropertyName = "Prop1",
                ActualValue = null,
                DefaultValue = 12,

            };

            HardwareParameter par2 = new HardwareParameter()
            {
                PropertyName = "Prop2",
                ActualValue = null,
                DefaultValue = true
            };

            HardwareComponent comp1 = new HardwareComponent()
            {
                ComponentName = "H_C_1",
                Description = "HardwareComponent"
            };
            comp1.Properties.Add(par1);
            comp1.Properties.Add(par2);
            col1.Components.Add(comp1);
            Collections.Add(col1);

        }

        #endregion
    }
}