using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel.DataAnnotations.Schema;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using Tango.BL;
using Tango.BL.Entities;
using Tango.BL.Enumerations;
using Tango.BL.Serialization;
using Tango.Core.Commands;
using Tango.SharedUI;

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

namespace Tango.HardwareVersionComparison
{
    public class MainWindowVM : ViewModel
    {
        #region Property
        
        private String _jsonText1;
        public String JsonText1
        {
            get { return _jsonText1; }
            set
            {
                _jsonText1 = value;
                RaisePropertyChangedAuto();
                InvalidateRelayCommands();
            }
        }
        private String _jsonText2;
        public String JsonText2
        {
            get { return _jsonText2; }
            set
            {
                _jsonText2 = value;
                RaisePropertyChangedAuto();
                InvalidateRelayCommands();
            }
        }

        private ObservableCollection<String> _valuesVersion1;

        public ObservableCollection<String> ValuesForVersion1
        {
            get { return _valuesVersion1; }
            set { _valuesVersion1 = value; RaisePropertyChangedAuto(); }
        }
        private ObservableCollection<String> _valuesVersion2;

        public ObservableCollection<String> ValuesForVersion2
        {
            get { return _valuesVersion2; }
            set { _valuesVersion2 = value; RaisePropertyChangedAuto(); }
        }
        private bool _isShowDifference;
        public bool IsShowDifference
        {
            get { return _isShowDifference; }
            set
            {
                _isShowDifference = value;
                RaisePropertyChangedAuto();
            }
        }
        
        private HardwareCompareResult _result;
        public HardwareCompareResult Result
        {
            get
            {
                return _result;
            }
            set
            {
                _result = value;
                RaisePropertyChangedAuto();
                InvalidateRelayCommands();
            }
        }
        #endregion
        #region Command

        public RelayCommand CompareCommand { get; set; }

