Wrap Panel Virtualization

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.ComponentModel.Composition;
using System.IO;
using System.Linq;
using System.Threading;
using System.Windows;
using System.Windows.Controls;
using MediaAssistant.Constants;
using MediaAssistant.Controls.AlternativeLocation;
using MediaAssistant.Controls.StatusMessageBar;
using MediaAssistant.DAL.Virtualization;
using MediaAssistant.EventArguments;
using MediaAssistant.Helper;
using MediaAssistant.Management;
using MediaAssistant.MusicDJ;
using MediaFS;
using MefBasic.Commans;
using MefBasic.Data;
using MefBasic.Extensions;
using MefBasic.Helper;
using MefBasic.Threading;
using Microsoft.Practices.Composite;
using Microsoft.Practices.Composite.Events;
using Microsoft.Win32;
using MediaAssistant.DAL;
using MediaAssistant.DAL.Constants;
using MediaAssistant.DAL.Helper;
using Newtonsoft.Json.Linq;

namespace MediaAssistant.Data
{
    [Serializable]
    [Export(typeof(LibraryDataSource))]
    public class LibraryDataSource : DependencyNotifyObject
    {
        public static readonly DependencyProperty SelectedLibraryItemProperty =
            DependencyProperty.Register("SelectedLibraryItem", typeof(LibraryItem), typeof(LibraryDataSource),
                                        new UIPropertyMetadata(null, OnPropertyChanged));

        [ImportingConstructor]
        public LibraryDataSource(IEventAggregator eventAggregator)
        {
            EventAggregator = eventAggregator;
            CurrentGenres = new ObservableCollection<string>();
            CurrentAlbums = new ObservableCollection<string>();
            CurrentArtists = new ObservableCollection<string>();
            CurrentComposers = new ObservableCollection<string>();
            ResultMusics = new ObservableCollection<Music>();
            ResultMovies = new ObservableCollection<Movie>();
            MusicPlayer = new MediaElement { LoadedBehavior = MediaState.Manual };
            PlayerUpdateTimer = new Timer(OnPlayerUpdateTimer, null, 0, 1000);
            Playlists = new ObservableCollection<LibraryItem>();

            PlayMovieCommand = new DelegateCommand(ExecutePlayMovie, CanExecutePlayMovie);
            ShowMovieInWindowsExplorerCommand = new DelegateCommand(ExecuteShowMovieInWindowsExplorer, CanExecuteShowMovieInWindowsExplorer);
            ShowMovieInIMDBCommand = new DelegateCommand(ExecuteShowMovieInIMDB, CanExecuteShowMovieInIMDB);
            SaveMovieStateCommand = new DelegateCommand(ExecuteSaveMovieState, CanExecuteSaveMovieState);
            ShowAlternativeLocationsCommand = new DelegateCommand(ExecuteShowAlternativeLocations);

            MarkeAsPendingCommand = new DelegateCommand(ExecuteMarkeAsPending, CanExecuteExecuteMarkeAsPending);
            SelectLibraryItemCommand = new DelegateCommand(ExecuteSelectLibraryItem);

            RootItems = new ObservableCollection<LibraryItem>();

        }

        [Import]
        private Lazy<LibraryManager> LibraryManager { get; set; }

        public DelegateCommand SelectLibraryItemCommand { get; set; }

        private void ExecuteSelectLibraryItem(object obj)
        {
            SelectedLibraryItem = (LibraryItem)obj;
        }


        private bool CanExecuteExecuteMarkeAsPending(object arg)
        {
            return SelectedMovie != null;
        }

        public DelegateCommand MarkeAsPendingCommand { get; set; }

        private void ExecuteMarkeAsPending(object obj)
        {
            DatabaseManager.Instance.MarkAsPending(SelectedMovie);
            DatabaseManager.Instance.UpdateProcessingMovies();
            DatabaseManager.Instance.UpdateProcessingTitle(ShowDrivesMoviesOnly);
        }

        public DelegateCommand ShowAlternativeLocationsCommand { get; set; }

        private void ExecuteShowAlternativeLocations(object obj)
        {
            Resolve<AlternativeLocationPresenter>().ShowAlternativeLocations(SelectedMovie);
        }


        private bool CanExecuteSaveMovieState(object arg)
        {
            return SelectedMovie != null;
        }

        private void ExecuteSaveMovieState(object obj)
        {
            lock (DatabaseManager.LockObject)
            {
                var profileMovie = DatabaseManager.Instance.GetOrCreateProfileMovie(SelectedProfile, SelectedMovie);
                if (IsFavoriteMovieChanged(profileMovie))
                {
                    WaitScreen.Show();
                    StatusMessageService.SetStatusMessage("Updating recommended movies...");
                    TasteKidService.Value.UpdateRecommendation(SelectedMovie);
                    StatusMessageService.SetStatusMessage(StatusMessages.Ready);
                    WaitScreen.Hide();
                }
                DatabaseManager.Instance.UpdateProfile(profileMovie, SelectedMovie.IsStarred ? 1 : 0, SelectedMovie.Watched, SelectedMovie.IsInWishList, SelectedMovie.IsNew);
                UpdateTitles();
            }
        }

