BakaMusicPlayer/Bmp.WinForms/MainForm.cs

using System.ComponentModel;
using System.Text;
using System.Threading.Channels;
using Bmp.Core.Common.EventBus;
using Bmp.Core.NAudioExt;
using Bmp.Core.Playback.Inputs;
using Bmp.Core.Playback.Outputs;
using Bmp.WinForms.SaveLoad;
using Bmp.WinForms.SaveLoad.Models;
using EnumsNET;
using Microsoft.AspNetCore.Identity.UI.Services;
using Microsoft.AspNetCore.Routing.Constraints;
using Microsoft.Extensions.Logging.Abstractions;
using NAudio.Wave;
using AsioOut = Bmp.Core.Playback.Outputs.NAudioASIO.AsioOut;

namespace Bmp.WinForms
{
    public partial class MainForm : Form
    {
        private const string EMOJI_X = "❌";
        private const string EMOJI_WARN = "⚠";
        private const string EMOJI_PLAY_BIG = "▶";
        private const string EMOJI_PLAY_SMALL = "⏵";

        private static readonly IReadOnlyCollection<string> SupportedDropTypes = new[] { DataFormats.FileDrop, DataFormats.Text };

        private readonly Channel<string> _pendingAddToList = Channel.CreateUnbounded<string>();

        private IServiceProvider? _serviceProvider;
        private ILogger<MainForm> _logger = new Logger<MainForm>(NullLoggerFactory.Instance);
        private IEventBus? _eventBus;
        private SaveLoadService? _sl;

        private bool _isRunning;

        private ListViewItem? _currentListViewItem;

        private IOutputDeviceInfo? _selectedOutputDevice;

        private WaveStream? _inputSource;
        private VisualizeDataMiddleWrap? _visualizeDataMiddleWrap;
        private IWavePlayer? _outputDevice;
        private bool _nativeDsd;

        private UIPlaybackState _playbackState;
        private bool _trackBarHolding;

        public MainForm()
        {
            Initialize();
            InitializeComponent();
        }

        private void Initialize() => Text = Const.AppTitle;

        public void SetServiceProvider(IServiceProvider serviceProvider) => _serviceProvider = serviceProvider;

        // -----------------  playback control -----------------

        private async Task LoadItemAsync(ListViewItem item)
        {
            await StopAsync();

            _playbackState = UIPlaybackState.Loading;

            _currentListViewItem = item;

            var finalState = EMOJI_PLAY_BIG;

            var balloonShow = false;
            ToolTipIcon? balloonIcon = null;
            string? balloonTitle = null;
            string? balloonContent = null;

            try
            {
                var meta = await Task.Run(() => InputSourceProvider.GetMeta(item.Name));
                if (meta.Error == null)
                {
                    var fileName = Path.GetFileNameWithoutExtension(item.Name);
                    if (Uri.TryCreate(item.Name, UriKind.Absolute, out var url))
                    {
                        fileName = Path.GetFileNameWithoutExtension(url.LocalPath);
                    }

                    item.SubItems[TitleColumnHeader.Index].Text = meta.Title ?? fileName;
                    if (!string.IsNullOrEmpty(meta.Artist)) item.SubItems[TitleColumnHeader.Index].Text += " - " + meta.Artist;

                    if (meta.Album != null && meta.TrackNo.HasValue)
                    {
                        item.SubItems[TitleColumnHeader.Index].Text =
                            $"{meta.Album} #{meta.TrackNo:00} - " + item.SubItems[TitleColumnHeader.Index].Text;
                    }

                    item.SubItems[DurColumnHeader.Index].Text = meta.Duration.ToString("hh\\:mm\\:ss");

                    item.ToolTipText = item.Name;

                    foreach (var pair in meta.RawTags.OrderBy(p => p.Key))
                    {
                        item.ToolTipText += $"{Environment.NewLine}{pair.Key}:{pair.Value}";
                    }
                }
                else
                {
                    finalState = EMOJI_WARN;
                    item.ToolTipText =
                        item.Name
                        + Environment.NewLine
                        + "无法获取元数据"
                        + Environment.NewLine
                        + meta.Error.Message;
                }

                try
                {
                    _inputSource = await Task.Run(() => InputSourceProvider.CreateWaveStream(item.Name, _sl?.State?.DecodeDsdToPcm == true));
                }
                catch (Exception e)
                {
                    finalState = EMOJI_X;
                    item.ToolTipText =
                        item.Name
                        + Environment.NewLine
                        + "无法加载文件"
                        + Environment.NewLine
                        + e.Message;
                    _playbackState = UIPlaybackState.Error;
                    return;
                }

                await PlayAsync();
            }
            finally
            {
                item.SubItems[StateColumnHeader.Index].Text = finalState;
                if (balloonShow)
                {
                    SettingButtonToolTip.ToolTipIcon = balloonIcon ?? ToolTipIcon.None;
                    SettingButtonToolTip.ToolTipTitle = balloonTitle;
                    if (balloonContent != null)
                    {
                        SettingButtonToolTip.Show(balloonContent, SettingButton);
                        SettingButtonToolTip.Show(balloonContent, SettingButton);
                    }
                }
                else
                {
                    SettingButtonToolTip.Hide(SettingButton);
                }
            }
        }

