using System;
using System.ComponentModel;
using System.ComponentModel.Composition;
using System.Threading.Tasks;
using System.Windows;
using DTS.Common.Events;
using DTS.Common.Interface;
using DTS.Common.Interface.TestSetups.Imports.TTS.ReadFile;
using Prism.Events;
using Unity;
using DTS.Common.Interactivity;
using Prism.Regions;
using Prism.Commands;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using DTS.Common;
using DTS.Common.Interface.DataRecorders;
using DTS.Common.Base;
using DTS.Common.Classes;
using DTS.Common.Enums;
using DTS.Common.Events.TTSImport;
using TTSImport.Model;
using TTSImport.Resources;

// ReSharper disable CheckNamespace
// ReSharper disable MemberCanBePrivate.Global
// ReSharper disable InconsistentNaming

namespace TTSImport
{
    /// <summary>
    /// this class handles Summary functionality
    /// </summary>
    [PartCreationPolicy(CreationPolicy.Shared)]
    public class SummaryViewModel : ISummaryViewModel
    {
        /// <summary>
        /// The Status and Progress bars
        /// </summary>
        public IStatusAndProgressBarView StatusAndProgressBarView { get; private set; }

        /// <summary>
        /// The Summary view
        /// </summary>
        public ISummaryView View { get; set; }

        private IEventAggregator _eventAggregator { get; set; }
        private IRegionManager _regionManager;
        private IUnityContainer UnityContainer { get; set; }

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

        /// <summary>
        /// Creates a new instance of the TechnologyDomainEditViewModel.
        /// </summary>
        /// <param name="view"></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 SummaryViewModel(ISummaryView view, IRegionManager regionManager, IEventAggregator eventAggregator,
            IUnityContainer unityContainer)
        {
            View = view;
            View.DataContext = this;

            NotificationRequest = new InteractionRequest<Notification>();
            ConfirmationRequest = new InteractionRequest<Confirmation>();

            _eventAggregator = eventAggregator;
            UnityContainer = unityContainer;
            _regionManager = regionManager;
            _eventAggregator.GetEvent<RaiseNotification>().Subscribe(OnRaiseNotification);
            _eventAggregator.GetEvent<BusyIndicatorChangeNotification>().Subscribe(OnBusyIndicatorNotification, ThreadOption.PublisherThread, true);
            _eventAggregator.GetEvent<TTSImportReadFileStatusEvent>().Subscribe(OnReadFileFinished, ThreadOption.PublisherThread, true);
            _eventAggregator.GetEvent<TTSImportTestSetupChangedEvent>().Subscribe(OnTestSetupChanged, ThreadOption.PublisherThread, true);

        }

        #region Methods

        public void Cleanup()
        {
        }

        public Task CleanupAsync()
        {
            return Task.CompletedTask;
        }

        public void Initialize()
        {
        }

        public void Initialize(object parameter)
        {
        }

        public void Initialize(object parameter, object model)
        {
        }

        public Task InitializeAsync()
        {
            StatusAndProgressBarView = GetStatusAndProgressBarView(this);
            return Task.CompletedTask;
        }

        public Task InitializeAsync(object parameter)
        {
            return Task.CompletedTask;
        }

        public void Activated()
        {
        }

        /// <summary>
        /// Private Event handler for RaiseNotification event.
        /// </summary>
        private void OnBusyIndicatorNotification(bool eventArg)
        {
            IsBusy = eventArg;
        }

        /// <summary>
        /// Private Event handler for RaiseNotification event.
        /// </summary>
        private void OnRaiseNotification(NotificationContentEventArgs eventArgsWithTitle)
        {
            // The NotificationRequest.Raise triggers the Invoke() method of the PopupWindowAction object to show the NotificationWindow window
            // Notification object expects a NotificationContentEventArgsWithoutTitle object and a Title string.
            var eventArgsWithoutTitle = new NotificationContentEventArgs(eventArgsWithTitle.Message, "",
                eventArgsWithTitle.Image, string.Empty);

            NotificationRequest.Raise(new Notification
            {
                Content = eventArgsWithoutTitle,
                Title = eventArgsWithTitle.Title
            });
        }

