using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Windows.Controls;
using Correlator.Model;
using Correlator.Util;
using HandyControl.Controls;
using HandyControl.Data;
using NAudio.Wave;
using Prism.Commands;
using Prism.Mvvm;
using Prism.Services.Dialogs;

namespace Correlator.ViewModels
{
    public class AudioFileViewModel : BindableBase, IDialogAware
    {
        #region 属性绑定

        public string Title { get; private set; } = string.Empty;
        public event Action<IDialogResult> RequestClose;
        private List<AudioFile> _totalFiles;
        private List<AudioFile> _audioFiles;

        public List<AudioFile> AudioFiles
        {
            get => _audioFiles;
            set
            {
                _audioFiles = value;
                RaisePropertyChanged();
            }
        }

        private int _pageIndex = 1;

        public int PageIndex
        {
            get => _pageIndex;
            set
            {
                _pageIndex = value;
                RaisePropertyChanged();
            }
        }

        private int _maxPage;

        public int MaxPage
        {
            get => _maxPage;
            set
            {
                _maxPage = value;
                RaisePropertyChanged();
            }
        }

        #endregion

        #region DelegateCommand

        public DelegateCommand GoBackCommand { get; set; }
        public DelegateCommand<DataGrid> ItemSelectedCommand { get; set; }
        public DelegateCommand<string> PlayAudioCommand { get; set; }
        public DelegateCommand DeleteItemCommand { get; set; }
        public DelegateCommand ReLoadDataCommand { get; set; }
        public DelegateCommand<FunctionEventArgs<int>> PageUpdatedCmd { get; set; }

        #endregion

        private AudioFile _selectedFile;
        private WaveOutEvent _waveOutEvent = new WaveOutEvent();
        private AudioFileReader _audioFileReader;

        public AudioFileViewModel(IDialogService dialogService)
        {
            GoBackCommand = new DelegateCommand(delegate
            {
                if (_audioFileReader != null)
                {
                    _audioFileReader.Dispose();
                    _audioFileReader = null;
                }

                if (_waveOutEvent != null)
                {
                    _waveOutEvent.Dispose();
                    _waveOutEvent = null;
                }

                RequestClose?.Invoke(new DialogResult(ButtonResult.Cancel));
            });

            ItemSelectedCommand = new DelegateCommand<DataGrid>(delegate(DataGrid dataGrid)
            {
                _selectedFile = (AudioFile)dataGrid.SelectedItem;
            });

            PlayAudioCommand = new DelegateCommand<string>(delegate(string fullPath)
            {
                if (_waveOutEvent.PlaybackState == PlaybackState.Playing)
                {
                    _waveOutEvent.Stop();
                }
                else
                {
                    try
                    {
                        _audioFileReader = new AudioFileReader(fullPath);
                        _waveOutEvent.Init(_audioFileReader);
                        _waveOutEvent.Play();
                    }
                    catch (FormatException)
                    {
                        dialogService.ShowDialog(
                            "AlertMessageDialog",
                            new DialogParameters
                            {
                                { "AlertType", AlertType.Error }, { "Title", "温馨提示" }, { "Message", "音频文件已损坏，无法播放" }
                            },
                            delegate { }
                        );
                        // MessageBox.Show("音频文件损坏，无法播放", "温馨提示", MessageBoxButton.OK, MessageBoxImage.Error);
                    }
                }
            });

            DeleteItemCommand = new DelegateCommand(() =>
            {
                if (_selectedFile == null)
                {
                    Growl.Error("删除失败");
                    return;
                }

                try
                {
                    File.Delete(_selectedFile.FullPath);

                    //刷新数据
                    _totalFiles = GetTotalAudioFiles();
                    MaxPage = _totalFiles.Count.GetPageSize();
                    AudioFiles = _totalFiles.Take(RuntimeCache.PerPageItemCount).ToList();
                }
                catch (IOException)
                {
                    Growl.Error("删除失败");
                }
            });

            ReLoadDataCommand = new DelegateCommand(() => { Growl.Success("刷新成功"); });

            PageUpdatedCmd = new DelegateCommand<FunctionEventArgs<int>>(args =>
            {
                AudioFiles = _totalFiles
                    .Skip((args.Info - 1) * RuntimeCache.PerPageItemCount)
                    .Take(RuntimeCache.PerPageItemCount)
                    .ToList();
            });
        }

        public bool CanCloseDialog()
        {
            return true;
        }

        public void OnDialogClosed()
        {
        }

        public void OnDialogOpened(IDialogParameters parameters)
        {
            _totalFiles = GetTotalAudioFiles();
            MaxPage = _totalFiles.Count.GetPageSize();
            AudioFiles = _totalFiles.Take(RuntimeCache.PerPageItemCount).ToList();
        }

        private static List<AudioFile> GetTotalAudioFiles()
        {
            var audioFiles = new List<AudioFile>();
            var i = 1;
            //筛选大于1K的音频文件
            var files = new DirectoryInfo(DirectoryManager.GetAudioDir()).GetFiles("*", SearchOption.AllDirectories);
            foreach (var file in files)
            {
                if (file.Length < 1024)
                {
                    RuntimeCache.SmallAudioFiles.Add(file.FullName);
                }
                else
                {
                    audioFiles.Add(new AudioFile
                    {
                        Order = i++,
                        FileName = file.Name,
                        FullPath = DirectoryManager.GetAudioDir() + "\\" + file.Name,
                        FileSize = file.Length.FormatFileSize(),
                        CreationTime = file.LastWriteTime.ToString("yyyy-MM-dd HH:mm:ss"),
                        IsPlaying = false
                    });
                }
            }

            return audioFiles;
        }
    }
}