        private async Task DeInitOutputDevice()
        {
            var local = _outputDevice;
            _outputDevice = null;
            if (local != null)
            {
                local.PlaybackStopped -= _outputDevice_PlaybackStopped;
                local.Stop();
                local.Dispose();
            }
        }

        private async Task<bool> ReInitOutputDevice()
        {
            await DeInitOutputDevice();

            var finalState = EMOJI_PLAY_BIG;

            bool balloonShow = false;
            ToolTipIcon? balloonIcon = null;
            string? balloonTitle = null;
            string? balloonContent = null;

            try
            {
                if (_inputSource is DsdAbstractSourceStream)
                {
                    _nativeDsd = true;
                    //TODO: 匹配原生DSD设备
                    if (_sl?.State?.SelectedDsdAsioOutputDeviceId == null)
                    {
                        finalState = EMOJI_X;
                        balloonShow = true;
                        balloonIcon = ToolTipIcon.Error;
                        balloonTitle = "未指定 DSD 输出设备";
                        balloonContent = "在设置菜单选择输出设备";
                        _playbackState = UIPlaybackState.Error;
                        return false;
                    }

                    var allDevices = OutputDeviceProvider.GetAllSupportedDevices();
                    IOutputDeviceInfo? selectedDevice = null;

                    selectedDevice = allDevices.FirstOrDefault(p => p.Id == _sl?.State?.SelectedDsdAsioOutputDeviceId);

                    if (selectedDevice == null)
                    {
                        //TODO: 消息机制 错误 找不到指定的输出设备

                        balloonShow = true;
                        balloonIcon = ToolTipIcon.Warning;
                        balloonTitle = "找不到指定的 DSD 输出设备";
                        balloonContent = "在设置菜单选择输出设备";
                        _playbackState = UIPlaybackState.Error;
                        return false;
                    }

                    _selectedOutputDevice = selectedDevice;
                }
                else
                {
                    _nativeDsd = false;
                    if (_sl?.State?.SelectedPcmOutputDeviceId == null)
                    {
                        //TODO: 消息机制 错误 未指定输出设备

                        finalState = EMOJI_X;
                        balloonShow = true;
                        balloonIcon = ToolTipIcon.Error;
                        balloonTitle = "未指定 PCM 输出设备";
                        balloonContent = "在设置菜单选择输出设备";
                        _playbackState = UIPlaybackState.Error;
                        return false;
                    }

                    var allDevices = OutputDeviceProvider.GetAllSupportedDevices();
                    IOutputDeviceInfo? selectedDevice = null;

                    selectedDevice = allDevices.FirstOrDefault(p => p.Id == _sl.State.SelectedPcmOutputDeviceId);

                    if (selectedDevice == null)
                    {
                        //TODO: 消息机制 错误 找不到指定的输出设备

                        balloonShow = true;
                        balloonIcon = ToolTipIcon.Warning;
                        balloonTitle = "找不到指定的 PCM 输出设备";
                        balloonContent = "在设置菜单选择输出设备";
                        _playbackState = UIPlaybackState.Error;
                        return false;
                    }

                    _selectedOutputDevice = selectedDevice;
                }

                _visualizeDataMiddleWrap = new VisualizeDataMiddleWrap(_inputSource!);
                _visualizeDataMiddleWrap.DataTransferred += _visualizeDataMiddleWrap_DataTransferred;

                try
                {
                    _outputDevice = OutputDeviceProvider.CreateWavePlayer(_selectedOutputDevice, _nativeDsd);
                }
                catch (Exception e)
                {
                    //TODO: 消息机制 错误 无法打开设备

                    finalState = EMOJI_X;

                    balloonShow = true;
                    balloonIcon = ToolTipIcon.Error;
                    balloonTitle = "无法启动播放";
                    balloonContent = "无法打开输出设备" + Environment.NewLine + e.Message;
                    _playbackState = UIPlaybackState.Error;
                    return false;
                }

                try
                {
                    _outputDevice.Init(_visualizeDataMiddleWrap);
                }
                catch (Exception e)
                {
                    //TODO: 消息机制 错误 无法初始化设备
                    finalState = EMOJI_X;

                    balloonShow = true;
                    balloonIcon = ToolTipIcon.Error;
                    balloonTitle = "无法启动播放";
                    balloonContent = "无法初始化输出设备" + Environment.NewLine + e.Message;
                    return false;
                }

                _outputDevice.PlaybackStopped += _outputDevice_PlaybackStopped;
            }
            catch (Exception e)
            {
                _currentListViewItem!.SubItems[StateColumnHeader.Index].Text = finalState;
                if (balloonShow)
                {
                    SettingButtonToolTip.ToolTipIcon = balloonIcon ?? ToolTipIcon.None;
                    SettingButtonToolTip.ToolTipTitle = balloonTitle;
                    if (balloonContent != null)
                    {
                        SettingButtonToolTip.Show(balloonContent, SettingButton);
                        SettingButtonToolTip.Show(balloonContent, SettingButton);
                    }
                }
                else
                {
                    SettingButtonToolTip.Hide(SettingButton);
                }
            }

            return true;
        }