        public void UpdateTitles()
        {
            DatabaseManager.Instance.UpdateTitles(ShowDrivesMoviesOnly, SelectedProfile);
        }


        private bool _showDrivesMoviesOnly;
        public bool ShowDrivesMoviesOnly
        {
            get { return _showDrivesMoviesOnly; }
            set
            {
                _showDrivesMoviesOnly = value;
                if (ResultMusics.Count > 0 || ResultMovies.Count > 0)
                    SynchronizationContextHelper.Instance.SendInBackground(d => RefreshResult(), null);
                if (SelectedProfile != null)
                    DatabaseManager.Instance.UpdateTitles(ShowDrivesMoviesOnly, SelectedProfile);
                OnPropertyChanged("ShowDrivesMoviesOnly");
            }
        }

        [Import]
        private Lazy<TasteKidService> TasteKidService { get; set; }


        private bool IsFavoriteMovieChanged(ProfileMovie profileMovie)
        {
            return profileMovie.Star > 0 != SelectedMovie.IsStarred || profileMovie.IsInWishList != SelectedMovie.IsInWishList;
        }

        public DelegateCommand SaveMovieStateCommand { get; set; }

        private bool CanExecuteShowMovieInIMDB(object arg)
        {
            return SelectedMovie != null && SelectedMovie.IMDBId != null;
        }

        private bool CanExecuteShowMovieInWindowsExplorer(object arg)
        {
            return SelectedMovie != null;
        }

        private bool CanExecutePlayMovie(object arg)
        {
            return SelectedMovie != null;
        }

        private void RaiseCanExecuteChanged()
        {
            PlayMovieCommand.RaiseCanExecuteChanged();
            ShowMovieInWindowsExplorerCommand.RaiseCanExecuteChanged();
            ShowMovieInIMDBCommand.RaiseCanExecuteChanged();
            SaveMovieStateCommand.RaiseCanExecuteChanged();
            ShowAlternativeLocationsCommand.RaiseCanExecuteChanged();
            MarkeAsPendingCommand.RaiseCanExecuteChanged();
            LibraryManager.Value.RaiseCanExecuteChanged();
        }

        public DelegateCommand ShowMovieInIMDBCommand { get; set; }

        private void ExecuteShowMovieInIMDB(object obj)
        {
            if (SelectedMovie.IMDBId != null)
            {
                var imdbUrl = String.Format("http://www.imdb.com/title/{0}/", SelectedMovie.IMDBId);
                SystemHelper.OpenUrl(imdbUrl);
            }
        }

        private void ExecutePlayMovie(object obj)
        {
            var selectedMovie = obj as Movie ?? SelectedMovie;
            if (selectedMovie != null && VerifyFileLocation(selectedMovie))
                Play(selectedMovie);
        }


        private int _recommendedMovieCount;
        public int RecommendedMovieCount
        {
            get { return _recommendedMovieCount; }
            set
            {
                _recommendedMovieCount = value;
                OnPropertyChanged("RecommendedMovieCount");
            }
        }


        public DelegateCommand ShowMovieInWindowsExplorerCommand { get; set; }

        private void ExecuteShowMovieInWindowsExplorer(object obj)
        {
            var selectedMovie = obj as Movie ?? SelectedMovie;
            if (selectedMovie != null && VerifyFileLocation(selectedMovie))
                SystemHelper.LocateInWndowsExplorer(selectedMovie.FullPath);
        }

        public DelegateCommand PlayMovieCommand { get; set; }


        private ObservableCollection<IMusicDJ> _musicDjs;

        [ImportMany(typeof(IMusicDJ))]
        public ObservableCollection<IMusicDJ> MusicDjs
        {
            get { return _musicDjs; }
            set
            {
                _musicDjs = value;
                OnPropertyChanged("MusicDjs");
            }
        }


        private IMusicDJ _selectedMusicDJ;
        public IMusicDJ SelectedMusicDJ
        {
            get { return _selectedMusicDJ; }
            set
            {
                _selectedMusicDJ = value;
                OnPropertyChanged("SelectedMusicDJ");
            }
        }

        private ObservableCollection<LibraryItem> _playlists;
        public ObservableCollection<LibraryItem> Playlists
        {
            get { return _playlists; }
            set
            {
                _playlists = value;
                OnPropertyChanged("Playlists");
            }
        }


        protected Timer PlayerUpdateTimer { get; set; }

        private void OnPlayerUpdateTimer(object state)
        {
            SynchronizationContextHelper.Instance.SendInBackground(UpdateTimer, state);
        }

