using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Data;
using Tango.BL.Enumerations;
using Tango.Core.Commands;
using Tango.Core.DI;
using Tango.FSE.Common;
using Tango.FSE.Common.Connection;
using Tango.FSE.Common.Dialogs;
using Tango.FSE.Common.Helpers;
using Tango.Integration.Logging;
using Tango.Logging;
using Tango.SharedUI.Components;

namespace Tango.FSE.UI.Panes
{
    /// <summary>
    /// Represents the log viewer pane view model.
    /// </summary>
    /// <seealso cref="Tango.FSE.Common.FSEViewModel" />
    public class LogViewerPaneVM : FSEViewModel
    {
        private List<LogItemBase> _pausedFSELogs;
        private List<LogItemBase> _pausedApplicationLogs;
        private List<EmbeddedLogItem> _pausedFirmwareLogs;
        private const int MAX_LOGS = 100000; //100,000

        /// <summary>
        /// Gets a value indicating whether the current user has FSE logs permission.
        /// </summary>
        public bool HasFSELogsPermission
        {
            get { return CurrentUser != null && CurrentUser.HasPermission(Permissions.FSE_ViewFSELogs); }
        }

        /// <summary>
        /// Gets or sets the FSE logs.
        /// </summary>
        public ObservableCollection<LogItemBase> FSELogs { get; set; }

        /// <summary>
        /// Gets or sets the application logs.
        /// </summary>
        public ObservableCollection<LogItemBase> ApplicationLogs { get; set; }

        /// <summary>
        /// Gets or sets the firmware logs.
        /// </summary>
        public ObservableCollection<EmbeddedLogItem> FirmwareLogs { get; set; }

        /// <summary>
        /// Gets or sets the FSE logs view.
        /// </summary>
        public ICollectionView FSELogsView { get; set; }

        /// <summary>
        /// Gets or sets the application logs view.
        /// </summary>
        public ICollectionView ApplicationLogsView { get; set; }

        /// <summary>
        /// Gets or sets the firmware logs view.
        /// </summary>
        public ICollectionView FirmwareLogsView { get; set; }

        /// <summary>
        /// Gets or sets the selected FSE logs categories.
        /// </summary>
        public SelectedObjectCollection<LogCategory> SelectedFSELogsCategories { get; set; }

        /// <summary>
        /// Gets or sets the selected application logs categories.
        /// </summary>
        public SelectedObjectCollection<LogCategory> SelectedApplicationLogsCategories { get; set; }