        private async Task StopAsync()
        {
            _playbackState = UIPlaybackState.Stopped;
            await DeInitOutputDevice();

            if (_inputSource != null) await _inputSource.DisposeAsync();
            _inputSource = null;

            if (_currentListViewItem != null)
            {
                var subItem = _currentListViewItem.SubItems[StateColumnHeader.Index];

                if (subItem.Text == EMOJI_PLAY_BIG) subItem.Text = "";
            }
        }

        private async Task PlayAsync()
        {
            _playbackState = UIPlaybackState.Playing;
            if (await ReInitOutputDevice())
            {
                try
                {
                    _outputDevice?.Play();
                }
                catch (Exception e)
                {
                    //TODO: 异常处理
                    _playbackState = UIPlaybackState.Error;
                }
            }
        }

        private async Task PauseAsync()
        {
            _playbackState = UIPlaybackState.Paused;
            await DeInitOutputDevice();
        }

        private void TrackPrev()
        {
            //TODO: 上一曲
        }

        private void TrackNext()
        {
            //TODO: 下一曲
        }

        // -----------------  playback event -----------------

        private void _visualizeDataMiddleWrap_DataTransferred(object? sender, VisualizeDataEventArgs e)
        {
            //TODO: 视觉效果
        }

        private async void _outputDevice_PlaybackStopped(object? sender, StoppedEventArgs e)
        {
            if (_playbackState == UIPlaybackState.Seeking) return;
            if (_playbackState == UIPlaybackState.Paused) return;
            if (_playbackState == UIPlaybackState.Loading) return;

            if (e.Exception == null)
            {
                //TODO: 正常播放结束 下一曲(按播放模式)
                _playbackState = UIPlaybackState.Stopped; //列表最后一项时
            }
            else
            {
                //TODO: 消息机制
                _playbackState = UIPlaybackState.Error;
            }
        }

        // -----------------  UI func -----------------

        private void SaveState()
        {
            if (_sl == null) return;
            if (_sl.State != null)
            {
                _sl.State.FormPosition = Location;
                _sl.State.FormSize = Size;

                _sl.State.Playlist = MainListView.Items.Cast<ListViewItem>().Select(p => new SaveLoadPlaylistItem
                {
                    Path = p.Name,
                    Title = p.SubItems[TitleColumnHeader.Index].Text,
                    Duration = p.SubItems[DurColumnHeader.Index].Text,
                }).ToArray();
            }

            _sl.Save();
        }

        private async void ProcessPendingAddQueue()
        {
            var reader = _pendingAddToList.Reader;
            while (_isRunning)
            {
                var path = await reader.ReadAsync();
                var item = new ListViewItem();
                item.Name = path;
                item.Text = path;

                for (var i = 0; i < MainListView.Columns.Count - 1; i++)
                {
                    item.SubItems.Add("");
                }

                MainListView.Items.Add(item);
            }
        }