        #endregion
        public MainWindowVM()
        {
            ValuesForVersion1 = new ObservableCollection<string>();
            ValuesForVersion2 = new ObservableCollection<string>();
            _isShowDifference = false;
            CompareCommand = new RelayCommand(CompareVersions, () => !String.IsNullOrEmpty(JsonText1) && !String.IsNullOrEmpty(JsonText2));

        }
        #region Compare
        private void CompareVersions()
        {
            
                PMR.Hardware.HardwareConfiguration h1 = CreateHardwareVersionFromJson(JsonText1);
                PMR.Hardware.HardwareConfiguration h2 = CreateHardwareVersionFromJson(JsonText2);
                Result = CompareHardwareVersions(h1, h2);
        }
        private HardwareCompareResult CompareHardwareVersions(PMR.Hardware.HardwareConfiguration h1, PMR.Hardware.HardwareConfiguration h2)
        {
            _result = new HardwareCompareResult();
            _result.Collections.Add(CompareMotorsCollection(h1, h2));
            _result.Collections.Add(CompareDancerCollection(h1, h2));
            _result.Collections.Add(ComparePidControlsCollection(h1, h2));
            _result.Collections.Add(CompareWindersCollection(h1, h2));
            _result.Collections.Add(CompareSpeedSensorsCollection(h1, h2));
            _result.Collections.Add(CompareBlowersCollection(h1, h2));
            _result.Collections.Add(CompareBreakSensorCollection(h1, h2));


            return _result;
        }
        private HardwareComponentCollectionCompareResult CompareMotorsCollection(PMR.Hardware.HardwareConfiguration h1, PMR.Hardware.HardwareConfiguration h2)
        {
            HardwareComponentCollectionCompareResult collection = new HardwareComponentCollectionCompareResult()
            {
                CollectionName = "MOTORS"
            };
            foreach (var motorTypeCode in Enum.GetValues(typeof(PMR.Hardware.HardwareMotorType)).Cast<PMR.Hardware.HardwareMotorType>())
            {
                var motor1 = h1.Motors.SingleOrDefault(x => x.HardwareMotorType.ToInt32() == motorTypeCode.ToInt32());
                var motor2 = h2.Motors.SingleOrDefault(x => x.HardwareMotorType.ToInt32() == motorTypeCode.ToInt32());
         
                var componentResult = CompareComponents(
                    motorTypeCode.ToDescription(),
                    GetComponentProperties(typeof(PMR.Hardware.HardwareMotor)),
                    motor1,
                    motor2);

                collection.Components.Add(componentResult);
            }
            return collection;
        }
        private HardwareComponentCollectionCompareResult CompareDancerCollection(PMR.Hardware.HardwareConfiguration h1, PMR.Hardware.HardwareConfiguration h2)
        {
            HardwareComponentCollectionCompareResult collection = new HardwareComponentCollectionCompareResult()
            {
                CollectionName = "DANCERS"
            };
            foreach (var dancerTypeCode in Enum.GetValues(typeof(PMR.Hardware.HardwareDancerType)).Cast<PMR.Hardware.HardwareDancerType>())
            {
                var motor1 = h1.Dancers.SingleOrDefault(x => x.HardwareDancerType.ToInt32() == dancerTypeCode.ToInt32());
                var motor2 = h2.Dancers.SingleOrDefault(x => x.HardwareDancerType.ToInt32() == dancerTypeCode.ToInt32());

                var componentResult = CompareComponents(
                    dancerTypeCode.ToDescription(),
                    GetComponentProperties(typeof(Tango.PMR.Hardware.HardwareDancer)),
                    motor1,
                    motor2);

                collection.Components.Add(componentResult);
            }
            return collection;
        }
        private HardwareComponentCollectionCompareResult ComparePidControlsCollection(PMR.Hardware.HardwareConfiguration h1, PMR.Hardware.HardwareConfiguration h2)
        {
            HardwareComponentCollectionCompareResult collection = new HardwareComponentCollectionCompareResult()
            {
                CollectionName = "PID CONTROLS"
            };
            foreach (var pidControlsTypeCode in Enum.GetValues(typeof(PMR.Hardware.HardwarePidControlType)).Cast<PMR.Hardware.HardwarePidControlType>())
            {
                ///(PMR.Hardware.HardwarePidControlType)pid.HardwarePidControlType.Code
                var motor1 = h1.PidControls.SingleOrDefault(x => x.HardwarePidControlType.ToInt32() == pidControlsTypeCode.ToInt32());
                var motor2 = h2.PidControls.SingleOrDefault(x => x.HardwarePidControlType.ToInt32() == pidControlsTypeCode.ToInt32());

                var componentResult = CompareComponents(
                    pidControlsTypeCode.ToDescription(),
                    GetComponentProperties(typeof(Tango.PMR.Hardware.HardwarePidControl)),
                    motor1,
                    motor2);

                collection.Components.Add(componentResult);
            }
            return collection;
        }
        private HardwareComponentCollectionCompareResult CompareWindersCollection(PMR.Hardware.HardwareConfiguration h1, PMR.Hardware.HardwareConfiguration h2)
        {
            HardwareComponentCollectionCompareResult collection = new HardwareComponentCollectionCompareResult()
            {
                CollectionName = "WINDERS"
            };
            foreach (var WinderTypeCode in Enum.GetValues(typeof(PMR.Hardware.HardwareWinderType)).Cast<PMR.Hardware.HardwareWinderType>())
            {
                var motor1 = h1.Winders.SingleOrDefault(x => x.HardwareWinderType.ToInt32() == WinderTypeCode.ToInt32());
                var motor2 = h2.Winders.SingleOrDefault(x => x.HardwareWinderType.ToInt32() == WinderTypeCode.ToInt32());

                var componentResult = CompareComponents(
                    WinderTypeCode.ToDescription(),
                    GetComponentProperties(typeof(PMR.Hardware.HardwareWinder)),
                    motor1,
                    motor2);

                collection.Components.Add(componentResult);
            }
            return collection;
        }
        private HardwareComponentCollectionCompareResult CompareSpeedSensorsCollection(PMR.Hardware.HardwareConfiguration h1, PMR.Hardware.HardwareConfiguration h2)
        {
            HardwareComponentCollectionCompareResult collection = new HardwareComponentCollectionCompareResult()
            {
                CollectionName = "SPEED SENSORS"
            };
            foreach (var speedSewnsorsTypeCode in Enum.GetValues(typeof(PMR.Hardware.HardwareSpeedSensorType)).Cast<PMR.Hardware.HardwareSpeedSensorType>())
            {
                var motor1 = h1.SpeedSensors.SingleOrDefault(x => x.HardwareSpeedSensorType.ToInt32() == speedSewnsorsTypeCode.ToInt32());
                var motor2 = h2.SpeedSensors.SingleOrDefault(x => x.HardwareSpeedSensorType.ToInt32() == speedSewnsorsTypeCode.ToInt32());

                var componentResult = CompareComponents(
                    speedSewnsorsTypeCode.ToDescription(),
                    GetComponentProperties(typeof(PMR.Hardware.HardwareSpeedSensor)),
                    motor1,
                    motor2);

                collection.Components.Add(componentResult);
            }
            return collection;
        }
        private HardwareComponentCollectionCompareResult CompareBlowersCollection(PMR.Hardware.HardwareConfiguration h1, PMR.Hardware.HardwareConfiguration h2)
        {
            HardwareComponentCollectionCompareResult collection = new HardwareComponentCollectionCompareResult()
            {
                CollectionName = "BLOWERS"
            };
            foreach (var blowersTypeCode in Enum.GetValues(typeof(PMR.Hardware.HardwareBlowerType)).Cast<PMR.Hardware.HardwareBlowerType>())
            {
                var motor1 = h1.Blowers.SingleOrDefault(x => x.HardwareBlowerType.ToInt32() == blowersTypeCode.ToInt32());
                var motor2 = h2.Blowers.SingleOrDefault(x => x.HardwareBlowerType.ToInt32() == blowersTypeCode.ToInt32());

                var componentResult = CompareComponents(
                    blowersTypeCode.ToDescription(),
                    GetComponentProperties(typeof(PMR.Hardware.HardwareBlower)),
                    motor1,
                    motor2);

                collection.Components.Add(componentResult);
            }
            return collection;
        }
        private HardwareComponentCollectionCompareResult CompareBreakSensorCollection(PMR.Hardware.HardwareConfiguration h1, PMR.Hardware.HardwareConfiguration h2)
        {
            HardwareComponentCollectionCompareResult collection = new HardwareComponentCollectionCompareResult()
            {
                CollectionName = "BREAK SENSOR"
            };
            foreach (var breakSewnsorsTypeCode in Enum.GetValues(typeof(PMR.Hardware.HardwareBreakSensorType)).Cast<PMR.Hardware.HardwareBreakSensorType>())
            {
                var motor1 = h1.BreakSensors.SingleOrDefault(x => x.HardwareBreakSensorType.ToInt32() == breakSewnsorsTypeCode.ToInt32());
                var motor2 = h2.BreakSensors.SingleOrDefault(x => x.HardwareBreakSensorType.ToInt32() == breakSewnsorsTypeCode.ToInt32());

                var componentResult = CompareComponents(
                    breakSewnsorsTypeCode.ToDescription(),
                    GetComponentProperties(typeof(PMR.Hardware.HardwareBreakSensor)),
                    motor1,
                    motor2);

                collection.Components.Add(componentResult);
            }
            return collection;
        }

