using System;
using System.ComponentModel;
using System.Threading.Tasks;
using System.Windows;
using DTS.Common.Base;
using DTS.Common.Classes.Sensors;
using DTS.Common.Enums.Sensors;
using DTS.Common.Events;
using DTS.Common.Interactivity;
using DTS.Common.Interface;
using Prism.Events;
using Prism.Regions;
using Unity;

namespace DTS.Viewer.ViewerSettings
{
    public class ViewerSettingsViewModel : BaseViewModel<IViewerSettingsViewModel>, IViewerSettingsViewModel
    {
        public IViewerSettingsView View { get; set; }
        public IBaseViewModel Parent { get; set; }
        private IEventAggregator _eventAggregator { get; set; }

        private IUnityContainer _unityContainer { get; set; }
        public InteractionRequest<Notification> NotificationRequest { get; private set; }
        public new InteractionRequest<Confirmation> ConfirmationRequest { get; private set; }

        /// <summary>
        /// Creates a new instance of the TestSummaryViewListModel.
        /// </summary>
        /// <param name="view">The TestSummaryList View interface.</param>
        /// <param name="regionManager">The logical placeholder defined within the application's UI (in the shell or within views) into which views are displayed.</param>
        /// <param name="eventAggregator">The EventAggregator which allows different components to publish/subscribe to events without being coupled to each other.</param>
        /// <param name="unityContainer">The unityContainer.</param>
        public ViewerSettingsViewModel(IViewerSettingsView view, IRegionManager regionManager, IEventAggregator eventAggregator,
            IUnityContainer unityContainer)
            : base(regionManager, eventAggregator, unityContainer)
        {
            View = view;
            View.DataContext = this;
            NotificationRequest = new InteractionRequest<Notification>();
            ConfirmationRequest = new InteractionRequest<Confirmation>();

            _eventAggregator = eventAggregator;
            _unityContainer = unityContainer;
        }

        #region Methods
        public override void Initialize() { }

        public override void Initialize(object parameter)
        {
            Parent = (IBaseViewModel)parameter;

            Subscribe();
        }

        private void Subscribe()
        {
            //event aggregator subscriptions
            _eventAggregator.GetEvent<CalibrationBehaviorSettingChangedEvent>().Subscribe(OnCalibrationBehaviorSettingChanged);
            _eventAggregator.GetEvent<CalibrationBehaviorSettableInViewerChangedEvent>().Subscribe(OnCalibrationBehaviorSettableInViewerChanged);
        }

        private void OnCalibrationBehaviorSettableInViewerChanged(bool settable)
        {
            CalibrationBehaviorSettingVisibility = settable ? Visibility.Visible : Visibility.Collapsed;
        }

        private void OnCalibrationBehaviorSettingChanged(CalibrationBehaviors cb)
        {
            _calibrationBehaviorSetting = cb;
            OnPropertyChanged("CalibrationBehaviorSetting");
        }

        public void PublishChanges()
        {
        }

        #endregion

        #region Properties
        ///<summary>
        ///Occurs when a property value changes.
        ///</summary>
        public new event PropertyChangedEventHandler PropertyChanged;
        private new void OnPropertyChanged(string propertyName)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
            if (propertyName.EndsWith("Visibility") && propertyName != "OverallSettingsVisibility")
            {
                OnPropertyChanged("OverallSettingsVisibility");
            }
        }

        /// <summary>
        /// Gets the HeaderInfo.
        /// </summary>
        public string HeaderInfo => "SettingsRegion";

        private bool _isBusy = false;
        public new bool IsBusy
        {
            get => _isBusy;
            set { _isBusy = value; OnPropertyChanged("IsBusy"); }
        }

        private bool _isDirty;
        public new bool IsDirty
        {
            get => _isDirty;
            set => _isDirty = value;
        }

        private bool _isNavigationIncluded;
        public new bool IsNavigationIncluded
        {
            get => _isNavigationIncluded;
            set => _isNavigationIncluded = value;
        }

        private Visibility _calibrationBehaviorSettingVisibility = Visibility.Visible;

        public Visibility CalibrationBehaviorSettingVisibility
        {
            get => _calibrationBehaviorSettingVisibility;
            set
            {
                _calibrationBehaviorSettingVisibility = value;
                OnPropertyChanged("CalibrationBehaviorSettingVisibility");
                _eventAggregator.GetEvent<ViewerSettingsVisibilityChangedEvent>().Publish(OverallSettingsVisibility);
            }
        }

        public Visibility OverallSettingsVisibility => (CalibrationBehaviorSettingVisibility == Visibility.Visible) ? Visibility.Visible : Visibility.Collapsed;

        #endregion

        private DisplayedCalibrationBehavior[] _availableCalibrationBehaviors = null;

        private readonly DisplayedCalibrationBehavior _linearIfAvail = new DisplayedCalibrationBehavior { CalibrationBehavior = CalibrationBehaviors.LinearIfAvailable, DisplayString = Resources.StringResources.CalibrationBehavior_LinearIfAvailable };
        private readonly DisplayedCalibrationBehavior _nonLinearIfAvail = new DisplayedCalibrationBehavior { CalibrationBehavior = CalibrationBehaviors.NonLinearIfAvailable, DisplayString = Resources.StringResources.CalibrationBehavior_NonLinearIfAvailable };
        private readonly DisplayedCalibrationBehavior _useBothIfAvail = new DisplayedCalibrationBehavior { CalibrationBehavior = CalibrationBehaviors.UseBothIfAvailable, DisplayString = Resources.StringResources.CalibrationBehavior_UseBothIfAvailable };
        private readonly object MyLock = new object();
        public DisplayedCalibrationBehavior[] AvailableCalibrationBehaviors
        {
            get
            {
                lock (MyLock)
                {
                    if (null == _availableCalibrationBehaviors)
                    {
                        _availableCalibrationBehaviors = new[] { _linearIfAvail, _nonLinearIfAvail, _useBothIfAvail };
                    }
                    return _availableCalibrationBehaviors;
                }
            }
        }

        private CalibrationBehaviors _calibrationBehaviorSetting = CalibrationBehaviors.NonLinearIfAvailable;
        public DisplayedCalibrationBehavior CalibrationBehaviorSetting
        {
            get
            {
                foreach (DisplayedCalibrationBehavior dcb in AvailableCalibrationBehaviors)
                {
                    if (dcb.CalibrationBehavior == _calibrationBehaviorSetting)
                    {
                        return dcb;
                    }
                }
                return null;
            }
            set
            {
                if (value.CalibrationBehavior != _calibrationBehaviorSetting)
                {
                    _calibrationBehaviorSetting = value.CalibrationBehavior;
                    _eventAggregator.GetEvent<CalibrationBehaviorSettingChangedEvent>().Publish(value.CalibrationBehavior);
                }
                OnPropertyChanged("CalibrationBehaviorSetting");
            }
        }
    }
}