        public Music PlayingMusic
        {
            get { return (Music)GetValue(PlayingMusicProperty); }
            set { SetValue(PlayingMusicProperty, value); }
        }

        public static readonly DependencyProperty PlayingMusicProperty =
            DependencyProperty.Register("PlayingMusic", typeof(Music), typeof(LibraryDataSource), new UIPropertyMetadata(null, OnPropertyChanged));


        public ObservableCollection<LibraryItem> RootItems
        {
            get { return (ObservableCollection<LibraryItem>)GetValue(RootItemsProperty); }
            set { SetValue(RootItemsProperty, value); }
        }

        public static readonly DependencyProperty RootItemsProperty =
            DependencyProperty.Register("RootItems", typeof(ObservableCollection<LibraryItem>), typeof(LibraryDataSource), new UIPropertyMetadata(null));


        private ObservableCollection<string> _currentArtists;
        public ObservableCollection<string> CurrentArtists
        {
            get { return _currentArtists; }
            set
            {
                _currentArtists = value;
                OnPropertyChanged("CurrentArtists");
            }
        }

        private ObservableCollection<string> _currentAlbums;
        public ObservableCollection<string> CurrentAlbums
        {
            get { return _currentAlbums; }
            set
            {
                _currentAlbums = value;
                OnPropertyChanged("CurrentAlbums");
            }
        }

        private ObservableCollection<string> _currentComposers;
        public ObservableCollection<string> CurrentComposers
        {
            get { return _currentComposers; }
            set
            {
                _currentComposers = value;
                OnPropertyChanged("CurrentComposers");
            }
        }

        private ObservableCollection<string> _currentGenres;
        public ObservableCollection<string> CurrentGenres
        {
            get { return _currentGenres; }
            set
            {
                _currentGenres = value;
                OnPropertyChanged("CurrentGenres");
            }
        }

        private ObservableCollection<Music> _resultMusics;
        public ObservableCollection<Music> ResultMusics
        {
            get { return _resultMusics; }
            set
            {
                _resultMusics = value;
                OnPropertyChanged("ResultMusics");
            }
        }

        private ObservableCollection<Movie> _resultMovies;
        public ObservableCollection<Movie> ResultMovies
        {
            get { return _resultMovies; }
            set
            {
                _resultMovies = value;
                OnPropertyChanged("ResultMovies");
            }
        }


        public LibraryItem SelectedLibraryItem
        {
            get { return (LibraryItem)GetValue(SelectedLibraryItemProperty); }
            set
            {
                if (value == SelectedLibraryItem)
                {
                    LoadSelectedItemResults();
                }
                SetValue(SelectedLibraryItemProperty, value);
            }
        }

        public IEventAggregator EventAggregator { get; private set; }

        public void LoadLibrary()
        {
            DatabaseManager.Instance.CreateFixedLibraryItems();
            foreach (var rootItem in DatabaseManager.Instance.GetRootLibraryItems())
            {
                SynchronizationContextHelper.Instance.Send(d => RootItems.Add((LibraryItem)d), rootItem);
            }
            RefreshOrderedLibraryItems();

            foreach (var musicDj in MusicDjs)
            {
                musicDj.DataSource = this;
            }
            SelectedMusicDJ = MusicDjs.FirstOrDefault(m => m.Name == MusicDJName.SmartDJ);
            Playlists.Clear();
            Playlists.AddRange(DatabaseManager.Instance.GetAllPlaylists());
            ShowDrivesMoviesOnly = RegistryHelper.ShowDrivesMoviesOnly;
        }

        public void RefreshOrderedLibraryItems()
        {
            var job = new Job(j =>
                                  {
                                      var rootItems = j.Store.GetObject<ObservableCollection<LibraryItem>>();
                                      var orderedLibraryItems = new VirtualizingCollection<LibraryItem>(new LibraryItemProvider(rootItems));
                                      j.Store.Add(orderedLibraryItems);
                                  });
            job.Store.Add(RootItems);
            job.JobCompleted+=(s,e)=> OrderedLibraryItems = job.Store.GetObject<VirtualizingCollection<LibraryItem>>();
            job.Start();
        }

        private IList<LibraryItem> _orderedLibraryItems;
        public IList<LibraryItem> OrderedLibraryItems
        {
            get { return _orderedLibraryItems; }
            set
            {
                _orderedLibraryItems = value;
                OnPropertyChanged("OrderedLibraryItems");
            }
        }

        private static void OnPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var dataSource = (LibraryDataSource)d;
            dataSource.DoPropertyChanged(e);
        }

        public bool CanPlay
        {
            get { return (bool)GetValue(CanPlayProperty); }
            set { SetValue(CanPlayProperty, value); }
        }

        public static readonly DependencyProperty CanPlayProperty =
            DependencyProperty.Register("CanPlay", typeof(bool), typeof(LibraryDataSource), new UIPropertyMetadata(false));