        private void AddDebugContent(int i)
        {
            var group = new ListViewGroup
            {
                Header = "Grrr" + i,
                Subtitle = "Srrr" + i,
                TitleImageIndex = 0
            };
            MainListView.Groups.Add(group);

            MainListView.Items.Add(new ListViewItem { Group = group, Text = "Brrr1", });
            MainListView.Items.Add(new ListViewItem { Group = group, Text = "Brrr2", });
            MainListView.Items.Add(new ListViewItem { Group = group, Text = "Brrr3", });
        }

        private void ShowSettingContextMenu(int? expandIndex = null)
        {
            var ctx = new ContextMenuStrip();
            ctx.Items.Add("(设置)").Enabled = false;
            ctx.Items.Add("-");

            var allSupportedDevices = OutputDeviceProvider.GetAllSupportedDevices();
            var selectedPcmDevice = allSupportedDevices.FirstOrDefault(p => p.Id == _sl?.State?.SelectedPcmOutputDeviceId);
            var selectedDsdDevice = allSupportedDevices.FirstOrDefault(p => p.Id == _sl?.State?.SelectedDsdAsioOutputDeviceId);

            var pcmOutputSelect = new ToolStripMenuItem($"PCM 输出{(selectedPcmDevice == null ? "(未选择)" : "")}");
            ctx.Items.Add(pcmOutputSelect);

            var dsdOutputSelect = new ToolStripMenuItem($"DSD 输出{(selectedPcmDevice == null ? "(未选择)" : "")}");
            ctx.Items.Add(dsdOutputSelect);

            var dsdToPcm = new ToolStripMenuItem("软解码成PCM");
            if (_sl?.State?.DecodeDsdToPcm == true) dsdToPcm.CheckState = CheckState.Indeterminate;
            dsdOutputSelect.DropDownItems.Add(dsdToPcm);
            dsdToPcm.Click += delegate
            {
                if (_sl?.State == null) return;
                _sl.State.DecodeDsdToPcm = true;
                _sl.State.SelectedDsdAsioOutputDeviceId = null;
                ShowSettingContextMenu();
            };

            foreach (var deviceInfo in allSupportedDevices)
            {
                var pcmDeviceItem = new ToolStripMenuItem(deviceInfo.DisplayName);
                pcmOutputSelect.DropDownItems.Add(pcmDeviceItem);

                if (selectedPcmDevice == deviceInfo) pcmDeviceItem.CheckState = CheckState.Indeterminate;
                pcmDeviceItem.Click += delegate
                {
                    if (_sl?.State == null) return;
                    _sl.State.SelectedPcmOutputDeviceId = deviceInfo.Id;
                    _sl.State.OutputDeviceLatency = null;
                    ShowSettingContextMenu();
                };

                if (deviceInfo.Type == OutputType.ASIO)
                {
                    var dsdDeviceItem = new ToolStripMenuItem(deviceInfo.DisplayName);
                    dsdOutputSelect.DropDownItems.Add(dsdDeviceItem);

                    if (selectedDsdDevice == deviceInfo) dsdDeviceItem.CheckState = CheckState.Indeterminate;

                    dsdDeviceItem.Click += delegate
                    {
                        if (_sl?.State == null) return;
                        _sl.State.SelectedDsdAsioOutputDeviceId = deviceInfo.Id;
                        _sl.State.DecodeDsdToPcm = false;
                        ShowSettingContextMenu();
                    };
                }
            }

            ctx.Items.Add("-");

            if (selectedPcmDevice == null)
            {
                ctx.Items.Add("(未选择 PCM 输出设备)").Enabled = false;
            }
            else
            {
                if (selectedPcmDevice.CanSetLatency)
                {
                    const int mulCount = 4;

                    var defaultLatency = selectedPcmDevice.Latency;
                    var selectedLatency = _sl?.State?.OutputDeviceLatency ?? defaultLatency;

                    var latencyMenu = new ToolStripMenuItem("缓冲大小:" + (_sl.State?.OutputDeviceLatency ?? defaultLatency));
                    ctx.Items.Add(latencyMenu);

                    void SetLatency(int latency)
                    {
                        if (_sl.State == null) return;
                        _sl.State.OutputDeviceLatency = latency;
                        ShowSettingContextMenu();
                        //ShowSettingContextMenu(ctx.Items.IndexOf(latencyMenu));
                    }

                    for (var i = 0; i < mulCount; i++)
                    {
                        var latency = defaultLatency * (i + 1);
                        var latencyItem = new ToolStripMenuItem(latency.ToString());
                        latencyMenu.DropDownItems.Add(latencyItem);
                        if (selectedLatency == latency) latencyItem.CheckState = CheckState.Indeterminate;
                        latencyItem.Click += delegate { SetLatency(latency); };
                    }
                }

                if (selectedPcmDevice.HasControlPanel)
                {
                    var toolStripItem = ctx.Items.Add("调出 PCM ASIO 设置面板");
                    if (_playbackState == UIPlaybackState.Playing)
                    {
                        toolStripItem.Enabled = false;
                        toolStripItem.Text += "(需要暂停播放)";
                    }
                    toolStripItem.Click += delegate
                    {
                        try
                        {
                            selectedPcmDevice.ShowControlPanel();
                        }
                        catch (Exception e)
                        {
                            //TODO: 消息机制 错误 调出ASIO设置面板
                            MessageBox.Show("无法调出 PCM ASIO 设置面板" + Environment.NewLine + e.Message, null, MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, 0, false);
                        }
                    };
                }

                if (selectedDsdDevice == null)
                {
                    ctx.Items.Add("(未选择 DSD 输出设备)").Enabled = false;
                }
                else if (selectedDsdDevice.HasControlPanel)
                {
                    var toolStripItem = ctx.Items.Add("调出 DSD ASIO 设置面板");
                    if (_playbackState == UIPlaybackState.Playing)
                    {
                        toolStripItem.Enabled = false;
                        toolStripItem.Text += "(需要暂停播放)";
                    }
                    toolStripItem.Click += delegate
                    {
                        try
                        {
                            selectedDsdDevice.ShowControlPanel();
                        }
                        catch (Exception e)
                        {
                            //TODO: 消息机制 错误 调出ASIO设置面板
                            MessageBox.Show("无法调出 DSD ASIO 设置面板" + Environment.NewLine + e.Message, null, MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, 0, false);
                        }
                    };
                }
            }

            ctx.Items.Add("-");
            ctx.Items.Add("立即保存状态").Click += delegate { SaveState(); };

            if (expandIndex.HasValue) ctx.Opened += delegate
            {
                if (ctx.Items[expandIndex.Value] is ToolStripMenuItem menuItem) menuItem.ShowDropDown();
            };
            ctx.Show(SettingButton, Point.Empty);
        }