        /// <summary>
        /// Gets or sets the selected firmware logs categories.
        /// </summary>
        public SelectedObjectCollection<LogCategory> SelectedFirmwareLogsCategories { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether to pause the insertion of FSE logs.
        /// </summary>
        public bool FSELogsPaused { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether to pause the insertion of application logs.
        /// </summary>
        public bool ApplicationLogsPaused { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether to pause the insertion of firmware logs.
        /// </summary>
        public bool FirmwareLogsPaused { get; set; }

        private String _fseLogsFilter;
        /// <summary>
        /// Gets or sets the application logs filter.
        /// </summary>
        public String FSELogsFilter
        {
            get { return _fseLogsFilter; }
            set { _fseLogsFilter = value; RaisePropertyChangedAuto(); FSELogsView.Refresh(); }
        }

        private String _applicationLogsFilter;
        /// <summary>
        /// Gets or sets the application logs filter.
        /// </summary>
        public String ApplicationLogsFilter
        {
            get { return _applicationLogsFilter; }
            set { _applicationLogsFilter = value; RaisePropertyChangedAuto(); ApplicationLogsView.Refresh(); }
        }

        private String _firmwareLogsFilter;
        /// <summary>
        /// Gets or sets the firmware logs filter.
        /// </summary>
        public String FirmwareLogsFilter
        {
            get { return _firmwareLogsFilter; }
            set { _firmwareLogsFilter = value; RaisePropertyChangedAuto(); FirmwareLogsView.Refresh(); }
        }

        /// <summary>
        /// Clears the FSE logs.
        /// </summary>
        public RelayCommand ClearFSELogsCommand { get; set; }

        /// <summary>
        /// Clears the application logs.
        /// </summary>
        public RelayCommand ClearApplicationLogsCommand { get; set; }

        /// <summary>
        /// Clears the firmware logs.
        /// </summary>
        public RelayCommand ClearFirmwareLogsCommand { get; set; }

        /// <summary>
        /// Opens the detailed FSE log dialog.
        /// </summary>
        public RelayCommand<LogItemBase> OpenFSELogItemCommand { get; set; }

        /// <summary>
        /// Opens the detailed application log dialog.
        /// </summary>
        public RelayCommand<LogItemBase> OpenApplicationLogItemCommand { get; set; }

        /// <summary>
        /// Opens the detailed firmware log dialog.
        /// </summary>
        public RelayCommand<EmbeddedLogItem> OpenFirmareLogItemCommand { get; set; }

        /// <summary>
        /// Initializes a new instance of the <see cref="LogViewerPaneVM"/> class.
        /// </summary>
        public LogViewerPaneVM()
        {
            _pausedFSELogs = new List<LogItemBase>();
            _pausedApplicationLogs = new List<LogItemBase>();
            _pausedFirmwareLogs = new List<EmbeddedLogItem>();

            FSELogs = new ObservableCollection<LogItemBase>();
            ApplicationLogs = new ObservableCollection<LogItemBase>();
            FirmwareLogs = new ObservableCollection<EmbeddedLogItem>();

            FSELogsView = CollectionViewSource.GetDefaultView(FSELogs);
            ApplicationLogsView = CollectionViewSource.GetDefaultView(ApplicationLogs);
            FirmwareLogsView = CollectionViewSource.GetDefaultView(FirmwareLogs);

            FSELogsView.Filter = (log) => FilterLogsFunc(log as LogItemBase, FSELogsFilter);
            ApplicationLogsView.Filter = (log) => FilterLogsFunc(log as LogItemBase, ApplicationLogsFilter);
            FirmwareLogsView.Filter = (log) => FilterLogsFunc(log as LogItemBase, FirmwareLogsFilter);

            SelectedFSELogsCategories = new SelectedObjectCollection<LogCategory>(new ObservableCollection<LogCategory>()
            {
                LogCategory.Info,
                LogCategory.Warning,
                LogCategory.Error,
                LogCategory.Critical,
            }, new ObservableCollection<LogCategory>()
            {
                LogCategory.Info,
                LogCategory.Warning,
                LogCategory.Error,
                LogCategory.Critical,
            });

            SelectedApplicationLogsCategories = new SelectedObjectCollection<LogCategory>(new ObservableCollection<LogCategory>()
            {
                LogCategory.Info,
                LogCategory.Warning,
                LogCategory.Error,
                LogCategory.Critical,
            }, new ObservableCollection<LogCategory>()
            {
                LogCategory.Info,
                LogCategory.Warning,
                LogCategory.Error,
                LogCategory.Critical,
            });

            SelectedFirmwareLogsCategories = new SelectedObjectCollection<LogCategory>(new ObservableCollection<LogCategory>()
            {
                LogCategory.Info,
                LogCategory.Warning,
                LogCategory.Error,
                LogCategory.Critical,
                LogCategory.Debug,
            }, new ObservableCollection<LogCategory>()
            {
                LogCategory.Info,
                LogCategory.Warning,
                LogCategory.Error,
                LogCategory.Critical,
                LogCategory.Debug,
            });

            SelectedFSELogsCategories.SynchedSource.CollectionChanged += (_, __) => FSELogsView?.Refresh();
            SelectedApplicationLogsCategories.SynchedSource.CollectionChanged += (_, __) => ApplicationLogsView?.Refresh();
            SelectedFirmwareLogsCategories.SynchedSource.CollectionChanged += (_, __) => FirmwareLogsView?.Refresh();

            ClearFSELogsCommand = new RelayCommand(ClearFSELogs);
            ClearApplicationLogsCommand = new RelayCommand(ClearApplicationLogs);
            ClearFirmwareLogsCommand = new RelayCommand(ClearFirmwareLogs);

            TangoIOC.Default.Inject(this);

            var appStartLogs = LogsHelper.GetLogSafe().EmptyAndDispose();

            foreach (var log in appStartLogs)
            {
                FSELogs.Insert(0, log);
            }

            LoggingProvider.FSELogAvailable += LoggingProvider_FSELogAvailable;
            LoggingProvider.ApplicationLogAvailable += LoggingProvider_ApplicationLogAvailable;
            LoggingProvider.FirmwareLogAvailable += LoggingProvider_FirmwareLogAvailable;

            OpenFSELogItemCommand = new RelayCommand<LogItemBase>(OpenFSELogItem);
            OpenApplicationLogItemCommand = new RelayCommand<LogItemBase>(OpenApplicationLogItem);
            OpenFirmareLogItemCommand = new RelayCommand<EmbeddedLogItem>(OpenFirmwareLogItem);

            MachineProvider.MachineConnected += MachineProvider_MachineConnected;
            AuthenticationProvider.CurrentUserChanged += AuthenticationProvider_CurrentUserChanged;
        }

        private void AuthenticationProvider_CurrentUserChanged(object sender, Tango.BL.Entities.User e)
        {
            RaisePropertyChanged(nameof(HasFSELogsPermission));
        }

        private void MachineProvider_MachineConnected(object sender, MachineConnectedEventArgs e)
        {
            if (e.DifferentFromPrevious)
            {
                InvokeUI(() =>
                {
                    ClearApplicationLogs();
                    ClearFirmwareLogs();
                });
            }
        }

        private async void OpenFSELogItem(LogItemBase logItem)
        {
            await NotificationProvider.ShowDialog(new ApplicationLogItemViewVM() { LogItem = logItem });
        }

        private async void OpenApplicationLogItem(LogItemBase logItem)
        {
            await NotificationProvider.ShowDialog(new ApplicationLogItemViewVM() { LogItem = logItem });
        }

        private async void OpenFirmwareLogItem(EmbeddedLogItem logItem)
        {
            await NotificationProvider.ShowDialog(new FirmwareLogItemViewVM() { LogItem = logItem });
        }

        private bool FilterLogsFunc(LogItemBase log, String filter)
        {
            if (log != null)
            {
                bool includeLog = false;

                if (String.IsNullOrWhiteSpace(filter)) return true;

                if (filter.Contains("|"))
                {
                    List<String> keywords = filter.Split('|').ToList();

                    if (keywords.Any(x => log.Category.ToString().ToLower() == x.ToLower()))
                    {
                        includeLog = true;
                    }
                }
                else
                {
                    if (log.Category.ToString().ToLower() == filter.ToLower())
                    {
                        includeLog = true;
                    }
                }

                if (log.TimeStamp.ToString("HH:mm:ss").Contains(filter))
                {
                    includeLog = true;
                }

                if (log.ClassName.ToLower() == filter.ToLower())
                {
                    includeLog = true;
                }

                if (log.Message.ToLower().Contains(filter.ToLower()))
                {
                    includeLog = true;
                }

                return includeLog;
            }
            else
            {
                return false;
            }
        }

        private void ClearFSELogs()
        {
            _pausedFSELogs.Clear();
            FSELogs.Clear();
        }

        private void ClearApplicationLogs()
        {
            _pausedApplicationLogs.Clear();
            ApplicationLogs.Clear();
        }

        private void ClearFirmwareLogs()
        {
            _pausedFirmwareLogs.Clear();
            FirmwareLogs.Clear();
        }

        private void LoggingProvider_FSELogAvailable(object sender, LogItemBase logItem)
        {
            if (FSELogsPaused)
            {
                _pausedFSELogs.Add(logItem);
            }
            else
            {
                InvokeUI(() =>
                {
                    if (_pausedFSELogs.Count > 0)
                    {
                        foreach (var pausedItem in _pausedFSELogs)
                        {
                            InsertFSELog(pausedItem);
                        }

                        _pausedFSELogs.Clear();
                    }

                    InsertFSELog(logItem);
                });
            }
        }

        private void InsertFSELog(LogItemBase log)
        {
            FSELogs.Insert(0, log);

            if (FSELogs.Count > MAX_LOGS)
            {
                FSELogs.RemoveAt(FSELogs.Count - 1);
            }
        }

        private void LoggingProvider_ApplicationLogAvailable(object sender, LogItemBase logItem)
        {
            if (ApplicationLogsPaused)
            {
                _pausedApplicationLogs.Add(logItem);
            }
            else
            {
                InvokeUI(() =>
                {
                    if (_pausedApplicationLogs.Count > 0)
                    {
                        foreach (var pausedItem in _pausedApplicationLogs)
                        {
                            InsertApplicationLog(pausedItem);
                        }

                        _pausedApplicationLogs.Clear();
                    }

                    InsertApplicationLog(logItem);
                });
            }
        }

        private void InsertApplicationLog(LogItemBase log)
        {
            ApplicationLogs.Insert(0, log);

            if (ApplicationLogs.Count > MAX_LOGS)
            {
                ApplicationLogs.RemoveAt(ApplicationLogs.Count - 1);
            }
        }

        private void LoggingProvider_FirmwareLogAvailable(object sender, EmbeddedLogItem logItem)
        {
            if (FirmwareLogsPaused)
            {
                _pausedFirmwareLogs.Add(logItem);
            }
            else
            {
                InvokeUI(() =>
                {
                    if (_pausedFirmwareLogs.Count > 0)
                    {
                        foreach (var pausedItem in _pausedFirmwareLogs)
                        {
                            InsertFirmwareLog(pausedItem);
                        }

                        _pausedFirmwareLogs.Clear();
                    }

                    InsertFirmwareLog(logItem);
                });
            }
        }

        private void InsertFirmwareLog(EmbeddedLogItem log)
        {
            FirmwareLogs.Insert(0, log);

            if (FirmwareLogs.Count > MAX_LOGS)
            {
                FirmwareLogs.RemoveAt(FirmwareLogs.Count - 1);
            }
        }
    }
}