        public void DoPropertyChanged(DependencyPropertyChangedEventArgs e)
        {
            switch (e.Property.Name)
            {
                case "SelectedLibraryItem":
                    LoadSelectedItemResults();
                    break;
                case "PlayingMusic":
                    MusicPlayer.Source = PlayingMusic != null ? GetPlayingMusicUri(PlayingMusic.FullPath) : null;
                    if (e.OldValue != null)
                    {
                        DatabaseManager.Instance.SetMusicStatus((Music)e.OldValue, PlayingMusic);
                    }
                    if (e.NewValue != null)
                    {
                        DatabaseManager.Instance.SetMusicStatus((Music)e.NewValue, PlayingMusic);
                    }
                    CanPlay = SelectedMusic != null || PlayingMusic != null;
                    EventAggregator.GetEvent<BaseEvent<PlayingMusicEventArgs>>().Publish(new PlayingMusicEventArgs { Sender = this, Music = PlayingMusic });
                    break;
                case "IsPlaying":
                    if (PlayingMusic == null && SelectedMusic != null)
                    {
                        WaitScreen.Show();
                        Play(SelectedMusic);
                        var job = new Job(j =>
                                              {
                                                  var playingMusic = j.Store.GetObject<Music>();
                                                  var resultMusics = j.Store.GetObject<ObservableCollection<Music>>();
                                                  DatabaseManager.Instance.SetNowPlayingPlaylist(resultMusics, resultMusics, playingMusic);
                                                  StartMusicDJ(playingMusic);

                                              });
                        job.Store.Add(PlayingMusic);
                        job.Store.Add(ResultMusics);
                        job.JobCompleted += (s, arg) => WaitScreen.Hide();
                        job.Start();
                    }
                    if (PlayingMusic != null)
                    {
                        if (IsPlaying)
                        {
                            MusicPlayer.Stop();
                            MusicPlayer.Close();
                            MusicPlayer.Play();
                            UpdateTimer(null);
                        }
                        else
                        {
                            MusicPlayer.Pause();
                        }
                    }
                    CanPlay = SelectedMusic != null || PlayingMusic != null;
                    break;
                case "SelectedMusic":
                    CanPlay = SelectedMusic != null || PlayingMusic != null;
                    break;
                case "SelectedMusicDJ":
                    if (PlayingMusic != null)
                    {
                        SelectedMusicDJ.Initialize(PlayingMusic);
                    }
                    break;
                case "MusicPlayer":
                    MusicPlayer.MediaEnded += HandleMediaEndedEvent;
                    MusicPlayer.MediaOpened += HandleMediaOpenedEvent;
                    MusicPlayer.MediaFailed += HandleMediaFailedEvent;
                    break;
                case "NaturalDuration":
                    DatabaseManager.Instance.UpdateDuration(PlayingMusic, NaturalDuration);
                    break;
                case "Position":
                    if (IsUpdatingTime == false)
                        MusicPlayer.Position = Position;
                    break;
                case "SelectedMovie":
                    if (e.NewValue != null)
                    {
                        var movie = ((Movie)e.NewValue);
                        movie.PropertyChanged += MoviePropertyChangedHandler;
                        if (SelectedProfile!=null && movie.IsNew)
                            DatabaseManager.Instance.MarkAsRead(movie,SelectedProfile);
                    }
                    if (e.OldValue != null)
                    {
                        ((Movie)e.OldValue).PropertyChanged -= MoviePropertyChangedHandler;
                    }
                    RaiseCanExecuteChanged();
                    break;
            }
        }

        public void RefreshResult()
        {
            RegistryHelper.ShowDrivesMoviesOnly = ShowDrivesMoviesOnly;
            WaitScreen.Show();
            if (RegistryHelper.LastResultType == LibraryItemType.MusicType)
            {
                SetMusicResults(ResultMusics.ToArray());
            }
            else
            {
                if (_originalResultMovies != null)
                {
                    SetMovieResults(_originalResultMovies);
                }
                DatabaseManager.Instance.UpdateTitles(ShowDrivesMoviesOnly, SelectedProfile);
            }

            WaitScreen.Hide();
        }


        private void MoviePropertyChangedHandler(object sender, PropertyChangedEventArgs e)
        {
            SynchronizationContextHelper.Instance.SendInBackground(d => RaiseCanExecuteChanged(), null);
        }

        private void HandleMediaFailedEvent(object sender, ExceptionRoutedEventArgs e)
        {
            if (PlayingMusic==null)
                return;
            PlayingMusic.Status = MusicStatus.Failed;
            PlayNextMusic();
        }

        private void PlayNextMusic()
        {
            if (PlayingMusic.Status == MusicStatus.Playing)
            {
                DatabaseManager.Instance.AdvanceScore(SelectedProfile, PlayingMusic, 0.5);
            }
            if (SelectedMusicDJ.CanMoveNext)
                SelectedMusicDJ.Next();
        }