        // -----------------  UI event: Form -----------------

        private void MainForm_Shown(object sender, EventArgs e)
        {
            if (_serviceProvider == null) throw new InvalidOperationException($"Must set {nameof(ServiceProvider)} before show!");

            _eventBus = _serviceProvider.GetRequiredService<IEventBus>();
            _sl = _serviceProvider.GetRequiredService<SaveLoadService>();
            _logger = _serviceProvider.GetRequiredService<ILogger<MainForm>>();

            //var lvi = new ListViewItem();

            //AlbumImageList.Images.Add(this.Icon);

            //AddContent(1);
            //AddContent(2);

            MainListView.Items.Clear();

            if (_sl != null)
            {
                if (_sl.State != null)
                {
                    if (_sl.State.FormPosition.HasValue) Location = _sl.State.FormPosition.Value;
                    Application.DoEvents();
                    if (_sl.State.FormSize.HasValue) Size = _sl.State.FormSize.Value;

                    if (_sl.State.Playlist != null)
                    {
                        foreach (var playlistItem in _sl.State.Playlist)
                        {
                            var item = new ListViewItem();
                            for (var i = 0; i < MainListView.Columns.Count - 1; i++) item.SubItems.Add("");

                            item.Name = playlistItem.Path;
                            item.SubItems[TitleColumnHeader.Index].Text = playlistItem.Title;
                            item.SubItems[DurColumnHeader.Index].Text = playlistItem.Duration;

                            MainListView.Items.Add(item);
                        }
                    }
                }
            }

            _isRunning = true;

            ProcessPendingAddQueue();
        }

        private void MainForm_FormClosed(object sender, FormClosedEventArgs e)
        {
            _isRunning = false;

            SaveState();
        }

        // -----------------  UI event: ListView -----------------

        private void MainListView_ColumnWidthChanging(object sender, ColumnWidthChangingEventArgs e)
        {
            if (MainListView.Columns[e.ColumnIndex] == StateColumnHeader)
            {
                e.Cancel = true;
                e.NewWidth = StateColumnHeader.Width;
            }

            if (MainListView.Columns[e.ColumnIndex] == DurColumnHeader)
            {
                e.Cancel = true;
                e.NewWidth = DurColumnHeader.Width;
            }
        }