        public string GetTestId()
        {
            return null == View ? "" : View.GetTestId();
        }
        private void OnReadFileFinished(ReadFileStatusArg statusArg)
        {
            TestSetupImported = false;
            if (!statusArg.Status) return;
            _setup = statusArg.TTSSetup;
            View?.SetTestName(_setup.TestId);
            OnPropertyChanged(PropertyNames.ImportFileName.ToString());
            OnPropertyChanged(PropertyNames.TestSetupName.ToString());
            OnPropertyChanged(PropertyNames.SampleRate.ToString());
            OnPropertyChanged(PropertyNames.RecordingMode.ToString());
            OnPropertyChanged(PropertyNames.TestLength.ToString());
            OnPropertyChanged(PropertyNames.PreTrigger.ToString());
            OnPropertyChanged(PropertyNames.PostTrigger.ToString());
            OnPropertyChanged(PropertyNames.ROIStart.ToString());
            OnPropertyChanged(PropertyNames.ROIEnd.ToString());
            OnPropertyChanged(PropertyNames.AAF_TDAS.ToString());
            OnPropertyChanged(PropertyNames.AAF_SLICE.ToString());
        }
        private void OnTestSetupChanged(ITTSSetup setup)
        {
            TestSetupImported = false;
        }
        public void UpdateUI()
        {
            SampleRate = _setup.SampleRate;
            SetAvailableRecordingModes();
            RecordingMode = _setup.Mode;
            SetChannelList();
            TestSetupComplete = !SummaryChannelList.Exists(channelType => (channelType.Unassigned != "0") && (channelType.Unassigned != Resources.StringResources.Table_NA));
            if (!TestSetupComplete || Array.Exists(_setup.Channels, channel => channel.IsModified) || Array.Exists(_setup.LevelTriggers, levelTrigger => levelTrigger.IsModified))
            {
                TestSetupImported = false;
            }
        }

        private List<double> _availableSampleRates = new List<double>();
        public List<double> AvailableSampleRates
        {
            get => _availableSampleRates;
            set
            {
                _availableSampleRates = value;
                OnPropertyChanged("AvailableSampleRates");
            }
        }
        public void SetAvailableSampleRates(int[] values)
        {
            AvailableSampleRates.Clear();

            var minSampleRate = (double)values.Min();
            var maxSampleRate = (double)values.Max();
            foreach (var channel in _setup.Channels)
            {
                if (channel.HardwareChannel == null) continue;
                minSampleRate = Math.Max(channel.HardwareChannel.GetParentDAS().GetMinSampleRateDouble(), minSampleRate);
                maxSampleRate = Math.Min(channel.HardwareChannel.GetParentDAS().GetMaxSampleRateDouble(), maxSampleRate);
            }
            foreach (var sampleRate in values)
            {
                if (sampleRate >= minSampleRate && sampleRate <= maxSampleRate)
                {
                    AvailableSampleRates.Add(sampleRate);
                }
            }
        }

        public string AAF_TDAS => string.Format(StringResources.AAF_TDAS, !_aafExceptions.ContainsKey(SampleRate) ? (SampleRate / 5) : _aafExceptions[SampleRate][0]);
        public string AAF_SLICE => string.Format(StringResources.AAF_SLICE, !_aafExceptions.ContainsKey(SampleRate) ? (SampleRate / 5) : _aafExceptions[SampleRate][1]);

        private Dictionary<double, List<double>> _aafExceptions = new Dictionary<double, List<double>>();
        public void SetAAFExceptions(Dictionary<double, List<double>> values)
        {
            _aafExceptions.Clear();
            _aafExceptions = values;
        }

        public List<RecordingModes> AvailableRecordingModes { get; } = new List<RecordingModes>();