        private void HandleMediaOpenedEvent(object sender, RoutedEventArgs e)
        {
            PlayingMusic.Status = MusicStatus.Playing;
        }

        private void HandleMediaEndedEvent(object sender, RoutedEventArgs e)
        {
            if (IsPlaying == false)
                return;
            if (PlayingMusic != null)
            {
                DatabaseManager.Instance.AdvanceScore(SelectedProfile, PlayingMusic, 0.5);
            }
            if (SelectedMusicDJ.CanMoveNext)
            {
                SelectedMusicDJ.Next();
            }
        }

        private void UpdateTimer(object state)
        {
            IsUpdatingTime = true;
            Position = MusicPlayer.Position;
            NaturalDuration = MusicPlayer.NaturalDuration;
            if (NaturalDuration.HasTimeSpan)
            {
                TimeRemains = Position - NaturalDuration.TimeSpan;
            }
            IsUpdatingTime = false;
        }

        protected bool IsUpdatingTime { get; set; }


        public TimeSpan TimeRemains
        {
            get { return (TimeSpan)GetValue(TimeRemainsProperty); }
            set { SetValue(TimeRemainsProperty, value); }
        }

        public static readonly DependencyProperty TimeRemainsProperty =
            DependencyProperty.Register("TimeRemains", typeof(TimeSpan), typeof(LibraryDataSource), new UIPropertyMetadata(default(TimeSpan)));



        public Duration NaturalDuration
        {
            get { return (Duration)GetValue(NaturalDurationProperty); }
            set { SetValue(NaturalDurationProperty, value); }
        }

        public static readonly DependencyProperty NaturalDurationProperty =
            DependencyProperty.Register("NaturalDuration", typeof(Duration), typeof(LibraryDataSource), new UIPropertyMetadata(default(Duration), OnPropertyChanged));


        public TimeSpan Position
        {
            get { return (TimeSpan)GetValue(PositionProperty); }
            set { SetValue(PositionProperty, value); }
        }

        public static readonly DependencyProperty PositionProperty =
            DependencyProperty.Register("Position", typeof(TimeSpan), typeof(LibraryDataSource), new UIPropertyMetadata(default(TimeSpan), OnPropertyChanged));



        private Uri GetPlayingMusicUri(string fullPath)
        {
            if (PlayingMusic != null)
                return new Uri(String.Format("file://{0}", fullPath));
            return null;
        }

        public void AddFilesInBackground(IEnumerable<string> fileNames)
        {
            StatusMessageService.SetStatusMessage("Adding files");
            var job = new Job(j => AddFiles(fileNames));
            job.StartBlocked();
            DatabaseManager.Instance.UpdateNewMovieTitle(ShowDrivesMoviesOnly, SelectedProfile);
            DatabaseManager.Instance.UpdateProcessingTitle(ShowDrivesMoviesOnly);
            StatusMessageService.SetStatusMessage(StatusMessages.Ready);
        }

        private void AddFiles(IEnumerable<string> fileNames)
        {
            WaitScreen.Show(fileNames.Count(), 0);
            var progress = 0;
            foreach (string fileName in fileNames)
            {
                AddFile(fileName, progress++);
            }
        }

        private void AddFile(string fileName, int progress)
        {
            SynchronizationContextHelper.Instance.Send(AddFileWithProgress, new object[] { fileName, progress });
            Thread.Sleep(100);
        }
        [Import]
        public StatusMessageBarPresenter StatusMessageBarPresenter { get; set; }
        private void AddFileWithProgress(object o)
        {
            var fileName = (string)((object[])o)[0];
            var progress = (int)((object[])o)[1];
            WaitScreen.Show(progress);
            if (Utility.IsMusicFile(fileName))
                StatusMessageBarPresenter.SetMessage(String.Format(StatusMessages.AddingMusic, fileName));
            else if (Utility.IsMovieFile(fileName))
            {
                StatusMessageBarPresenter.SetMessage(String.Format(StatusMessages.AddingMovie, fileName));
            }
            DatabaseManager.Instance.AddFile(fileName);
        }

        public void SelectLastImportedPlaylist()
        {
            var lastImportedPlaylist = DatabaseManager.Instance.GetLastImportedPlaylist();
            SelectedLibraryItem = null;
            SelectedLibraryItem = lastImportedPlaylist;
        }

        public void SetMusicResults(IEnumerable<Music> musics)
        {
            ResultMusics.Clear();
            var index = 1;
            WaitScreen.Show(musics.Count(), index - 1);
            foreach (var music in musics)
            {
                music.Index = index++;
                music.Preferance = string.Empty;
                WaitScreen.Show(musics.Count(), index);
                ResultMusics.Add(music);
                Application.Current.DoEvents();
            }
            UpdateCurrentLists();
        }

