using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Windows;
using System.Windows.Data;
using System.Windows.Shell;
using System.Windows.Threading;
using YALV.Common;
using YALV.Common.Interfaces;
using YALV.Core;
using YALV.Core.Domain;
using YALV.Properties;

namespace YALV.ViewModel
{
    public class MainWindowVM
        : BindableObject
    {
        public MainWindowVM(IWinSimple win)
        {
            _callingWin = win;

            CommandExit = new CommandRelay(commandExitExecute, p => true);
            CommandOpenFile = new CommandRelay(commandOpenFileExecute, commandOpenFileCanExecute);
            CommandSelectFolder = new CommandRelay(commandSelectFolderExecute, commandSelectFolderCanExecute);
            CommandSaveFolder = new CommandRelay(commandSaveFolderExecute, commandSaveFolderCanExecute);
            CommandRefresh = new CommandRelay(commandRefreshExecute, commandRefreshCanExecute);
            CommandRefreshFiles = new CommandRelay(commandRefreshFilesExecute, commandRefreshFilesCanExecute);
            CommandClear = new CommandRelay(commandClearExecute, commandClearCanExecute);
            CommandDelete = new CommandRelay(commandDeleteExecute, commandDeleteCanExecute);
            CommandOpenSelectedFolder = new CommandRelay(commandOpenSelectedFolderExecute, commandOpenSelectedFolderCanExecute);
            CommandSelectAllFiles = new CommandRelay(commandSelectAllFilesExecute, commandSelectAllFilesCanExecute);
            CommandIncreaseInterval = new CommandRelay(commandIncreaseIntervalExecute, p => true);
            CommandDecreaseInterval = new CommandRelay(commandDecreaseIntervalExecute, p => true);
            CommandAbout = new CommandRelay(commandAboutExecute, p => true);

            FileList = new ObservableCollection<FileItem>();
            Items = new ObservableCollection<LogItem>();
            loadFolderList();

            SelectedFile = null;
            IsFileSelectionEnabled = false;
            IsLoading = false;

            _selectAll = true;
            _selectDebug = _selectInfo = _selectWarn = _selectError = _selectFatal = false;
            _showLevelDebug = _showLevelInfo = _showLevelWarn = _showLevelError = _showLevelFatal = true;

            bkLoader = new BackgroundWorker();
            bkLoader.WorkerSupportsCancellation = true;
            bkLoader.DoWork += bkLoaderRun;
            bkLoader.RunWorkerCompleted += bkLoaderCompleted;

            _dispatcherTimer = new DispatcherTimer();
            _dispatcherTimer.Tick += new EventHandler(dispatcherTimer_Tick);

            AutoRefreshInterval = Constants.DEFAULT_REFRESH_INTERVAL;
            IsAutoRefreshEnabled = false;

            refreshWindowTitle();
        }

        protected override void OnDispose()
        {
            if (_dispatcherTimer != null)
            {
                _dispatcherTimer.Stop();
                _dispatcherTimer.Tick -= dispatcherTimer_Tick;
            }

            if (bkLoader != null)
            {
                if (bkLoader.IsBusy)
                    bkLoader.CancelAsync();
                bkLoader.DoWork -= bkLoaderRun;
                bkLoader.RunWorkerCompleted -= bkLoaderCompleted;
                bkLoader.Dispose();
            }

            if (GridManager != null)
                GridManager.Dispose();

            Items.Clear();
            FileList.Clear();

            base.OnDispose();
        }

        #region Costants

        public const string NOTIFY_ScrollIntoView = "ScrollIntoView";

        #endregion

        #region Commands

        /// <summary>
        /// Exit Command
        /// </summary>
        public ICommandAncestor CommandExit { get; protected set; }

        /// <summary>
        /// OpenFile Command
        /// </summary>
        public ICommandAncestor CommandOpenFile { get; protected set; }

        /// <summary>
        /// SelectFolder Command
        /// </summary>
        public ICommandAncestor CommandSelectFolder { get; protected set; }

        /// <summary>
        /// SaveFolder Command
        /// </summary>
        public ICommandAncestor CommandSaveFolder { get; protected set; }

        /// <summary>
        /// Refresh Command
        /// </summary>
        public ICommandAncestor CommandRefresh { get; protected set; }

        /// <summary>
        /// RefreshFiles Command
        /// </summary>
        public ICommandAncestor CommandRefreshFiles { get; protected set; }

        /// <summary>
        /// Clear Command
        /// </summary>
        public ICommandAncestor CommandClear { get; protected set; }

        /// <summary>
        /// Delete Command
        /// </summary>
        public ICommandAncestor CommandDelete { get; protected set; }

        /// <summary>
        /// OpenSelectedFolder Command
        /// </summary>
        public ICommandAncestor CommandOpenSelectedFolder { get; protected set; }

        /// <summary>
        /// SelectAllFiles Command
        /// </summary>
        public ICommandAncestor CommandSelectAllFiles { get; protected set; }

        /// <summary>
        /// About Command
        /// </summary>
        public ICommandAncestor CommandAbout { get; protected set; }

        protected virtual object commandExitExecute(object parameter)
        {
            _callingWin.Close();
            return null;
        }

        protected virtual object commandOpenFileExecute(object parameter)
        {
            using (System.Windows.Forms.OpenFileDialog dlg = new System.Windows.Forms.OpenFileDialog())
            {
                bool addFile = parameter != null && parameter.Equals("ADD");
                dlg.Filter = String.Format("{0} (*.log)|*.log|{1} (*.xml)|*.xml|{2} (*.*)|*.*", 
                    Resources.MainWindowVM_commandOpenFileExecute_LogFilesCaption,
                    Resources.MainWindowVM_commandOpenFileExecute_XmlFilesCaption,
                    Resources.MainWindowVM_commandOpenFileExecute_AllFilesCaption);
                dlg.DefaultExt = "log";
                dlg.Multiselect = true;
                dlg.Title = addFile ? Resources.MainWindowVM_commandOpenFileExecute_Add_Log_File : Resources.MainWindowVM_commandOpenFileExecute_Open_Log_File;

                if (dlg.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                {
                    string[] files = dlg.FileNames;
                    SelectedFolder = null;
                    LoadFileList(files, addFile);
                }
            }
            return null;
        }

        protected virtual bool commandOpenFileCanExecute(object parameter)
        {
            return true;
        }

        protected virtual object commandSelectFolderExecute(object parameter)
        {
            using (System.Windows.Forms.FolderBrowserDialog dlg = new System.Windows.Forms.FolderBrowserDialog())
            {
                dlg.Description = Resources.MainWindowVM_commandSelectFolderExecute_Description;
                if (dlg.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                {
                    string selectedPath = dlg.SelectedPath;
                    SelectedFolder = null;
                    for (int i = 0; i < FolderList.Count; i++)
                    {
                        PathItem item = FolderList[i];
                        if (item.Path.Equals(selectedPath, StringComparison.OrdinalIgnoreCase))
                        {
                            SelectedFolder = item;
                            return null;
                        }
                    }
                    loadFolderFiles(selectedPath);
                }
            }
            return null;
        }

        protected virtual bool commandSelectFolderCanExecute(object parameter)
        {
            return true;
        }

        protected virtual object commandSaveFolderExecute(object parameter)
        {
            var win = new AddFolderPath() { Owner = _callingWin as Window };
            if (win.EditList())
                loadFolderList();
            return null;
        }

        protected virtual bool commandSaveFolderCanExecute(object parameter)
        {
            return true;
        }

        protected virtual object commandClearExecute(object parameter)
        {
            if (GridManager != null)
            {
                GridManager.ResetSearchTextBox();
                RefreshView();
            }
            return null;
        }

        protected virtual bool commandClearCanExecute(object parameter)
        {
            return true;
        }

        protected virtual object commandRefreshExecute(object parameter)
        {
            Items.Clear();

            if (IsFileSelectionEnabled)
            {
                foreach (FileItem item in FileList)
                {
                    if (item.Checked)
                        loadLogFile(item.Path, true);
                }
            }
            else
            {
                if (FileList.Count > 0 && SelectedFile != null)
                    loadLogFile(SelectedFile.Path);
            }

            return null;
        }

        protected virtual bool commandRefreshCanExecute(object parameter)
        {
            return true;
        }

        protected virtual object commandRefreshFilesExecute(object parameter)
        {
            if (_selectedFolder != null)
            {
                Items.Clear();

                if (IsFileSelectionEnabled)
                {
                    //Reload file list and restore all checked items
                    IList<string> checkedItems = (from f in FileList
                                                  where f.Checked
                                                  select f.Path).ToList<string>();
                    SelectedFile = null;
                    loadFolderFiles(_selectedFolder.Path);

                    if (checkedItems != null && checkedItems.Count > 0)
                    {
                        foreach (string filePath in checkedItems)
                        {
                            FileItem selItem = (from f in FileList
                                                where filePath.Equals(f.Path, StringComparison.OrdinalIgnoreCase)
                                                select f).FirstOrDefault<FileItem>();
                            if (selItem != null)
                                selItem.Checked = true;
                        }
                    }
                }
                else
                {
                    //Reload file list and restore selected item
                    string selectedFilePath = SelectedFile != null ? SelectedFile.Path : string.Empty;
                    SelectedFile = null;
                    loadFolderFiles(_selectedFolder.Path);

                    if (!String.IsNullOrWhiteSpace(selectedFilePath))
                    {
                        FileItem selItem = (from f in FileList
                                            where selectedFilePath.Equals(f.Path, StringComparison.OrdinalIgnoreCase)
                                            select f).FirstOrDefault<FileItem>();
                        if (selItem != null)
                            SelectedFile = selItem;
                    }
                }
            }
            return null;
        }

        protected virtual bool commandRefreshFilesCanExecute(object parameter)
        {
            return SelectedFolder != null;
        }

        protected virtual object commandDeleteExecute(object parameter)
        {
            if (IsFileSelectionEnabled)
            {
                if (MessageBox.Show(Resources.MainWindowVM_commandDeleteExecute_DeleteCheckedFiles_ConfirmText, Resources.MainWindowVM_commandDeleteExecute_DeleteCheckedFiles_ConfirmTitle, MessageBoxButton.YesNo, MessageBoxImage.Question, MessageBoxResult.No) == MessageBoxResult.No)
                    return null;

                //Delete all selected file
                for (int i = FileList.Count - 1; i >= 0; i--)
                {
                    FileItem item = FileList[i];
                    if (item.Checked && deleteFile(item.Path))
                    {
                        Items.Clear();
                        SelectedFile = null;
                        FileList.RemoveAt(i);
                    }
                }
            }
            else
            {
                if (MessageBox.Show(Resources.MainWindowVM_commandDeleteExecute_DeleteSelectedFile_ConfirmText, Resources.MainWindowVM_commandDeleteExecute_DeleteSelectedFile_ConfirmTitle, MessageBoxButton.YesNo, MessageBoxImage.Question, MessageBoxResult.No) == MessageBoxResult.No)
                    return null;

                //Delete selected file
                if (SelectedFile != null)
                {
                    int indexToDelete = FileList.IndexOf(SelectedFile);
                    if (deleteFile(SelectedFile.Path))
                    {
                        Items.Clear();
                        SelectedFile = null;
                        FileList.RemoveAt(indexToDelete);
                    }
                }
            }
            return null;
        }

        protected virtual bool commandDeleteCanExecute(object parameter)
        {
            if (IsFileSelectionEnabled)
            {
                if (FileList == null || FileList.Count == 0)
                    return false;

                return (from f in FileList
                        where f.Checked
                        select f).Count() > 0;
            }
            else
                return SelectedFile != null;
        }

        protected virtual object commandOpenSelectedFolderExecute(object parameter)
        {
            string path = SelectedFolder != null ? SelectedFolder.Path : string.Empty;
            if (!String.IsNullOrWhiteSpace(path) && Directory.Exists(path))
                Process.Start("explorer.exe", path);
            return null;
        }

        protected virtual bool commandOpenSelectedFolderCanExecute(object parameter)
        {
            return SelectedFolder != null;
        }

        protected virtual object commandSelectAllFilesExecute(object parameter)
        {
            if (parameter == null)
                return null;

            if (IsFileSelectionEnabled)
            {
                try
                {
                    _loadingAllFiles = true;

                    switch (parameter.ToString())
                    {
                        case "ALL":
                            IList<string> files = new List<string>();
                            foreach (FileItem item in FileList)
                            {
                                files.Add(item.Path);
                                item.Checked = true;
                            }

                            if (bkLoader != null)
                            {
                                while (IsLoading)
                                    GlobalHelper.DoEvents();

                                IsLoading = true;

                                object[] args = { files.ToArray<string>(), false };
                                bkLoader.RunWorkerAsync(args);
                            }
                            break;

                        case "NONE":
                            foreach (FileItem item in FileList)
                                item.Checked = false;

                            Items.Clear();
                            updateCounters();
                            break;

                        default:
                            break;
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message, Resources.GlobalHelper_ParseLogFile_Error_Title, MessageBoxButton.OK, MessageBoxImage.Exclamation);
                }
                finally
                {
                    _loadingAllFiles = false;
                }
            }
            return null;
        }

        protected virtual bool commandSelectAllFilesCanExecute(object parameter)
        {
            return IsFileSelectionEnabled && FileList.Count > 0;
        }

        protected virtual object commandAboutExecute(object parameter)
        {
            var win = new About() { Owner = _callingWin as Window };
            win.ShowDialog();
            return null;
        }

        #endregion

        #region Public Properties

        /// <summary>
        /// RefreshUI Action
        /// </summary>
        public Action<string, object> RefreshUI { get; set; }

        /// <summary>
        /// WindowTitle Property
        /// </summary>
        public string WindowTitle
        {
            get { return _windowTitle; }
            set
            {
                _windowTitle = value;
                RaisePropertyChanged(PROP_WindowTitle);
            }
        }
        private string _windowTitle;
        public static string PROP_WindowTitle = "WindowTitle";

        /// <summary>
        /// RecentFileList Manager
        /// </summary>
        public RecentFileList RecentFileList
        {
            get { return _recentFileList; }
            set
            {
                _recentFileList = value;
                if (_recentFileList != null)
                {
                    _recentFileList.MenuClick += (s, e) =>
                    {
                        SelectedFolder = null;
                        LoadFileList(new string[] { e.Filepath }, false);
                    };
                    updateJumpList();
                }
            }
        }
        private RecentFileList _recentFileList;
        public static string PROP_RecentFileList = "RecentFileList";

        /// <summary>
        /// IsLoading Property
        /// </summary>
        public bool IsLoading
        {
            get { return _isLoading; }
            set
            {
                _isLoading = value;
                RaisePropertyChanged(PROP_IsLoading);
            }
        }
        private bool _isLoading;
        public static string PROP_IsLoading = "IsLoading";

        /// <summary>
        /// IsFileSelectionEnabled Property
        /// </summary>
        public bool IsFileSelectionEnabled
        {
            get { return _isFileSelectionEnabled; }
            set
            {
                _isFileSelectionEnabled = value;
                RaisePropertyChanged(PROP_IsFileSelectionEnabled);

                if (_isFileSelectionEnabled)
                {
                    Items.Clear();
                    if (FileList.Count > 0 && SelectedFile != null)
                        SelectedFile.Checked = true;
                }
                else
                {
                    Items.Clear();
                    foreach (FileItem item in FileList)
                        item.Checked = false;
                    SelectedFile = null;
                }

                refreshCommandsCanExecute();
                refreshWindowTitle();
            }
        }
        private bool _isFileSelectionEnabled;
        public static string PROP_IsFileSelectionEnabled = "IsFileSelectionEnabled";

        /// <summary>
        /// SelectedFile Property
        /// </summary>
        public FileItem SelectedFile
        {
            get { return _selectedFile; }
            set
            {
                if (value != _selectedFile)
                {
                    _selectedFile = value;
                    RaisePropertyChanged(PROP_SelectedFile);

                    if (!_loadingFileList && _selectedFile != null)
                    {
                        string path = _selectedFile.Path;
                        SelectedFileDir = !string.IsNullOrWhiteSpace(path) ? Path.GetDirectoryName(path) : string.Empty;
                        if (!IsFileSelectionEnabled)
                            loadLogFile(path);
                    }

                    refreshCommandsCanExecute();
                    refreshWindowTitle();
                }
            }
        }
        private FileItem _selectedFile;
        public static string PROP_SelectedFile = "SelectedFile";

        /// <summary>
        /// SelectedFolder Property
        /// </summary>
        public PathItem SelectedFolder
        {
            get { return _selectedFolder; }
            set
            {
                if (value != _selectedFolder)
                {
                    _selectedFolder = value;
                    RaisePropertyChanged(PROP_SelectedFolder);

                    Items.Clear();
                    if (_selectedFolder != null)
                        loadFolderFiles(_selectedFolder.Path);

                    refreshCommandsCanExecute();
                }
            }
        }
        private PathItem _selectedFolder;
        public static string PROP_SelectedFolder = "SelectedFolder";

        /// <summary>
        /// SelectedFileDir Property
        /// </summary>
        public string SelectedFileDir
        {
            get { return _selectedFileDir; }
            set
            {
                _selectedFileDir = value;
                RaisePropertyChanged(PROP_SelectedFileDir);
            }
        }
        private string _selectedFileDir;
        public static string PROP_SelectedFileDir = "SelectedFileDir";

        /// <summary>
        /// FolderList Property
        /// </summary>
        public ObservableCollection<PathItem> FolderList
        {
            get { return _folderList; }
            set
            {
                _folderList = value;
                RaisePropertyChanged(PROP_FolderList);
            }
        }
        private ObservableCollection<PathItem> _folderList;
        public static string PROP_FolderList = "FolderList";

        /// <summary>
        /// FileList Property
        /// </summary>
        public ObservableCollection<FileItem> FileList
        {
            get { return _fileList; }
            set
            {
                _fileList = value;
                RaisePropertyChanged(PROP_FileList);

                refreshCommandsCanExecute();
            }
        }
        private ObservableCollection<FileItem> _fileList;
        public static string PROP_FileList = "FileList";

        /// <summary>
        /// LogItems Property
        /// </summary>
        public ObservableCollection<LogItem> Items
        {
            get { return _items; }
            set
            {
                _items = value;
                RaisePropertyChanged(PROP_Items);
            }
        }
        private ObservableCollection<LogItem> _items;
        public static string PROP_Items = "Items";

        /// <summary>
        /// SelectedLogItem Property
        /// </summary>
        public LogItem SelectedLogItem
        {
            get { return _selectedLogItem; }
            set
            {
                _selectedLogItem = value;
                RaisePropertyChanged(PROP_SelectedLogItem);

                _goToLogItemId = _selectedLogItem != null ? _selectedLogItem.Id.ToString() : string.Empty;
                RaisePropertyChanged(PROP_GoToLogItemId);

                refreshWindowTitle();
            }
        }
        private LogItem _selectedLogItem;
        public static string PROP_SelectedLogItem = "SelectedLogItem";

        /// <summary>
        /// ShowLevelDebug Property
        /// </summary>
        public bool ShowLevelDebug
        {
            get { return _showLevelDebug; }
            set
            {
                if (value != _showLevelDebug)
                {
                    _showLevelDebug = value;
                    RaisePropertyChanged(PROP_ShowLevelDebug);
                    resetLevelSelection();
                    RefreshView();
                }
            }
        }
        private bool _showLevelDebug;
        public static string PROP_ShowLevelDebug = "ShowLevelDebug";

        /// <summary>
        /// ShowLevelInfo Property
        /// </summary>
        public bool ShowLevelInfo
        {
            get { return _showLevelInfo; }
            set
            {
                if (value != _showLevelInfo)
                {
                    _showLevelInfo = value;
                    RaisePropertyChanged(PROP_ShowLevelInfo);
                    resetLevelSelection();
                    RefreshView();
                }
            }
        }
        private bool _showLevelInfo;
        public static string PROP_ShowLevelInfo = "ShowLevelInfo";

        /// <summary>
        /// ShowLevelWarn Property
        /// </summary>
        public bool ShowLevelWarn
        {
            get { return _showLevelWarn; }
            set
            {
                if (value != _showLevelWarn)
                {
                    _showLevelWarn = value;
                    RaisePropertyChanged(PROP_ShowLevelWarn);
                    resetLevelSelection();
                    RefreshView();
                }
            }
        }
        private bool _showLevelWarn;
        public static string PROP_ShowLevelWarn = "ShowLevelWarn";

        /// <summary>
        /// ShowLevelError Property
        /// </summary>
        public bool ShowLevelError
        {
            get { return _showLevelError; }
            set
            {
                if (value != _showLevelError)
                {
                    _showLevelError = value;
                    RaisePropertyChanged(PROP_ShowLevelError);
                    resetLevelSelection();
                    RefreshView();
                }
            }
        }
        private bool _showLevelError;
        public static string PROP_ShowLevelError = "ShowLevelError";

        /// <summary>
        /// ShowLevelFatal Property
        /// </summary>
        public bool ShowLevelFatal
        {
            get { return _showLevelFatal; }
            set
            {
                if (value != _showLevelFatal)
                {
                    _showLevelFatal = value;
                    RaisePropertyChanged(PROP_ShowLevelFatal);
                    resetLevelSelection();
                    RefreshView();
                }
            }
        }
        private bool _showLevelFatal;
        public static string PROP_ShowLevelFatal = "ShowLevelFatal";

        /// <summary>
        /// SelectAll Property
        /// </summary>
        public bool SelectAll
        {
            get { return _selectAll; }
            set
            {
                if (value != _selectAll)
                {
                    _selectAll = value;
                    RaisePropertyChanged(PROP_SelectAll);

                    if (_selectAll)
                    {
                        _showLevelDebug = _showLevelInfo = _showLevelWarn = _showLevelError = _showLevelFatal = true;
                        refreshCheckBoxBinding();
                        RefreshView();
                    }
                }
            }
        }
        private bool _selectAll;
        public static string PROP_SelectAll = "SelectAll";

        /// <summary>
        /// SelectDebug Property
        /// </summary>
        public bool SelectDebug
        {
            get { return _selectDebug; }
            set
            {
                if (value != _selectDebug)
                {
                    _selectDebug = value;
                    RaisePropertyChanged(PROP_SelectDebug);

                    if (_selectDebug)
                    {
                        _showLevelInfo = _showLevelWarn = _showLevelError = _showLevelFatal = false;
                        _showLevelDebug = true;
                        refreshCheckBoxBinding();
                        RefreshView();
                    }
                }
            }
        }
        private bool _selectDebug;
        public static string PROP_SelectDebug = "SelectDebug";

        /// <summary>
        /// SelectInfo Property
        /// </summary>
        public bool SelectInfo
        {
            get { return _selectInfo; }
            set
            {
                if (value != _selectInfo)
                {
                    _selectInfo = value;
                    RaisePropertyChanged(PROP_SelectInfo);

                    if (_selectInfo)
                    {
                        _showLevelDebug = _showLevelWarn = _showLevelError = _showLevelFatal = false;
                        _showLevelInfo = true;
                        refreshCheckBoxBinding();
                        RefreshView();
                    }
                }
            }
        }
        private bool _selectInfo;
        public static string PROP_SelectInfo = "SelectInfo";

        /// <summary>
        /// SelectWarn Property
        /// </summary>
        public bool SelectWarn
        {
            get { return _selectWarn; }
            set
            {
                if (value != _selectWarn)
                {
                    _selectWarn = value;
                    RaisePropertyChanged(PROP_SelectWarn);

                    if (_selectWarn)
                    {
                        _showLevelDebug = _showLevelInfo = _showLevelError = _showLevelFatal = false;
                        _showLevelWarn = true;
                        refreshCheckBoxBinding();
                        RefreshView();
                    }
                }
            }
        }
        private bool _selectWarn;
        public static string PROP_SelectWarn = "SelectWarn";

        /// <summary>
        /// SelectError Property
        /// </summary>
        public bool SelectError
        {
            get { return _selectError; }
            set
            {
                if (value != _selectError)
                {
                    _selectError = value;
                    RaisePropertyChanged(PROP_SelectError);

                    if (_selectError)
                    {
                        _showLevelDebug = _showLevelInfo = _showLevelWarn = _showLevelFatal = false;
                        _showLevelError = true;
                        refreshCheckBoxBinding();
                        RefreshView();
                    }
                }
            }
        }
        private bool _selectError;
        public static string PROP_SelectError = "SelectError";

        /// <summary>
        /// SelectFatal Property
        /// </summary>
        public bool SelectFatal
        {
            get { return _selectFatal; }
            set
            {
                if (value != _selectFatal)
                {
                    _selectFatal = value;
                    RaisePropertyChanged(PROP_SelectFatal);

                    if (_selectFatal)
                    {
                        _showLevelDebug = _showLevelInfo = _showLevelWarn = _showLevelError = false;
                        _showLevelFatal = true;
                        refreshCheckBoxBinding();
                        RefreshView();
                    }
                }
            }
        }
        private bool _selectFatal;
        public static string PROP_SelectFatal = "SelectFatal";

        /// <summary>
        /// GoToLogItemId Property
        /// </summary>
        public string GoToLogItemId
        {
            get { return _goToLogItemId; }
            set
            {
                _goToLogItemId = value;

                int idGoTo = 0;
                int.TryParse(value, out idGoTo);
                int currentId = SelectedLogItem != null ? SelectedLogItem.Id : 0;

                if (idGoTo > 0 && idGoTo != currentId)
                {
                    var selectItem = (from it in Items
                                      where it.Id == idGoTo
                                      select it).FirstOrDefault<LogItem>();

                    if (selectItem != null)
                        SelectedLogItem = selectItem;
                }
                else
                    _goToLogItemId = currentId != 0 ? currentId.ToString() : string.Empty;

                RaisePropertyChanged(PROP_GoToLogItemId);
            }
        }
        private string _goToLogItemId;
        public static string PROP_GoToLogItemId = "GoToLogItemId";

        #endregion

        #region Public Methods

        public void LoadFileList(string[] pathList, bool add = false)
        {
            SelectedFile = null;

            _loadingFileList = true;

            if (!add)
                FileList.Clear();

            foreach (string path in pathList)
            {
                //Ignore path if is not valid
                if (!File.Exists(path) && !Directory.Exists(path))
                    continue;

                //Get files list to add
                string[] files = null;
                FileAttributes attr = File.GetAttributes(path);
                if (attr.HasFlag(FileAttributes.Directory))
                    files = Directory.GetFiles(path);
                else
                    files = new string[] { path };

                foreach (string file in files)
                {
                    string fileName = Path.GetFileName(file);
                    FileItem newItem = new FileItem(fileName, file);
                    newItem.PropertyChanged += delegate (object sender, PropertyChangedEventArgs e)
                    {
                        if (e.PropertyName.Equals(FileItem.PROP_Checked) && !_loadingAllFiles)
                        {
                            if (newItem.Checked)
                                loadLogFile(newItem.Path, true);
                            else
                                removeItems(newItem.Path);

                            refreshCommandsCanExecute();
                        }
                    };
                    FileList.Add(newItem);
                }
            }

            _loadingFileList = false;

            //Load item if only one
            if (FileList.Count == 1)
            {
                if (IsFileSelectionEnabled)
                {
                    SelectedFile = FileList[0];
                    SelectedFile.Checked = true;
                }
                else
                    SelectedFile = FileList[0];
            }
        }

        #endregion

        #region Privates

        private IWinSimple _callingWin;

        private bool _loadingFileList = false;

        private bool _loadingAllFiles = false;

        private void refreshCheckBoxBinding()
        {
            RaisePropertyChanged(PROP_ShowLevelDebug);
            RaisePropertyChanged(PROP_ShowLevelInfo);
            RaisePropertyChanged(PROP_ShowLevelWarn);
            RaisePropertyChanged(PROP_ShowLevelError);
            RaisePropertyChanged(PROP_ShowLevelFatal);
        }

        private void resetLevelSelection()
        {
            SelectAll = false;
            SelectDebug = false;
            SelectInfo = false;
            SelectWarn = false;
            SelectError = false;
            SelectFatal = false;
        }

        private void loadFolderList()
        {
            FileList.Clear();
            SelectedFolder = null;
            string path = Constants.FOLDERS_FILE_PATH;
            IList<PathItem> folders = null;
            try
            {
                folders = DataService.ParseFolderFile(path);
            }
            catch (Exception ex)
            {
                string message = String.Format((string)Resources.GlobalHelper_ParseFolderFile_Error_Text, path, ex.Message);
                MessageBox.Show(message, Resources.GlobalHelper_ParseFolderFile_Error_Title, MessageBoxButton.OK, MessageBoxImage.Exclamation);

            }
            FolderList = folders != null ? new ObservableCollection<PathItem>(folders) : new ObservableCollection<PathItem>();
        }

        private void loadFolderFiles(string folderPath)
        {
            if (Directory.Exists(folderPath))
            {
                string[] files = Directory.GetFiles(folderPath);
                LoadFileList(files);
            }
            else
            {
                FileList.Clear();
                MessageBox.Show(String.Format(Resources.MainWindowVM_loadFolderFiles_ErrorMessage_Text, folderPath), Resources.MainWindowVM_loadFolderFiles_ErrorMessageText_Title, MessageBoxButton.OK, MessageBoxImage.Exclamation);
            }
        }

        private void loadLogFile(string path, bool merge = false)
        {
            if (bkLoader != null)
            {
                while (IsLoading)
                    GlobalHelper.DoEvents();

                IsLoading = true;

                RecentFileList.InsertFile(path);
                updateJumpList();

                object[] args = { new string[] { path }, merge };
                bkLoader.RunWorkerAsync(args);
            }
        }

        private void removeItems(string path)
        {
            //Less performance
            //for (int i = Items.Count - 1; i >= 0; i--)
            //{
            //    if (Items[i].Path.Equals(path, StringComparison.OrdinalIgnoreCase))
            //        Items.RemoveAt(i);
            //}

            //Best performance
            var selectedItems = from it in Items
                                where (!it.Path.Equals(path, StringComparison.OrdinalIgnoreCase))
                                select it;
            Items = new ObservableCollection<LogItem>(selectedItems);

            int itemId = 1;
            foreach (LogItem item in Items)
                item.Id = itemId++;

            updateCounters();
        }

        private bool deleteFile(string path)
        {
            try
            {
                FileInfo fileInfo = new FileInfo(path);
                if (fileInfo != null)
                    fileInfo.Delete();
                return true;
            }
            catch (Exception ex)
            {
                MessageBox.Show(String.Format(Resources.MainWindowVM_deleteFile_ErrorMessage_Text, path, ex.Message), Resources.MainWindowVM_deleteFile_ErrorMessage_Title, MessageBoxButton.OK, MessageBoxImage.Error);
                return false;
            }
        }

        private void refreshCommandsCanExecute()
        {
            CommandRefreshFiles.OnCanExecuteChanged();
            CommandDelete.OnCanExecuteChanged();
            CommandOpenSelectedFolder.OnCanExecuteChanged();
            CommandSelectAllFiles.OnCanExecuteChanged();
        }

        private void updateJumpList()
        {
            JumpList myJumpList = JumpList.GetJumpList(Application.Current);

            if (myJumpList == null)
            {
                myJumpList = new JumpList();
                JumpList.SetJumpList(Application.Current, myJumpList);
            }

            myJumpList.JumpItems.Clear();
            if (RecentFileList != null && RecentFileList.RecentFiles != null)
            {
                foreach (string item in RecentFileList.RecentFiles)
                {
                    try
                    {
                        JumpTask myJumpTask = new JumpTask();
                        myJumpTask.CustomCategory = Resources.MainWindowVM_updateJumpList_CustomCategoryName;
                        myJumpTask.Title = Path.GetFileName(item);
                        //myJumpTask.Description = "";
                        myJumpTask.ApplicationPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, System.AppDomain.CurrentDomain.FriendlyName);
                        myJumpTask.Arguments = item;
                        myJumpList.JumpItems.Add(myJumpTask);
                    }
                    catch (Exception)
                    {
                        //throw;
                    }
                }
            }
            myJumpList.Apply();
        }

        private void raiseRefreshUI(string eventName, object parameter = null)
        {
            if (RefreshUI != null)
                RefreshUI(eventName, parameter);
        }

        private void refreshWindowTitle()
        {
            string fileName = string.Empty;
            if (IsFileSelectionEnabled && SelectedLogItem != null)
            {
                fileName = (from f in FileList
                            where SelectedLogItem.Path.Equals(f.Path, StringComparison.OrdinalIgnoreCase)
                            select f.FileName).FirstOrDefault<string>();
            }

            if (!IsFileSelectionEnabled && SelectedFile != null)
                fileName = SelectedFile.FileName;

            string title = string.Empty;
            if (!String.IsNullOrWhiteSpace(fileName))
                title = String.Format("{0} / {1}", Properties.Resources.MainWindow_Title, fileName);
            else
                title = Properties.Resources.MainWindow_Title;

            if (!title.Equals(WindowTitle, StringComparison.OrdinalIgnoreCase))
                WindowTitle = title;
        }

        #endregion

        #region BackgroundWorker Methods (bkLoader)

        private BackgroundWorker bkLoader;

        private void bkLoaderRun(object sender, DoWorkEventArgs e)
        {
            object[] args = e.Argument as object[];
            if (args == null)
                return;

            string[] pathList = args[0] as string[];
            bool merge = (bool)args[1];
            List<LogItem> res = new List<LogItem>();
            int count = 0;

            if (pathList != null)
            {
                foreach (string path in pathList)
                {
                    if (String.IsNullOrWhiteSpace(path))
                        continue;

                    try
                    {
                        var list = DataService.ParseLogFile(path);
                        if (list != null)
                        {
                            res.AddRange(list);
                            count++;
                        }
                    }
                    catch (Exception ex)
                    {
                        string message = String.Format((string)Resources.GlobalHelper_ParseLogFile_Error_Text, path, ex.Message);
                        MessageBox.Show(message, Resources.GlobalHelper_ParseLogFile_Error_Title, MessageBoxButton.OK, MessageBoxImage.Exclamation);
                    }

                    BackgroundWorker worker = sender as BackgroundWorker;
                    if (worker != null && worker.CancellationPending)
                    {
                        e.Cancel = true;
                        return;
                    }
                }
            }

            //If loaded more than one list, then sort items by timestamp
            if (count > 1)
            {
                res = (from it in res
                       orderby it.TimeStamp ascending
                       select it).ToList<LogItem>();

                int itemId = 1;
                foreach (LogItem item in res)
                    item.Id = itemId++;
            }

            e.Result = new object[] { res, merge };
        }

        private void bkLoaderCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if (e.Error != null)
                MessageBox.Show(String.Format(Resources.MainWindowVM_bkLoaderCompleted_UnreadableFile_Text, e.Error.ToString()), Resources.MainWindowVM_bkLoaderCompleted_UnreadableFile_Title, MessageBoxButton.OK, MessageBoxImage.Exclamation);
            else
            {
                if (!e.Cancelled && e.Result != null)
                {
                    object[] res = e.Result as object[];
                    IList<LogItem> list = res[0] as IList<LogItem>;
                    bool merge = (bool)res[1];

                    if (merge && Items.Count > 0)
                    {
                        //Merge result list with existing items
                        IList<LogItem> mergeList = new List<LogItem>(Items);
                        int startId = mergeList.Count;

                        foreach (LogItem item in list)
                            mergeList.Add(item);

                        mergeList = (from it in mergeList
                                     orderby it.TimeStamp ascending
                                     select it).ToList<LogItem>();

                        int itemId = 1;
                        foreach (LogItem item in mergeList)
                            item.Id = itemId++;

                        list = mergeList;
                    }

                    Items.Clear();
                    Items = new ObservableCollection<LogItem>(list);

                    updateCounters();

                    if (Items.Count > 0)
                    {
                        var lastItem = (from it in Items
                                        where levelCheckFilter(it)
                                        select it).LastOrDefault<LogItem>();

                        SelectedLogItem = lastItem != null ? lastItem : Items[Items.Count - 1];
                    }
                }
            }
            IsLoading = false;
        }

        #endregion

        #region FilteredGridManager

        /// <summary>
        /// GridManager Property
        /// </summary>
        public FilteredGridManager GridManager { get; set; }

        public void InitDataGrid()
        {
            if (GridManager != null)
            {
                IList<ColumnItem> dgColumns = new List<ColumnItem>()
                {
                    new ColumnItem("Id", 37, null, CellAlignment.CENTER,string.Empty){Header = Resources.MainWindowVM_InitDataGrid_IdColumn_Header},
                    new ColumnItem("TimeStamp", 120, null, CellAlignment.CENTER, GlobalHelper.DisplayDateTimeFormat){Header = Resources.MainWindowVM_InitDataGrid_TimeStampColumn_Header},
                    new ColumnItem("Level", null, 50, CellAlignment.CENTER){Header = Resources.MainWindowVM_InitDataGrid_LevelColumn_Header},
                    new ColumnItem("Message", null, 300){Header = Resources.MainWindowVM_InitDataGrid_MessageColumn_Header},
                    new ColumnItem("Logger", 150, null){Header = Resources.MainWindowVM_InitDataGrid_LoggerColumn_Header},
                    new ColumnItem("MachineName", 110, null, CellAlignment.CENTER){Header = Resources.MainWindowVM_InitDataGrid_MachineNameColumn_Header},
                    new ColumnItem("HostName", 110, null, CellAlignment.CENTER){Header = Resources.MainWindowVM_InitDataGrid_HostNameColumn_Header},
                    new ColumnItem("UserName", 110, null, CellAlignment.CENTER){Header = Resources.MainWindowVM_InitDataGrid_UserNameColumn_Header},
                    new ColumnItem("App", 150, null){Header = Resources.MainWindowVM_InitDataGrid_AppColumn_Header},
                    new ColumnItem("Thread", 44, null, CellAlignment.CENTER){Header = Resources.MainWindowVM_InitDataGrid_ThreadColumn_Header},
                    new ColumnItem("Class", null, 300){Header = Resources.MainWindowVM_InitDataGrid_ClassColumn_Header},
                    new ColumnItem("Method", 200, null){Header = Resources.MainWindowVM_InitDataGrid_MethodColumn_Header}
                    //new ColumnItem("Delta", 60, null, CellAlignment.CENTER, null, "Δ"),
                    //new ColumnItem("Path", 50)
                };
                GridManager.BuildDataGrid(dgColumns);
                GridManager.AssignSource(new Binding(MainWindowVM.PROP_Items) { Source = this, Mode = BindingMode.OneWay });
                GridManager.OnBeforeCheckFilter = levelCheckFilter;
            }
        }

        public void RefreshView()
        {
            if (GridManager != null)
            {
                ICollectionView view = GridManager.GetCollectionView();
                if (view != null)
                    view.Refresh();
                updateFilteredCounters(view);
            }
            raiseRefreshUI(NOTIFY_ScrollIntoView);
        }

        private bool levelCheckFilter(object item)
        {
            LogItem logItem = item as LogItem;
            if (logItem != null)
            {
                switch (logItem.LevelIndex)
                {
                    case LevelIndex.DEBUG:
                        return ShowLevelDebug;
                    case LevelIndex.INFO:
                        return ShowLevelInfo;
                    case LevelIndex.WARN:
                        return ShowLevelWarn;
                    case LevelIndex.ERROR:
                        return ShowLevelError;
                    case LevelIndex.FATAL:
                        return ShowLevelFatal;
                }
            }
            return true;
        }

        #endregion

        #region Counters

        /// <summary>
        /// ItemsDebugCount Property
        /// </summary>
        public int ItemsDebugCount
        {
            get { return _itemsDebugCount; }
            set
            {
                _itemsDebugCount = value;
                RaisePropertyChanged(PROP_ItemsDebugCount);
            }
        }
        private int _itemsDebugCount;
        public static string PROP_ItemsDebugCount = "ItemsDebugCount";

        /// <summary>
        /// ItemsInfoCount Property
        /// </summary>
        public int ItemsInfoCount
        {
            get { return _itemsInfoCount; }
            set
            {
                _itemsInfoCount = value;
                RaisePropertyChanged(PROP_ItemsInfoCount);
            }
        }
        private int _itemsInfoCount;
        public static string PROP_ItemsInfoCount = "ItemsInfoCount";

        /// <summary>
        /// ItemsWarnCount Property
        /// </summary>
        public int ItemsWarnCount
        {
            get { return _itemsWarnCount; }
            set
            {
                _itemsWarnCount = value;
                RaisePropertyChanged(PROP_ItemsWarnCount);
            }
        }
        private int _itemsWarnCount;
        public static string PROP_ItemsWarnCount = "ItemsWarnCount";

        /// <summary>
        /// ItemsErrorCount Property
        /// </summary>
        public int ItemsErrorCount
        {
            get { return _itemsErrorCount; }
            set
            {
                _itemsErrorCount = value;
                RaisePropertyChanged(PROP_ItemsErrorCount);
            }
        }
        private int _itemsErrorCount;
        public static string PROP_ItemsErrorCount = "ItemsErrorCount";

        /// <summary>
        /// ItemsFatalCount Property
        /// </summary>
        public int ItemsFatalCount
        {
            get { return _itemsFatalCount; }
            set
            {
                _itemsFatalCount = value;
                RaisePropertyChanged(PROP_ItemsFatalCount);
            }
        }
        private int _itemsFatalCount;
        public static string PROP_ItemsFatalCount = "ItemsFatalCount";

        /// <summary>
        /// ItemsDebugFilterCount Property
        /// </summary>
        public int ItemsDebugFilterCount
        {
            get { return _itemsDebugFilterCount; }
            set
            {
                _itemsDebugFilterCount = value;
                RaisePropertyChanged(PROP_ItemsDebugFilterCount);
            }
        }
        private int _itemsDebugFilterCount;
        public static string PROP_ItemsDebugFilterCount = "ItemsDebugFilterCount";

        /// <summary>
        /// ItemsInfoFilterCount Property
        /// </summary>
        public int ItemsInfoFilterCount
        {
            get { return _itemsInfoFilterCount; }
            set
            {
                _itemsInfoFilterCount = value;
                RaisePropertyChanged(PROP_ItemsInfoFilterCount);
            }
        }
        private int _itemsInfoFilterCount;
        public static string PROP_ItemsInfoFilterCount = "ItemsInfoFilterCount";

        /// <summary>
        /// ItemsWarnFilterCount Property
        /// </summary>
        public int ItemsWarnFilterCount
        {
            get { return _itemsWarnFilterCount; }
            set
            {
                _itemsWarnFilterCount = value;
                RaisePropertyChanged(PROP_ItemsWarnFilterCount);
            }
        }
        private int _itemsWarnFilterCount;
        public static string PROP_ItemsWarnFilterCount = "ItemsWarnFilterCount";

        /// <summary>
        /// ItemsErrorFilterCount Property
        /// </summary>
        public int ItemsErrorFilterCount
        {
            get { return _itemsErrorFilterCount; }
            set
            {
                _itemsErrorFilterCount = value;
                RaisePropertyChanged(PROP_ItemsErrorFilterCount);
            }
        }
        private int _itemsErrorFilterCount;
        public static string PROP_ItemsErrorFilterCount = "ItemsErrorFilterCount";

        /// <summary>
        /// ItemsFatalFilterCount Property
        /// </summary>
        public int ItemsFatalFilterCount
        {
            get { return _itemsFatalFilterCount; }
            set
            {
                _itemsFatalFilterCount = value;
                RaisePropertyChanged(PROP_ItemsFatalFilterCount);
            }
        }
        private int _itemsFatalFilterCount;
        public static string PROP_ItemsFatalFilterCount = "ItemsFatalFilterCount";

        /// <summary>
        /// ItemsFilterCount Property
        /// </summary>
        public int ItemsFilterCount
        {
            get { return _itemsFilterCount; }
            set
            {
                _itemsFilterCount = value;
                RaisePropertyChanged(PROP_ItemsFilterCount);
            }
        }
        private int _itemsFilterCount;
        public static string PROP_ItemsFilterCount = "ItemsFilterCount";

        private void updateCounters()
        {
            ItemsDebugCount = (from it in Items
                               where it.Level.Equals("DEBUG", StringComparison.OrdinalIgnoreCase)
                               select it).Count();

            ItemsInfoCount = (from it in Items
                              where it.Level.Equals("INFO", StringComparison.OrdinalIgnoreCase)
                              select it).Count();

            ItemsWarnCount = (from it in Items
                              where it.Level.Equals("WARN", StringComparison.OrdinalIgnoreCase)
                              select it).Count();

            ItemsErrorCount = (from it in Items
                               where it.Level.Equals("ERROR", StringComparison.OrdinalIgnoreCase)
                               select it).Count();

            ItemsFatalCount = (from it in Items
                               where it.Level.Equals("FATAL", StringComparison.OrdinalIgnoreCase)
                               select it).Count();

            RefreshView();
        }

        private void updateFilteredCounters(ICollectionView filteredList)
        {
            if (filteredList != null)
            {
                IEnumerable<LogItem> fltList = filteredList.Cast<LogItem>();
                if (fltList != null)
                {
                    ItemsFilterCount = fltList.Count();

                    ItemsDebugFilterCount = (from it in fltList
                                             where it.Level.Equals("DEBUG", StringComparison.OrdinalIgnoreCase)
                                             select it).Count();

                    ItemsInfoFilterCount = (from it in fltList
                                            where it.Level.Equals("INFO", StringComparison.OrdinalIgnoreCase)
                                            select it).Count();

                    ItemsWarnFilterCount = (from it in fltList
                                            where it.Level.Equals("WARN", StringComparison.OrdinalIgnoreCase)
                                            select it).Count();

                    ItemsErrorFilterCount = (from it in fltList
                                             where it.Level.Equals("ERROR", StringComparison.OrdinalIgnoreCase)
                                             select it).Count();

                    ItemsFatalFilterCount = (from it in fltList
                                             where it.Level.Equals("FATAL", StringComparison.OrdinalIgnoreCase)
                                             select it).Count();
                }
            }
            else
            {
                ItemsFilterCount = 0;
                ItemsDebugFilterCount = 0;
                ItemsInfoFilterCount = 0;
                ItemsWarnFilterCount = 0;
                ItemsErrorFilterCount = 0;
                ItemsFatalFilterCount = 0;
            }
        }


        #endregion

        #region Auto Refresh

        /// <summary>
        /// IsAutoRefreshEnabled Property
        /// </summary>
        public bool IsAutoRefreshEnabled
        {
            get { return _isAutoRefreshEnabled; }
            set
            {
                _isAutoRefreshEnabled = value;
                RaisePropertyChanged(PROP_IsAutoRefreshEnabled);

                if (_dispatcherTimer != null)
                {
                    if (_isAutoRefreshEnabled)
                        _dispatcherTimer.Start();
                    else
                        _dispatcherTimer.Stop();
                }
            }
        }
        private bool _isAutoRefreshEnabled;
        public static string PROP_IsAutoRefreshEnabled = "IsAutoRefreshEnabled";

        /// <summary>
        /// AutoRefreshInterval Property
        /// </summary>
        public int AutoRefreshInterval
        {
            get { return _autoRefreshInterval; }
            set
            {
                _autoRefreshInterval = value;
                RaisePropertyChanged(PROP_AutoRefreshInterval);
                RaisePropertyChanged(PROP_AutoRefreshIntervalLocalized);
                if (_dispatcherTimer != null)
                    _dispatcherTimer.Interval = new TimeSpan(0, 0, _autoRefreshInterval);
            }
        }
        private int _autoRefreshInterval;
        public static string PROP_AutoRefreshInterval = "AutoRefreshInterval";

        public string AutoRefreshIntervalLocalized
        {
            get
            {
                return String.Format(Resources.MainWindowVM_AutoRefreshIntervalLocalized_Format,
                                     AutoRefreshInterval.ToString(System.Globalization.CultureInfo.GetCultureInfo(Properties.Resources.CultureName)));
            }

        }
        public static string PROP_AutoRefreshIntervalLocalized = "AutoRefreshIntervalLocalized";


        /// <summary>
        /// IncreaseInterval Command
        /// </summary>
        public ICommandAncestor CommandIncreaseInterval { get; protected set; }

        /// <summary>
        /// DecreaseInterval Command
        /// </summary>
        public ICommandAncestor CommandDecreaseInterval { get; protected set; }

        protected virtual object commandIncreaseIntervalExecute(object parameter)
        {
            AutoRefreshInterval += Constants.DEFAULT_REFRESH_INTERVAL;
            return null;
        }

        protected virtual object commandDecreaseIntervalExecute(object parameter)
        {
            if (AutoRefreshInterval > Constants.DEFAULT_REFRESH_INTERVAL)
                AutoRefreshInterval -= Constants.DEFAULT_REFRESH_INTERVAL;
            return null;
        }

        private DispatcherTimer _dispatcherTimer;

        private void dispatcherTimer_Tick(object sender, EventArgs e)
        {
            DateTime? currentLog = null;

            if (SelectedLogItem != null)
                currentLog = SelectedLogItem.TimeStamp;

            CommandRefresh.Execute(null);

            if (currentLog.HasValue)
            {
                while (IsLoading)
                    GlobalHelper.DoEvents();

                var currentItem = (from it in Items
                                   where DateTime.Compare(it.TimeStamp, currentLog.Value) == 0
                                   select it).FirstOrDefault<LogItem>();

                if (currentItem != null)
                    SelectedLogItem = currentItem;
            }
        }

        #endregion
    }
}