        private void SetAvailableRecordingModes()
        {
            AvailableRecordingModes.Clear();

            AvailableRecordingModes.Add(RecordingModes.CircularBuffer);
            AvailableRecordingModes.Add(RecordingModes.Recorder);
            if (_setup.AllowAdvancedRecordingModes)
            {
                AvailableRecordingModes.Add(RecordingModes.HybridRecorder);
            }
        }

        public void SetSerializedTestIdValues(string[] values)
        {
            View?.UpdateTestIds(values);
        }
        /// <summary>
        /// Fill in the table of channels, including those added after the file was read
        /// </summary>
        public void SetChannelList()
        {
            const int Assigned = 0;
            const int Unassigned = 1;

            var analogChannels = new[] { 0, 0 };
            var tomChannels = new[] { 0, 0 };
            var digitalInChannels = new[] { 0, 0 };
            var levelTriggers = new[] { 0, 0 };

            foreach (var channelRecord in _setup.Channels)
            {
                if (string.Equals(channelRecord.ChannelCode, TTSChannelRecord.NONE, StringComparison.CurrentCultureIgnoreCase) || channelRecord.Disabled) continue;
                if (channelRecord.IsSquib)
                {
                    if (channelRecord.HardwareChannel != null && channelRecord.HardwareChannel.IsSquib)
                    {
                        tomChannels[Assigned] += 1;
                    }
                    else
                    {
                        tomChannels[Unassigned] += 1;
                    }
                }
                else if (channelRecord.IsDigitalInput)
                {
                    if (channelRecord.HardwareChannel != null && channelRecord.HardwareChannel.IsDigitalIn)
                    {
                        digitalInChannels[Assigned] += 1;
                    }
                    else
                    {
                        digitalInChannels[Unassigned] += 1;
                    }
                }
                else if (!channelRecord.IsDigitalOutput)
                {
                    if (channelRecord.HardwareChannel != null && channelRecord.HardwareChannel.IsAnalog)
                    {
                        analogChannels[Assigned] += 1;
                    }
                    else
                    {
                        analogChannels[Unassigned] += 1;
                    }
                }
            }

            foreach (var levelTrigger in _setup.LevelTriggers)
            {
                if (!string.IsNullOrWhiteSpace(levelTrigger.Code))
                {
                    levelTriggers[Assigned] += 1;
                }
            }

            var temp = new List<SummaryChannel>();
            var channel = new SummaryChannel
            {
                ChannelType = "Analog", //internationalize these
                Assigned = analogChannels[Assigned],
                Unassigned = analogChannels[Unassigned].ToString()
            };
            temp.Add(channel);

            channel = new SummaryChannel
            {
                ChannelType = "TOM",
                Assigned = tomChannels[Assigned],
                Unassigned = tomChannels[Unassigned].ToString()
            };
            temp.Add(channel);

            channel = new SummaryChannel
            {
                ChannelType = "Digital In",
                Assigned = digitalInChannels[Assigned],
                Unassigned = digitalInChannels[Unassigned].ToString()
            };
            temp.Add(channel);

            channel = new SummaryChannel
            {
                ChannelType = "Level Trigger",
                Assigned = levelTriggers[Assigned],
                Unassigned = Resources.StringResources.Table_NA
            };
            temp.Add(channel);

            SummaryChannelList = temp;
        }

        private readonly StatusAndProgressBarEventArgs statusAndProgressBarEventArgs = new StatusAndProgressBarEventArgs();