        private HardwareComponentCompareResult CompareComponents(String name, List<PropertyInfo> properties, Object component1, Object component2)
        {
            HardwareComponentCompareResult result = new HardwareComponentCompareResult();
            result.ComponentName = name;
            result.HasComponent1 = component1 != null;
            result.HasComponent2 = component2 != null;

            foreach (var prop in properties)
            {
                var hProp = new HardwareComponentPropertyResult();
                hProp.PropertyName = prop.Name;
                hProp.Value1 = component1 != null ? (prop.GetValue(component1) == null ? "" : prop.GetValue(component1).ToString()) : null;
                hProp.Value2 = component2 != null ? (prop.GetValue(component2) == null ? "" : prop.GetValue(component2).ToString()) : null;
              
                result.Properties.Add(hProp);
            }

            return result;
        }

        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();
        }
       public PMR.Hardware.HardwareConfiguration CreateHardwareVersionFromJson(string json)
        {
            try
            {
                var tmpObj = JContainer.Parse(json);
            }
            catch (FormatException fex)
            {
                Console.WriteLine(fex);
            }
            catch (Exception ex) //some other exception
            {
                Console.WriteLine(ex.ToString());
            }
            var jsonSettings = new JsonSerializerSettings
            {
                NullValueHandling = NullValueHandling.Ignore,
                MissingMemberHandling = MissingMemberHandling.Ignore
            };
            PMR.Hardware.HardwareConfiguration hversion = JsonConvert.DeserializeObject<PMR.Hardware.HardwareConfiguration>(json, jsonSettings);
            
            return hversion;
        }
        #endregion Compare
    }

}