        public void UpdateCurrentLists()
        {
            WaitScreen.Show();

            CurrentGenres.Clear();
            CurrentGenres.AddRange(ResultMusics.Where(m => string.IsNullOrWhiteSpace(m.Genre) == false).Select(m => m.Genre).Distinct().OrderBy(o => o));
            CurrentArtists.Clear();
            CurrentArtists.AddRange(ResultMusics.Where(m => string.IsNullOrWhiteSpace(m.Artist) == false).Select(m => m.Artist).Distinct().OrderBy(o => o));
            CurrentAlbums.Clear();
            CurrentAlbums.AddRange(ResultMusics.Where(m => string.IsNullOrWhiteSpace(m.Album) == false).Select(m => m.Album).Distinct().OrderBy(o => o));
            CurrentComposers.Clear();
            CurrentComposers.AddRange(ResultMusics.Where(m => string.IsNullOrWhiteSpace(m.Composer) == false).Select(m => m.Composer).Distinct().OrderBy(o => o));
            WaitScreen.Hide();
        }

        public void SetMovieResults(IEnumerable<Movie> movies)
        {
            SetMovieResults(movies, m => m.Rating);
        }

        [Import]
        private WaitScreenService WaitScreen { get; set; }
        public void SetMovieResults(IEnumerable<Movie> movies, Func<Movie, double?> orderBySelector)
        {
            if (movies == null)
                return;
            _originalResultMovies = movies;
            var resultMovies = new ObservableCollection<Movie>();
            resultMovies.Clear();
            var index = 1;
            var resultArray = ShowDrivesMoviesOnly ? movies.Where(m => m.IsLocal()) : movies;
            var orderedArray = orderBySelector == null ? resultArray.ToArray() : resultArray.OrderByDescending(orderBySelector).ToArray();
            WaitScreen.Show(orderedArray.Length, index - 1);
            foreach (var movie in orderedArray)
            {
                movie.Index = index++;
                if (movie.Size==null && File.Exists(movie.FullPath))
                {
                    DatabaseManager.Instance.UpdateMovieFileSize(movie);
                }
                resultMovies.Add(movie);

                WaitScreen.Show(orderedArray.Length, index - 1);
                Application.Current.DoEvents();
            }
            ResultMovies = resultMovies;
            SelectedMovie = ResultMovies.FirstOrDefault();
        }

        public void InitializeMovieForList(Movie movie)
        {
            var profileMovie = DatabaseManager.Instance.GetProfileMovie(SelectedProfile, movie);
            if (profileMovie == null)
            {
                if (String.IsNullOrWhiteSpace(movie.FullPath) == false)
                    movie.IsNew = true;
            }
            else
            {
                movie.IsNew = profileMovie.IsNewMovie();
                movie.IsStarred = profileMovie.Star > 0;
                movie.Watched = profileMovie.Watched;
                movie.IsInWishList = profileMovie.IsInWishList.HasValue && profileMovie.IsInWishList.Value;
            }
        }

        [Import]
        private Lazy<MusicDurationUpdater> MusicDurationUpdater { get; set; }
        public void UpdateDuration()
        {
            var musics = ResultMusics.Where(m => String.IsNullOrWhiteSpace(m.TimeText) && m.Status != "Playing").ToArray();
            if (musics.Count() <= 0) return;
            MusicDurationUpdater.Value.AddRange(musics);
        }

        [Import]
        private Lazy<BackgroundScannerManager> BackgroundScannerManager { get; set; }
        private void LoadSelectedItemResults()
        {
            if (SelectedLibraryItem == null)
                return;
            WaitScreen.Show();
            BackgroundScannerManager.Value.Pause();
            switch (SelectedLibraryItem.Type)
            {
                case LibraryItemType.ProcessingLibrary:
                    SetMovieResults(DatabaseManager.Instance.UpdateProcessingMovies());
                    break;
                case LibraryItemType.FailedLibrary:
                    SetMovieResults(DatabaseManager.Instance.GetFailedMovies());
                    break;
                case LibraryItemType.UnreadMovieLibrary:
                    if (SelectedProfile != null)
                    {
                        SetMovieResults(DatabaseManager.Instance.GetNewMovies(SelectedProfile));
                    }
                    break;
                case LibraryItemType.WatchListLibrary:
                    if (SelectedProfile != null)
                    {
                        SetMovieResults(DatabaseManager.Instance.GetWatchedMovies(SelectedProfile));
                    }
                    break;
                case LibraryItemType.WishListLibrary:
                    if (SelectedProfile != null)
                    {
                        SetMovieResults(DatabaseManager.Instance.GetWishListMovie(SelectedProfile));
                    }
                    break;
                case LibraryItemType.StaredMovieLibrary:
                    if (SelectedProfile != null)
                    {
                        SetMovieResults(DatabaseManager.Instance.GetStarMovies(SelectedProfile));
                    }
                    break;
                case LibraryItemType.RecommendedMovieLibrary:
                    if (SelectedProfile != null)
                    {
                        SetMovieResults(DatabaseManager.Instance.GetRecommendedMovies(SelectedProfile), null);
                    }
                    break;
                case LibraryItemType.RecentlyPlayedMovieLibrary:
                    if (SelectedProfile != null)
                    {
                        SetMovieResults(DatabaseManager.Instance.GetRecentlyPlayedMovies(SelectedProfile), null);
                    }
                    break;
                case LibraryItemType.IMDbMustWatchList:
                    DatabaseManager.Instance.UpdateIMDBMustWatchList();
                    ShowSelectedLibraryItemsResult();
                    break;
                case LibraryItemType.MovieLibrary:
                    SetMovieResults(DatabaseManager.Instance.GetAllMovies());
                    break;
                case LibraryItemType.MusicLibrary:
                    SetMusicResults(DatabaseManager.Instance.GetAllMusics());
                    UpdateDuration();
                    break;
                
                default:
                    ShowSelectedLibraryItemsResult();
                    break;
            }

            BackgroundScannerManager.Value.Resume();
            EventAggregator.GetEvent<BaseEvent<PerformSelectedItemActionEventArgs>>().Publish(new PerformSelectedItemActionEventArgs(this, SelectedLibraryItem));
            WaitScreen.Hide();
        }