        /// <summary>
        /// Sets the text, background color, progress value, and/or progress visibility
        /// </summary>
        /// <param name="status"></param>
        /// <param name="error"></param>
        public void SetStatus(string status, string error = default(string)) //default(string) is null
        {
            switch (status)
            {
                case "Waiting": //change this to string resources but use the same one in DataPRO and here???
                    statusAndProgressBarEventArgs.StatusColor = BrushesAndColors.Brush_ApplicationStatus_Waiting.Color;
                    statusAndProgressBarEventArgs.ProgressBarVisibility = Visibility.Collapsed;
                    break;
                case "Working":
                    statusAndProgressBarEventArgs.StatusColor = BrushesAndColors.Brush_ApplicationStatus_Busy.Color;
                    statusAndProgressBarEventArgs.ProgressValue = 0;
                    statusAndProgressBarEventArgs.ProgressBarVisibility = Visibility.Visible;
                    break;
                case "Failed":
                    TestSetupImported = false;
                    statusAndProgressBarEventArgs.StatusColor = BrushesAndColors.Brush_ApplicationStatus_Failed.Color;
                    statusAndProgressBarEventArgs.ProgressBarVisibility = Visibility.Collapsed;
                    break;
                case "Done":
                    TestSetupImported = true;
                    foreach (var ch in _setup.Channels)
                    {
                        ch.IsModified = false;
                    }
                    foreach (var lt in _setup.LevelTriggers)
                    {
                        lt.IsModified = false;
                    }
                    statusAndProgressBarEventArgs.StatusColor = BrushesAndColors.Brush_ApplicationStatus_Complete.Color;
                    statusAndProgressBarEventArgs.ProgressBarVisibility = Visibility.Collapsed;
                    break;
            }
            if (!string.IsNullOrEmpty(error))
            {
                statusAndProgressBarEventArgs.StatusText = status + " - " + error;
            }
            else
            {
                statusAndProgressBarEventArgs.StatusText = status;
            }

            statusAndProgressBarEventArgs.Requester = this;
            _eventAggregator.GetEvent<StatusAndProgressBarEvent>().Publish(statusAndProgressBarEventArgs);
        }

        /// <summary>
        /// Sets the progress value on the Status and Progress bar
        /// </summary>
        /// <param name="progress"></param>
        public void SetProgress(double progress)
        {
            statusAndProgressBarEventArgs.ProgressValue = (int)progress;
            statusAndProgressBarEventArgs.Requester = this;
            _eventAggregator.GetEvent<StatusAndProgressBarEvent>().Publish(statusAndProgressBarEventArgs);
        }

        private IStatusAndProgressBarView GetStatusAndProgressBarView(IBaseViewModel parent)
        {
            var view = UnityContainer.Resolve<IStatusAndProgressBarView>();
            var viewModel = UnityContainer.Resolve<IStatusAndProgressBarViewModel>();
            view.DataContext = viewModel;
            viewModel.Initialize(parent);
            return view;
        }

        #endregion

        #region Properties

        private ITTSSetup _setup;
        public bool IsDirty { get; private set; }
        private bool _isBusy = false;

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

        private bool _isMenuIncluded = false;

        public bool IsMenuIncluded
        {
            get => _isMenuIncluded;
            set
            {
                _isMenuIncluded = value;
                OnPropertyChanged("IsMenuIncluded");
            }
        }

        private bool _isNavigationIncluded = false;

        public bool IsNavigationIncluded
        {
            get => _isNavigationIncluded;
            set
            {
                _isNavigationIncluded = value;
                OnPropertyChanged("IsNavigationIncluded");
            }
        }

        private List<SummaryChannel> _summaryChannelList = new List<SummaryChannel>();

        public List<SummaryChannel> SummaryChannelList
        {
            get => _summaryChannelList;
            set
            {
                _summaryChannelList = value;
                OnPropertyChanged("SummaryChannelList");
            }
        }

        private bool _testSetupComplete;
        public bool TestSetupComplete
        {
            get => _testSetupComplete;
            set
            {
                _testSetupComplete = value;
                OnPropertyChanged("ImportEnabled");
            }
        }

        private bool _testSetupImported;
        public bool TestSetupImported
        {
            get => _testSetupImported;
            set
            {
                _testSetupImported = value;
                OnPropertyChanged("RunTestVisible");
            }
        }

        public bool ImportEnabled => TestSetupComplete & IsROIValid;