        private async void MainListView_ItemActivate(object sender, EventArgs e)
        {
            if (MainListView.SelectedItems.Count > 0)
            {
                var item = MainListView.SelectedItems[0];

                await LoadItemAsync(item);
            }
        }

        private void MainListView_SizeChanged(object sender, EventArgs e)
        {
            TitleColumnHeader.Width = MainListView.Width - DurColumnHeader.Width - StateColumnHeader.Width - 50;
        }

        private void MainListView_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Delete)
            {
                var selectedItems = MainListView.SelectedItems.Cast<ListViewItem>().ToArray();

                foreach (var item in selectedItems) MainListView.Items.Remove(item);
            }
        }

        private void MainListView_ItemDrag(object sender, ItemDragEventArgs e)
        {
            var selectedItems = MainListView.SelectedItems.Cast<ListViewItem>().ToArray();
            if (selectedItems.Length > 0) MainListView.DoDragDrop(selectedItems, DragDropEffects.Move);
        }

        private void MainListView_DragEnter(object sender, DragEventArgs e)
        {
            e.Effect = e.Data?.GetData(typeof(ListViewItem[])) is ListViewItem[]? DragDropEffects.Move
                : e.Data?.GetFormats().Any(SupportedDropTypes.Contains) == true
                    ? DragDropEffects.Link
                    : DragDropEffects.None;
        }

        private void MainListView_DragOver(object sender, DragEventArgs e)
        {
            if (e.Data?.GetDataPresent(typeof(ListViewItem[])) == true)
            {
                var point = MainListView.PointToClient(new Point(e.X, e.Y));
                var targetIndex = MainListView.InsertionMark.NearestIndex(point);
                if (targetIndex == -1)
                {
                    MainListView.InsertionMark.Index = -1;
                }
                else if (targetIndex >= 0 && targetIndex < MainListView.Items.Count)
                {
                    MainListView.InsertionMark.Index = targetIndex;
                }
            }
        }

        private void MainListView_DragLeave(object sender, EventArgs e)
        {
            MainListView.InsertionMark.Index = -1;
        }

        private void MainListView_DragDrop(object sender, DragEventArgs e)
        {
            MainListView.InsertionMark.Index = -1;

            if (e.Data?.GetDataPresent(typeof(ListViewItem[])) == true)
            {
                var items = e.Data.GetData(typeof(ListViewItem[])) as ListViewItem[];

                var point = MainListView.PointToClient(new Point(e.X, e.Y));

                var targetIndex = MainListView.InsertionMark.NearestIndex(point);
                //BUG: move down
                if (targetIndex >= 0 && targetIndex < MainListView.Items.Count)
                {
                    foreach (var item in items!)
                    {
                        MainListView.Items.Remove(item);
                    }
                    targetIndex = Math.Min(targetIndex, MainListView.Items.Count);

                    for (int i = 0; i < items.Length; i++)
                    {
                        MainListView.Items.Insert(targetIndex + i, items[i]);
                    }
                }
                return;
            }

            var listAllPath = new List<string>();

            if (e.Data?.GetDataPresent(DataFormats.FileDrop) == true)
            {
                var arrFilePath = (string[]?)e.Data.GetData(DataFormats.FileDrop);
                if (arrFilePath == null) return;

                foreach (var s in arrFilePath)
                {
                    if (Directory.Exists(s))
                    {
                        listAllPath.AddRange(Directory.GetFiles(s, "*", SearchOption.AllDirectories));
                    }
                    else
                    {
                        listAllPath.Add(s);
                    }
                }
            }

            if (e.Data?.GetDataPresent(DataFormats.Text) == true)
            {
                var text = (string?)e.Data.GetData(DataFormats.Text);
                if (text == null) return;

                listAllPath.Add(text);
            }

            var writer = _pendingAddToList.Writer;

            foreach (var path in listAllPath)
            {
                writer.WriteAsync(path);
            }
        }

        private void MainContextMenu_Opening(object sender, System.ComponentModel.CancelEventArgs e)
        {
            MainContextMenu.Items.Clear();
            var moveTop = new ToolStripMenuItem("置顶");
            var moveUp = new ToolStripMenuItem("上移");
            var moveDown = new ToolStripMenuItem("下移");
            var moveBottom = new ToolStripMenuItem("置底");
            var clearSelected = new ToolStripMenuItem("清空选中");
            var clearAll = new ToolStripMenuItem("清空全部");

            MainContextMenu.Items.Add(moveTop);
            MainContextMenu.Items.Add(moveUp);
            MainContextMenu.Items.Add(moveDown);
            MainContextMenu.Items.Add(moveBottom);
            MainContextMenu.Items.Add("-");
            MainContextMenu.Items.Add(clearSelected);
            MainContextMenu.Items.Add(clearAll);

            var isAnyContain = MainListView.Items.Count != 0;
            var isAnySelected = MainListView.SelectedItems.Count != 0;

            var isMultiSelected = MainListView.SelectedItems.Count > 1;
            var isAllSelected = MainListView.SelectedItems.Count == MainListView.Items.Count;
            var isTopSelected = MainListView.SelectedIndices.Contains(0);
            var isBottomSelected = MainListView.SelectedIndices.Contains(MainListView.Items.Count - 1);

            moveTop.Enabled = isAnySelected && !isAllSelected && !isTopSelected;
            moveUp.Enabled = isAnySelected && !isAllSelected && !isTopSelected;
            moveDown.Enabled = isAnySelected && !isAllSelected && !isBottomSelected;
            moveBottom.Enabled = isAnySelected && !isAllSelected && !isBottomSelected;
            clearAll.Enabled = isAnyContain;
            clearSelected.Enabled = isAnySelected;

            moveTop.Click += delegate
            {
                var selectedItems = MainListView.SelectedItems.Cast<ListViewItem>().ToArray();
                var targetIndex = 0;
                foreach (var item in selectedItems) MainListView.Items.Remove(item);
                for (int i = 0; i < selectedItems.Length; i++) MainListView.Items.Insert(targetIndex + i, selectedItems[i]);
            };

            moveUp.Click += delegate
            {
                var selectedItems = MainListView.SelectedItems.Cast<ListViewItem>().ToArray();
                var targetIndex = selectedItems[0].Index - 1;
                foreach (var item in selectedItems) MainListView.Items.Remove(item);
                for (int i = 0; i < selectedItems.Length; i++) MainListView.Items.Insert(targetIndex + i, selectedItems[i]);
            };

            moveDown.Click += delegate
            {
                var selectedItems = MainListView.SelectedItems.Cast<ListViewItem>().ToArray();
                ListViewItem nextItem = null;
                for (int i = selectedItems[0].Index; i < MainListView.Items.Count; i++)
                {
                    if (MainListView.Items[i].Selected == false)
                    {
                        nextItem = MainListView.Items[i];
                        break;
                    }
                }

                if (nextItem == null) return;

                foreach (var item in selectedItems) MainListView.Items.Remove(item);

                var targetIndex = nextItem.Index + 1;

                if (targetIndex > MainListView.Items.Count) targetIndex = MainListView.Items.Count;
                for (int i = 0; i < selectedItems.Length; i++) MainListView.Items.Insert(targetIndex + i, selectedItems[i]);
            };

            moveBottom.Click += delegate
            {
                var selectedItems = MainListView.SelectedItems.Cast<ListViewItem>().ToArray();
                foreach (var item in selectedItems) MainListView.Items.Remove(item);
                var targetIndex = MainListView.Items.Count;
                for (int i = 0; i < selectedItems.Length; i++) MainListView.Items.Insert(targetIndex + i, selectedItems[i]);
            };

            clearSelected.Click += delegate
            {
                foreach (ListViewItem selectedItem in MainListView.SelectedItems.Cast<ListViewItem>().ToArray()) MainListView.Items.Remove(selectedItem);
            };

            clearAll.Click += delegate
            {
                MainListView.Items.Clear();
            };
        }

        // -----------------  UI event: Buttons -----------------

        private void SettingButton_Click(object sender, EventArgs e) => ShowSettingContextMenu();

        private void StopButton_Click(object sender, EventArgs e) => StopAsync();

        private async void PlayButton_Click(object sender, EventArgs e)
        {
            if (_playbackState == UIPlaybackState.Paused)
            {
                await PlayAsync();
                return;
            }

            var selectedItem = MainListView.SelectedItems.Cast<ListViewItem>().FirstOrDefault();
            if (selectedItem != null) await LoadItemAsync(selectedItem);
        }

        private async void PauseButton_Click(object sender, EventArgs e) => await PauseAsync();

        private void PrevButton_Click(object sender, EventArgs e) => TrackPrev();

        private void NextButton_Click(object sender, EventArgs e) => TrackNext();

        // -----------------  UI event: Others -----------------

        private void UpdateTimer_Tick(object sender, EventArgs e)
        {
            var sb = new StringBuilder();

            //播放状态
            sb.Append(_playbackState.AsString(EnumFormat.Description));

            //进度

            var dur = _inputSource?.TotalTime;
            var cur = _inputSource?.CurrentTime;

            if (dur.HasValue && cur.HasValue)
            {
                sb.Append(" | ");
                var tsDur = dur.Value;
                var tsCur = cur.Value;
                sb.Append($"{tsCur:hh\\:mm\\:ss}.{tsCur.Milliseconds / 100:0}/{tsDur:hh\\:mm\\:ss}.{tsDur.Milliseconds / 100:0}");

                var durMs = (int)tsDur.TotalMilliseconds;
                var curMs = (int)cur.Value.TotalMilliseconds;

                if (_trackBarHolding == false)
                {
                    SeekTrackBar.Maximum = durMs;
                    if (curMs > durMs) curMs = durMs;
                    SeekTrackBar.Value = curMs;
                }
            }

            if (_inputSource != null)
            {
                sb.Append(" | ");

                if (_nativeDsd) sb.Append("DSD ");

                var format = _inputSource.WaveFormat;
                var rawBit = _inputSource is IHaveBitPerRawSample bpr ? bpr.BitPerRawSample : null;
                var decBit = format.BitsPerSample;

                if (format.Encoding == WaveFormatEncoding.IeeeFloat)
                {
                    sb.Append("IeeeFloat ");
                }

                if (format.Encoding == WaveFormatEncoding.Pcm)
                {
                    sb.Append("PCM ");
                }

                if (rawBit.HasValue && rawBit != 0 && rawBit != decBit)
                {
                    sb.Append($"{decBit}({rawBit})bit");
                }
                else
                {
                    sb.Append($"{decBit}bit");
                }

                var unit = "K";
                var sampleRate = format.SampleRate;
                if (sampleRate > 1000000)
                {
                    sampleRate /= 1000;
                    unit = "M";
                }

                sb.Append(sampleRate % 1000 == 0
                    ? $"/{sampleRate / 1000.0:N0}{unit}Hz"
                    : $"/{sampleRate / 1000.0:N1}{unit}Hz");
            }

            if (_selectedOutputDevice != null && _playbackState == UIPlaybackState.Playing)
            {
                sb.Append(" | ");
                if (_outputDevice is AsioOut asioOut)
                {
                    try
                    {
                        var type = asioOut.Driver.Capabilities.OutputChannelInfos.First().type;
                        sb.Append($"{type} ");
                    }
                    catch (Exception exception)
                    {
                        //TODO: 异常处理
                        Console.WriteLine(exception);
                    }
                }
                sb.Append($"{_selectedOutputDevice.DisplayName}");
            }

            StatusBarLabel.Text = sb.ToString();
        }

        private void SeekTrackBar_MouseDown(object sender, MouseEventArgs e)
        {
            _trackBarHolding = true;
        }

        private async void SeekTrackBar_MouseUp(object sender, MouseEventArgs e)
        {
            if (_inputSource != null)
            {
                await PauseAsync();

                _playbackState = UIPlaybackState.Seeking;

                var ms = SeekTrackBar.Value;
                var seekTo = TimeSpan.FromMilliseconds(ms);

                await Task.Run(() => _inputSource.CurrentTime = seekTo);

                var bytesOf50Ms = (int)((double)_inputSource.WaveFormat.BitsPerSample / 8 * _inputSource.WaveFormat.Channels * _inputSource.WaveFormat.SampleRate / 20);

                var mod = bytesOf50Ms % _inputSource.BlockAlign;
                if (mod != 0) bytesOf50Ms -= mod;
                if (bytesOf50Ms == 0) bytesOf50Ms = _inputSource.BlockAlign;

                var buf = new byte[bytesOf50Ms];

                do
                {
                    var count = await _inputSource.ReadAsync(buf, 0, bytesOf50Ms);
                    if (count == 0) break;
                } while (_inputSource.CurrentTime < seekTo);

                await PlayAsync();
            }

            _trackBarHolding = false;
        }
    }

    internal enum UIPlaybackState
    {
        [Description("就绪")]
        Ready,

        [Description("正在加载")]
        Loading,

        [Description("正在播放")]
        Playing,

        [Description("正在跳转")]
        Seeking,

        [Description("暂停")]
        Paused,

        [Description("停止")]
        Stopped,

        [Description("错误")]
        Error,
    }
}