        private void ShowSelectedLibraryItemsResult()
        {
            var job = new Job(ExecuteGetAllMoviesOrMusics);
            job.Store.Add(SelectedLibraryItem);
            job.StartBlocked();
            if (LibraryItemType.IsMusicItem(SelectedLibraryItem.Type))
            {
                SetMusicResults(job.Store.GetObject<IEnumerable<Music>>());
                UpdateDuration();
            }
            else
            {
                SetMovieResults(job.Store.GetObject<IEnumerable<Movie>>());
            }
        }

        private static void ExecuteGetAllMoviesOrMusics(Job obj)
        {
            var libraryItem = obj.Store.GetObject<LibraryItem>();
            if (LibraryItemType.IsMusicItem(libraryItem.Type))
            {
                obj.Store.Add(libraryItem.GetAllMusic());
            }
            else
            {
                obj.Store.Add(libraryItem.GetAllMovies());
            }
        }

        public void Play(Music music)
        {
            if (PlayingMusic == music)
                return;
            PlayingMusic = music;
            DatabaseManager.Instance.AdvanceScore(SelectedProfile, PlayingMusic, 0.5);
            IsPlaying = true;
        }


        public MediaElement MusicPlayer
        {
            get { return (MediaElement)GetValue(MusicPlayerProperty); }
            set { SetValue(MusicPlayerProperty, value); }
        }

        public static readonly DependencyProperty MusicPlayerProperty =
            DependencyProperty.Register("MusicPlayer", typeof(MediaElement), typeof(LibraryDataSource), new UIPropertyMetadata(null, OnPropertyChanged));


        public bool IsPlaying
        {
            get { return (bool)GetValue(IsPlayingProperty); }
            set { SetValue(IsPlayingProperty, value); }
        }

        public Music SelectedMusic
        {
            get { return (Music)GetValue(SelectedMusicProperty); }
            set { SetValue(SelectedMusicProperty, value); }
        }

        public static readonly DependencyProperty SelectedMusicProperty =
            DependencyProperty.Register("SelectedMusic", typeof(Music), typeof(LibraryDataSource), new UIPropertyMetadata(null, OnPropertyChanged));



        public static readonly DependencyProperty IsPlayingProperty =
            DependencyProperty.Register("IsPlaying", typeof(bool), typeof(LibraryDataSource), new UIPropertyMetadata(false, OnPropertyChanged));


        public void AddFolderInBackground(string folderPath)
        {
            AddFilesInBackground(CollectFileNames(folderPath));
        }

        [Import]
        private StatusMessageService StatusMessageService { get; set; }

        private IEnumerable<string> CollectFileNames(string folderPath)
        {
            StatusMessageService.SetStatusMessage("Searching folder for musics and movies");
            var files = new List<string>();
            new Job(j => AddFolderRecursively(folderPath, files)).StartBlocked();
            return files;
        }

        private static void AddFolderRecursively(string folderPath, List<string> files)
        {
            files.AddRange(Directory.GetFiles(folderPath, "*.mp3"));
            files.AddRange(Directory.GetFiles(folderPath, "*.wma"));
            foreach (var extension in Utility.SupportedMovieFileExtension)
            {
                files.AddRange(Directory.GetFiles(folderPath, "*" + extension));
            }

            foreach (string directory in Directory.GetDirectories(folderPath))
            {
                AddFolderRecursively(directory, files);
            }
        }

        public void SelectMusicDJ(string dJName)
        {
            SelectedMusicDJ = MusicDjs.FirstOrDefault(d => d.Name == dJName);
        }