        public Visibility RunTestVisible => TestSetupImported ? Visibility.Visible : Visibility.Hidden;
        public Visibility SummaryPreTriggerVisibility => RecordingMode == RecordingModes.CircularBuffer ? Visibility.Visible : Visibility.Collapsed;
        public string PostTriggerOrTestLength => RecordingMode == RecordingModes.CircularBuffer ? StringResources.PostTrigger : StringResources.TestLength;

        private bool _isROIStartValid = true;

        public bool IsROIStartValid
        {
            get => _isROIStartValid;
            set
            {
                _isROIStartValid = value;
                OnPropertyChanged("IsROIStartValid");
            }
        }
        private bool _isROIEndValid = true;

        public bool IsROIEndValid
        {
            get => _isROIEndValid;
            set
            {
                _isROIEndValid = value;
                OnPropertyChanged("IsROIEndValid");
            }
        }

        private void CalculateROIValid()
        {
            if (null == _setup)
            {
                IsROIEndValid = true;
                IsROIStartValid = true;
                return;
            }

            if (_setup.ROIEnd < _setup.ROIStart)
            {
                IsROIStartValid = false;
                IsROIEndValid = false;
                return;
            }
            if (RecordingMode == RecordingModes.Recorder)
            {
                IsROIStartValid = true;
                IsROIEndValid = !(_setup.ROIEnd - _setup.ROIStart > _setup.PostTrigger);
            }
            else
            {
                IsROIEndValid = !(_setup.ROIEnd > _setup.PostTrigger);
                IsROIStartValid = !(Math.Abs(_setup.ROIStart) > _setup.PreTrigger);
            }
        }
        public bool IsROIValid
        {
            get
            {
                CalculateROIValid();
                return IsROIStartValid && IsROIEndValid;
            }
        }
        //=> RecordingMode != RecordingModes.Recorder || !(_setup.ROIEnd - _setup.ROIStart > _setup.PostTrigger);

        #endregion Properties

        #region Commands

        /// <summary>
        /// browse to a file to import, should be xml, maybe needs a few other criteria
        /// </summary>
        private DelegateCommand _importCommand;

        public DelegateCommand ImportClicked => _importCommand ?? (_importCommand = new DelegateCommand(ImportMethod));

        private void ImportMethod()
        {
            _eventAggregator.GetEvent<TTSImportSummaryImportEvent>().Publish(_setup);
        }

        /// <summary>
        /// Run the test since the Run Test button was clicked
        /// </summary>
        private DelegateCommand _runTestCommand;

        public DelegateCommand RunTestClicked =>
            _runTestCommand ?? (_runTestCommand = new DelegateCommand(RunTestMethod));

        private void RunTestMethod()
        {
            SetStatus(Resources.StringResources.ImportTestSetup_PossibleStatus_Working); //use string resource (same both here and where passed)
            ThreadPool.QueueUserWorkItem(RunTestWorkThread, null);
        }
        void RunTestWorkThread(object obj)
        {
            _eventAggregator.GetEvent<TTSImportSummaryRunTestEvent>().Publish(_setup);
        }

        #endregion

        #region properties

        /// <summary>
        /// all properties that are exposed
        /// </summary>
        public enum PropertyNames
        {
            ImportFileName,
            TestSetupName,
            SampleRate,
            RecordingMode,
            TestLength,
            PreTrigger,
            PostTrigger,
            ROIStart,
            ROIEnd,
            AAF_TDAS,
            AAF_SLICE,
            AllowAdvancedRecordingModes,
            AllowTSRAIRRecordingModes
        }

        /// <summary>
        /// full path to import file
        /// </summary>
        public string ImportFileName => _setup?.Filename ?? "";

        public string TestSetupName
        {
            get => _setup?.TestId ?? "";
            set
            {
                TestSetupImported = false;
                _setup.TestId = value;
                View?.SetTestName(_setup.TestId);
            }
        }