        public void StartMusicDJ(Music playingMusic)
        {
            if (playingMusic == null || SelectedMusicDJ == null) return;
            SelectedMusicDJ.Initialize(playingMusic);
        }

        public void SelectProfile(string profileName)
        {
            SelectedProfile = DatabaseManager.Instance.GetProfile(profileName);
        }

        public Profile SelectedProfile
        {
            get { return _selectedProfile; }
            set
            {
                _selectedProfile = value;
                OnPropertyChanged("SelectedProfile");
                MediaFSManager.Instance.SelectedProfile = value;
            }
        }


        public Movie SelectedMovie
        {
            get { return (Movie)GetValue(SelectedMovieProperty); }
            set { SetValue(SelectedMovieProperty, value); }
        }

        public static readonly DependencyProperty SelectedMovieProperty =
            DependencyProperty.Register("SelectedMovie", typeof(Movie), typeof(LibraryDataSource), new UIPropertyMetadata(null, OnPropertyChanged));

        private IEnumerable<Movie> _originalResultMovies;
        private Profile _selectedProfile;

        public bool IsPlaylistExists(string playlistTitle)
        {
            return Playlists.Any(p => String.Compare(p.Title, playlistTitle, true) == 0);
        }

        public LibraryItem CreatePlaylist(string playlistTitle)
        {
            var playlist = DatabaseManager.Instance.CreatePlaylist(playlistTitle);
            Playlists.Add(playlist);
            return playlist;
        }

        public LibraryItem GetPlaylist(string playlistTitle)
        {
            return Playlists.FirstOrDefault(p => String.Compare(p.Title, playlistTitle) == 0);
        }

        public void UpdateMusic(Music music)
        {
            var position = Position;
            if (music == PlayingMusic)
            {
                MusicPlayer.Stop();
                MusicPlayer.Close();
            }
            DatabaseManager.Instance.UpdateAndLink(music);
            if (PlayingMusic != null && music == PlayingMusic)
            {
                MusicPlayer.Source = GetPlayingMusicUri(PlayingMusic.FullPath);
                MusicPlayer.Position = position;
                if (IsPlaying)
                {
                    MusicPlayer.Play();
                }
            }
        }


        public void UpdateMovie(Movie movie, JObject jsonObject)
        {
            var newMovie = DatabaseManager.Instance.UpdateMovie(movie, jsonObject);
            if (movie.Equals(newMovie) == false)
            {
                var resultMovie = ResultMovies.FirstOrDefault(m => m.Equals(movie));
                if (resultMovie != null)
                {
                    newMovie.Index = resultMovie.Index;
                    ResultMovies.Remove(movie);
                    InsertMovieToCurrentResult(newMovie);
                    var originalResult = _originalResultMovies.ToList();
                    originalResult.Remove(resultMovie);
                    _originalResultMovies = originalResult;
                }
            }
        }

        private void InsertMovieToCurrentResult(Movie newMovie)
        {
            ResultMovies.Insert(newMovie.Index - 1, newMovie);
        }

        public void SelectYear(int year)
        {
            SelectedLibraryItem = DatabaseManager.Instance.GetYearLibraryItem(year);
        }

        private void Play(Movie movie)
        {
            DatabaseManager.Instance.IncrementPlayCount(movie, SelectedProfile);
            SystemHelper.PlayMovie(movie.FullPath);
        }

        private static bool VerifyFileLocation(Movie movie)
        {
            bool isExist = true;
            if (File.Exists(movie.FullPath) == false)
            {
                if (
                    MessageBox.Show(String.Format("Cannot access {0}. Press Ok to browse the movie?", movie.FullPath),
                                    "Cannot Access", MessageBoxButton.OKCancel) == MessageBoxResult.OK)
                {
                    var fileDialog = new OpenFileDialog { Filter = Utility.SupportedMovieFileFilter, Multiselect = false };
                    if (fileDialog.ShowDialog() == true)
                    {
                        DatabaseManager.Instance.UpdateMovieLocation(movie, fileDialog.FileName);

                    }
                    else
                    {
                        isExist = false;
                    }
                }
                else
                {
                    isExist = false;
                }
            }
            return isExist;
        }

        public void InitializeDatabase()
        {
            MusicPlayer.Volume = RegistryHelper.Volume;
            MusicPlayer.IsMuted = RegistryHelper.IsMuted;
            if (MediaAssistantEntities.IsUpdatedVersion == false)
            {
                DatabaseManager.Instance.ConvertOldVersionMusicLibrary();
            }
            SelectProfile(RegistryHelper.ProfileName);
            LoadLibrary();
            var selectedMusicDj = MusicDjs.SingleOrDefault(m => m.Name == RegistryHelper.SelectedMusicDJ);
            if (selectedMusicDj != null)
                SelectedMusicDJ = selectedMusicDj;
        }
    }
}