        public double SampleRate
        {
            get => _setup?.SampleRate ?? 10000;
            set
            {
                if (_setup.SampleRate != value)
                {
                    TestSetupImported = false;
                    _setup.SampleRate = value;
                }
                OnPropertyChanged(PropertyNames.SampleRate.ToString());
                OnPropertyChanged(PropertyNames.AAF_TDAS.ToString());
                OnPropertyChanged(PropertyNames.AAF_SLICE.ToString());
            }
        }

        private void OnPropertyChanged(PropertyNames sampleRate)
        {
            throw new NotImplementedException();
        }

        public RecordingModes RecordingMode
        {
            get => _setup?.Mode ?? RecordingModes.CircularBuffer;
            set
            {
                if (_setup.Mode != value)
                {
                    TestSetupImported = false;
                    switch (value)
                    {
                        case RecordingModes.CircularBuffer:
                        case RecordingModes.Recorder:
                        case RecordingModes.HybridRecorder:
                            _setup.Mode = value;
                            break;
                        default:
                            _setup.Mode = RecordingModes.CircularBuffer;
                            break;
                    }
                }
                OnPropertyChanged("RecordingMode");
                OnPropertyChanged("SummaryPreTriggerVisibility");
                OnPropertyChanged("PostTriggerOrTestLength");
                OnPropertyChanged("IsROIValid");
                OnPropertyChanged("ImportEnabled");
            }
        }

        public string PreTrigger
        {
            get => _setup?.PreTrigger.ToString("0.00") ?? "";
            set
            {
                if (!double.TryParse(value, out double preTrigger)) return;
                //if (preTrigger * -1 > _setup.ROIStart) ROIStart = (preTrigger * -1).ToString("0.00");
                //if (preTrigger * -1 > _setup.ROIEnd) ROIEnd = (preTrigger * -1).ToString("0.00");
                TestSetupImported = false;
                _setup.PreTrigger = preTrigger;
                OnPropertyChanged("PreTrigger");

                OnPropertyChanged("IsROIValid");
                OnPropertyChanged("ImportEnabled");
            }
        }

        public string PostTrigger
        {
            get => _setup?.PostTrigger.ToString("0.00") ?? "";
            set
            {
                if (!double.TryParse(value, out double postTrigger)) return;
                //if (postTrigger < _setup.ROIStart) ROIStart = postTrigger.ToString("0.00");
                //if (postTrigger < _setup.ROIEnd) ROIEnd = postTrigger.ToString("0.00");
                TestSetupImported = false;
                _setup.PostTrigger = postTrigger;
                OnPropertyChanged("PostTrigger");

                OnPropertyChanged("IsROIValid");
                OnPropertyChanged("ImportEnabled");
            }
        }

        public string ROIStart
        {
            get => _setup?.ROIStart.ToString("0.00") ?? "";
            set
            {
                if (!double.TryParse(value, out double roiStart)) return;
                if (roiStart < _setup.PreTrigger * -1 || roiStart > _setup.PostTrigger || roiStart > _setup.ROIEnd) return;
                TestSetupImported = false;
                _setup.ROIStart = roiStart;
                OnPropertyChanged("ROIStart");

                OnPropertyChanged("IsROIValid");
                OnPropertyChanged("ImportEnabled");
            }
        }

        public string ROIEnd
        {
            get => _setup?.ROIEnd.ToString("0.00") ?? "";
            set
            {
                if (!double.TryParse(value, out double roiEnd)) return;
                if (roiEnd < _setup.PreTrigger * -1 || roiEnd > _setup.PostTrigger || roiEnd < _setup.ROIStart) return;
                TestSetupImported = false;
                _setup.ROIEnd = roiEnd;
                OnPropertyChanged("ROIEnd");

                OnPropertyChanged("IsROIValid");
                OnPropertyChanged("ImportEnabled");
            }
        }

        #endregion

        ///<summary>
        ///Occurs when a property value changes.
        ///</summary>
        public event PropertyChangedEventHandler PropertyChanged;

        public void OnPropertyChanged(string propertyName)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }
}