Newer
Older
Qwilight / Qwilight / ViewModel / MainViewModel.cs
using CommunityToolkit.Mvvm.Input;
using CommunityToolkit.Mvvm.Messaging;
using Ionic.Zip;
using Qwilight.Compute;
using Qwilight.MSG;
using Qwilight.NoteFile;
using Qwilight.System16;
using Qwilight.System16.MSG;
using Qwilight.UIComponent;
using Qwilight.Utilities;
using SharpCompress.Archives;
using SharpCompress.Archives.Rar;
using SharpCompress.Archives.SevenZip;
using System.Buffers;
using System.Collections.Concurrent;
using System.Collections.Immutable;
using System.Collections.ObjectModel;
using System.Data;
using System.Data.SQLite;
using System.Diagnostics;
using System.IO;
using System.Net.Http;
using System.Text;
using System.Windows;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Threading;
using System.Xml.Serialization;
using UtfUnknown;
using Windows.ApplicationModel.DataTransfer;
using Windows.System;
using Windows.Win32.UI.WindowsAndMessaging;
using Clipboard = Windows.ApplicationModel.DataTransfer.Clipboard;

namespace Qwilight.ViewModel
{
    public sealed partial class MainViewModel : Model
    {
        public enum Mode
        {
            NoteFile, Computing = 2, Quit
        }

        public sealed class Fading
        {
            public double Status { get; set; }

            public int Layer { get; set; }

            public DefaultCompute Computer { get; set; }

            public bool IsComputerStable { get; set; }
        }

        readonly PausableAudioHandler _pausableAudioHandler = new();
        readonly ConcurrentDictionary<int, EntryItem> _entryItems = new();
        readonly HashSet<DefaultEntryItem> _alreadyLoadedDefaultEntryItems = new();
        readonly DispatcherTimer _loadDefaultCommentHandler = new(DispatcherPriority.Input, UIHandler.Instance.Handler)
        {
            Interval = TimeSpan.FromMilliseconds(QwilightComponent.StandardUILoopMillis)
        };
        readonly DispatcherTimer _loadTwilightCommentHandler = new(DispatcherPriority.Input, UIHandler.Instance.Handler)
        {
            Interval = TimeSpan.FromMilliseconds(QwilightComponent.StandardUILoopMillis)
        };
        readonly DispatcherTimer _autoComputerHandler = new(DispatcherPriority.Input, UIHandler.Instance.Handler)
        {
            Interval = TimeSpan.FromMilliseconds(QwilightComponent.StandardWaitMillis)
        };
        readonly DispatcherTimer _wantHandler = new(DispatcherPriority.Input, UIHandler.Instance.Handler)
        {
            Interval = TimeSpan.FromMilliseconds(QwilightComponent.StandardWaitMillis)
        };
        readonly ModeComponent _defaultModeComponentValue = new();
        readonly FileSystemWatcher _fsw = new(QwilightComponent.EdgeEntryPath)
        {
            EnableRaisingEvents = true
        };
        int _randomMillis = Environment.TickCount;
        DispatcherTimer _fadeInHandler;
        bool _isAvailable = true;
        string _twilightCommentText0 = string.Empty;
        string _twilightCommentText1 = string.Empty;
        string _qwilightFileName;
        Mode _mode;
        int _lastEntryItemID;
        bool _isCommentMode;
        CommentItem _defaultCommentItem;
        CommentItem _twilightCommentItem;
        int _entryItemPosition;
        EntryItem _entryItemValue;
        CancellationTokenSource _setCancelDefaultEntryLoading;
        int? _lastLowerMillis;
        bool _wasLowerMillis = true;
        bool _isUILoading;
        bool _isInputWantPointed;
        bool _isTwilightCommentaryPointed;
        bool _isDefaultCommentLoading;
        bool _isTwilightCommentLoading;
        bool? _twilightCommentFavor;
        string _twilightCommentTotalFavor;
        bool _isHOFTotalTotalLoading;
        bool _isHOFAtTotalLoading;
        bool _isHOFTotalHighestLoading;
        bool _isHOFAtHighestLoading;
        bool _isHOFTotalStandLoading;
        bool _isHOFAtStandLoading;
        bool _isHOFTotalBandLoading;
        bool _isHOFAtBandLoading;
        bool _isHOFAbility5KLoading;
        bool _isHOFAbility7KLoading;
        bool _isHOFAbility9KLoading;
        bool _isHOFLevelLoading;
        string _twilightCommentary = string.Empty;
        bool _isLazyGCMode;
        bool _isWPFViewVisible = true;
        bool _isLoaded;
        double _windowDPI;

        static bool IsNotModal(BaseViewModel targetViewModel = null)
        {
            foreach (var windowViewModel in ViewModels.Instance.WindowViewModels)
            {
                if (windowViewModel == targetViewModel)
                {
                    continue;
                }
                if (windowViewModel.IsOpened && windowViewModel.IsModal)
                {
                    return false;
                }
            }
            return true;
        }

        public List<DefaultEntryItem> DefaultEntryItems { get; } = new()
        {
            DefaultEntryItem.Total
        };

        public string PausableAudioFileName => _pausableAudioHandler.AudioFileName;

        public bool IsBPMVisible => EntryItemValue?.NoteFile?.HasBPMMap != true;

        public bool IsBPM1Visible => EntryItemValue?.NoteFile?.HasBPMMap == true;

        bool HasNotInput(BaseViewModel targetViewModel = null) => IsNotModal(targetViewModel) && IsAvailable && (!IsWPFViewVisible || !_isInputWantPointed && !_isTwilightCommentaryPointed && !ViewModels.Instance.SiteContainerValue.IsInputPointed);

        public double WindowDPI
        {
            get => _windowDPI;

            set => SetProperty(ref _windowDPI, value, nameof(WindowDPI));
        }

        public ConcurrentDictionary<string, EntryItem> EventNoteEntryItems { get; } = new();

        public ConcurrentDictionary<string, BaseNoteFile> NoteID512s { get; } = new();

        public ConcurrentDictionary<string, BaseNoteFile> NoteID128s { get; } = new();

        public int NoteDrawingCount => _entryItems.Values.Sum(entryItem => entryItem.NoteFiles.Count(noteFile => noteFile.HasNoteDrawing));

        public ObservableCollection<CommentItem> DefaultCommentItemCollection { get; } = new();

        public ObservableCollection<CommentItem> TwilightCommentItemCollection { get; } = new();

        public double Status { get; set; }

        public ObservableCollection<EntryItem> EntryItems { get; set; } = new();

        public ObservableCollection<HOFItem> TotalTotalHOFItemCollection { get; } = new();

        public ObservableCollection<HOFItem> TotalHighestHOFItemCollection { get; } = new();

        public ObservableCollection<HOFItem> TotalStandHOFItemCollection { get; } = new();

        public ObservableCollection<HOFItem> TotalBandHOFItemCollection { get; } = new();

        public ObservableCollection<HOFItem> AtTotalHOFItemCollection { get; } = new();

        public ObservableCollection<HOFItem> AtHighestHOFItemCollection { get; } = new();

        public ObservableCollection<HOFItem> AtStandHOFItemCollection { get; } = new();

        public ObservableCollection<HOFItem> AtBandHOFItemCollection { get; } = new();

        public ObservableCollection<HOFItem> Ability5KHOFItemCollection { get; } = new();

        public ObservableCollection<HOFItem> Ability7KHOFItemCollection { get; } = new();

        public ObservableCollection<HOFItem> Ability9KHOFItemCollection { get; } = new();

        public ObservableCollection<HOFItem> LevelHOFItemCollection { get; } = new();

        public Dictionary<string, EntryItem> LastEntryItems { get; } = new();

        public DefaultCompute Computer { get; set; }

        public AutoCompute AutoComputer { get; set; }

        public DefaultCompute FadingViewComputer
        {
            get
            {
                var fadingViewComputer = FadingValue.Computer;
                if (FadingValue.IsComputerStable)
                {
                    return fadingViewComputer;
                }
                else
                {
                    if (fadingViewComputer.NoteFile == AutoComputer?.NoteFile)
                    {
                        return AutoComputer;
                    }
                    else
                    {
                        return fadingViewComputer;
                    }
                }
            }
        }

        public ModeComponent ModeComponentValue { get; } = Configure.Instance.ModeComponentValue;

        public bool IsWPFViewVisible
        {
            get => _isWPFViewVisible;

            set
            {
                if (SetProperty(ref _isWPFViewVisible, value, nameof(IsWPFViewVisible)))
                {
                    if (!value)
                    {
                        DrawingSystem.Instance.OnModified();
                    }
                    PoolSystem.Instance.Wipe(value);
                    StrongReferenceMessenger.Default.Send(new SetD2DViewVisibility
                    {
                        IsVisible = !value
                    });
                    IsLazyGCMode = IsComputingMode && !value;
                    ViewModels.Instance.NotifyWindowViewModels();
                    TVSystem.Instance.HandleSystemIfAvailable();
                }
            }
        }

        public bool IsLazyGCMode
        {
            get => _isLazyGCMode;

            set
            {
                _isLazyGCMode = value;
                if (value)
                {
                    var lazyGC = Configure.Instance.LazyGCV2 * 1000L * 1000L;
                    try
                    {
                        var eagerRAM = 0.1 * QwilightComponent.RAM - (1000L * (long)Utility.GetWMI("SELECT FreePhysicalMemory FROM Win32_OperatingSystem").Select(o => (ulong)o["FreePhysicalMemory"]).Single() - lazyGC);
                        if (eagerRAM > 0.0)
                        {
                            NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.Warning, NotifySystem.NotifyConfigure.Default, string.Format(LanguageSystem.Instance.RAMWarning, Utility.FormatLength((long)eagerRAM)));
                        }
                    }
                    catch
                    {
                    }
                    if (lazyGC > 0L)
                    {
                        try
                        {
                            GC.TryStartNoGCRegion(lazyGC);
                        }
                        catch (InvalidOperationException)
                        {
                        }
                    }
                }
                else
                {
                    try
                    {
                        GC.EndNoGCRegion();
                    }
                    catch (InvalidOperationException)
                    {
                    }
                }
            }
        }

        public bool HasPoint { get; set; }

        public string TwilightCommentary
        {
            get => _twilightCommentary;

            set => SetProperty(ref _twilightCommentary, value, nameof(TwilightCommentary));
        }

        public Computing GetHandlingComputing() => IsNoteFileMode ? EntryItemValue?.NoteFile : GetHandlingComputer();

        public DefaultCompute GetHandlingComputer() => ModeValue switch
        {
            Mode.NoteFile => AutoComputer,
            Mode.Computing => Computer,
            Mode.Quit => AutoComputer?.IsHandling == true ? AutoComputer : Computer,
            _ => default
        };

        public bool IsPausing => AutoComputer?.IsPausing ?? _pausableAudioHandler.IsPausing;

        public string TwilightCommentText0
        {
            get => _twilightCommentText0;

            set => SetProperty(ref _twilightCommentText0, value, nameof(TwilightCommentText0));
        }

        public string TwilightCommentText1
        {
            get => _twilightCommentText1;

            set => SetProperty(ref _twilightCommentText1, value, nameof(TwilightCommentText1));
        }

        public bool IsDefaultCommentLoading
        {
            get => _isDefaultCommentLoading;

            set => SetProperty(ref _isDefaultCommentLoading, value, nameof(IsDefaultCommentLoading));
        }

        public bool IsTwilightCommentLoading
        {
            get => _isTwilightCommentLoading;

            set
            {
                if (SetProperty(ref _isTwilightCommentLoading, value, nameof(IsTwilightCommentLoading)))
                {
                    OnPropertyChanged(nameof(IsEntryItemBanned));
                }
            }
        }

        public bool? TwilightCommentFavor
        {
            get => _twilightCommentFavor;

            set
            {
                if (SetProperty(ref _twilightCommentFavor, value))
                {
                    OnPropertyChanged(nameof(LowerTwilightCommentFavorPaint));
                    OnPropertyChanged(nameof(HigherTwilightCommentFavorPaint));
                    NotifyCanTwilightFavor();
                }
            }
        }

        public bool CanLowerTwilightCommentFavor => IsNoteFileNotLogical && !IsEntryItemBanned && TwilightSystem.Instance.IsSignedIn && TwilightCommentFavor != true;

        public Brush LowerTwilightCommentFavorPaint => TwilightCommentFavor == false ? Paints.Paint1 : Paints.Paint4;

        public bool CanHigherTwilightCommentFavor => IsNoteFileNotLogical && !IsEntryItemBanned && TwilightSystem.Instance.IsSignedIn && TwilightCommentFavor != false;

        public Brush HigherTwilightCommentFavorPaint => TwilightCommentFavor == true ? Paints.Paint3 : Paints.Paint4;

        public string TwilightCommentTotalFavor
        {
            get => _twilightCommentTotalFavor;

            set => SetProperty(ref _twilightCommentTotalFavor, value, nameof(TwilightCommentTotalFavor));
        }

        public bool IsHOFTotalTotalLoading
        {
            get => _isHOFTotalTotalLoading;

            set => SetProperty(ref _isHOFTotalTotalLoading, value, nameof(IsHOFTotalTotalLoading));
        }

        public bool IsHOFTotalHighestLoading
        {
            get => _isHOFTotalHighestLoading;

            set => SetProperty(ref _isHOFTotalHighestLoading, value, nameof(IsHOFTotalHighestLoading));
        }

        public bool IsHOFTotalStandLoading
        {
            get => _isHOFTotalStandLoading;

            set => SetProperty(ref _isHOFTotalStandLoading, value, nameof(IsHOFTotalStandLoading));
        }

        public bool IsHOFTotalBandLoading
        {
            get => _isHOFTotalBandLoading;

            set => SetProperty(ref _isHOFTotalBandLoading, value, nameof(IsHOFTotalBandLoading));
        }

        public bool IsHOFAtTotalLoading
        {
            get => _isHOFAtTotalLoading;

            set => SetProperty(ref _isHOFAtTotalLoading, value, nameof(IsHOFAtTotalLoading));
        }

        public bool IsHOFAtHighestLoading
        {
            get => _isHOFAtHighestLoading;

            set => SetProperty(ref _isHOFAtHighestLoading, value, nameof(IsHOFAtHighestLoading));
        }

        public bool IsHOFAtStandLoading
        {
            get => _isHOFAtStandLoading;

            set => SetProperty(ref _isHOFAtStandLoading, value, nameof(IsHOFAtStandLoading));
        }

        public bool IsHOFAtBandLoading
        {
            get => _isHOFAtBandLoading;

            set => SetProperty(ref _isHOFAtBandLoading, value, nameof(IsHOFAtBandLoading));
        }

        public bool IsHOFAbility5KLoading
        {
            get => _isHOFAbility5KLoading;

            set => SetProperty(ref _isHOFAbility5KLoading, value, nameof(IsHOFAbility5KLoading));
        }

        public bool IsHOFAbility7KLoading
        {
            get => _isHOFAbility7KLoading;

            set => SetProperty(ref _isHOFAbility7KLoading, value, nameof(IsHOFAbility7KLoading));
        }

        public bool IsHOFAbility9KLoading
        {
            get => _isHOFAbility9KLoading;

            set => SetProperty(ref _isHOFAbility9KLoading, value, nameof(IsHOFAbility9KLoading));
        }

        public bool IsHOFLevelLoading
        {
            get => _isHOFLevelLoading;

            set => SetProperty(ref _isHOFLevelLoading, value, nameof(IsHOFLevelLoading));
        }

        public void NotifyIsPausing() => OnPropertyChanged(nameof(IsPausing));

        public Fading FadingValue { get; } = new();

        public bool IsAvailable
        {
            get => _isAvailable;

            set
            {
                if (SetProperty(ref _isAvailable, value, nameof(IsAvailable)) && value)
                {
                    PointEntryView();
                }
            }
        }

        public bool IsDefaultEntryLoading { get; set; }

        public bool IsUILoading
        {
            get => _isUILoading;

            set
            {
                if (SetProperty(ref _isUILoading, value, nameof(IsUILoading)) && !value)
                {
                    PointEntryView();
                }
            }
        }

        public string HighestInputCountText => Utility.GetHighestInputCountText(EntryItemValue?.NoteFile?.AverageInputCount ?? default, EntryItemValue?.NoteFile?.HighestInputCount ?? default, ModeComponentValue.AudioMultiplier);

        public string BPMText => Utility.GetBPMText(EntryItemValue?.NoteFile?.BPM ?? Component.StandardBPM, ModeComponentValue.Multiplier, ModeComponentValue.AudioMultiplier);

        public string LengthText => Utility.GetLengthText(EntryItemValue?.NoteFile?.Length ?? default);

        public bool IsEntryItemEventNote => !string.IsNullOrEmpty(EntryItemValue?.EventNoteID);

        public bool IsNoteFileNotLogical => EntryItemValue?.NoteFile?.IsLogical == false;

        public bool IsNoteFileAvailable => !string.IsNullOrEmpty(EntryItemValue?.NoteFile?.NoteFilePath);

        public bool CanSaveAsBundle => (IsEntryItemEventNote || IsNoteFileNotLogical) && TwilightSystem.Instance.IsSignedIn;

        public bool HasAssistFile => !string.IsNullOrEmpty(EntryItemValue?.NoteFile?.AssistFileName);

        public bool CanModifyModeComponent => IsNoteFileMode && !IsCommentMode;

        public void NotifyCanSaveAsBundle() => OnPropertyChanged(nameof(CanSaveAsBundle));

        public bool IsEntryItemBanned => EntryItemValue?.IsBanned != false;

        public bool CanTwilightCommentary => IsNoteFileNotLogical && !IsEntryItemBanned && TwilightSystem.Instance.IsSignedIn;

        public void NotifyCanTwilightCommentary() => OnPropertyChanged(nameof(CanTwilightCommentary));

        public void NotifyCanTwilightFavor()
        {
            OnPropertyChanged(nameof(CanLowerTwilightCommentFavor));
            OnPropertyChanged(nameof(CanHigherTwilightCommentFavor));
        }

        public double DefaultLength => IsComputingMode ? UI.Instance.DefaultLength : BaseUI.Instance.DefaultLength;

        public double DefaultHeight => IsComputingMode ? UI.Instance.DefaultHeight : BaseUI.Instance.DefaultHeight;

        public bool IsNoteFileMode => ModeValue == Mode.NoteFile;

        public bool IsComputingMode => ModeValue == Mode.Computing;

        public bool IsQuitMode => ModeValue == Mode.Quit;

        public Mode ModeValue
        {
            get => _mode;

            set
            {
                if (SetProperty(ref _mode, value))
                {
                    OnPropertyChanged(nameof(IsNoteFileMode));
                    OnPropertyChanged(nameof(IsComputingMode));
                    OnPropertyChanged(nameof(IsQuitMode));
                    OnPropertyChanged(nameof(CanModifyModeComponent));
                    OnPropertyChanged(nameof(DefaultLength));
                    OnPropertyChanged(nameof(DefaultHeight));
                    SetWPFViewVisibility();
                    MediaSystem.Instance.Stop(BaseUI.Instance);
                    BaseUI.Instance.HandlePaintProperties();
                    MediaSystem.Instance.HandleDefaultIfAvailable(BaseUI.Instance);
                    MediaSystem.Instance.HandleIfAvailable(BaseUI.Instance);
                    var handlingComputer = GetHandlingComputer();
                    if (handlingComputer != null)
                    {
                        MediaSystem.Instance.HandleDefaultIfAvailable(handlingComputer);
                        MediaSystem.Instance.HandleIfAvailable(handlingComputer);
                    }
                    ViewModels.Instance.NotifyWindowViewModels();
                    BaseUI.Instance.InitEvents();
                    Configure.Instance.UIConfigureValue.NotifyInputMode();
                    if (IsNoteFileMode)
                    {
                        ViewModels.Instance.HandleSilentlyClosableViewModels(silentlyClosableViewModel => silentlyClosableViewModel.OpenSilently());
                        NotifySystem.Instance.NotifyPending();
                        _randomMillis = Environment.TickCount;
                    }
                    else
                    {
                        ViewModels.Instance.HandleSilentlyClosableViewModels(silentlyClosableViewModel => silentlyClosableViewModel.CloseSilently());
                    }
                }
            }
        }

        public CommentItem DefaultCommentItem
        {
            get => _defaultCommentItem;

            set => SetProperty(ref _defaultCommentItem, value, nameof(DefaultCommentItem));
        }

        public CommentItem TwilightCommentItem
        {
            get => _twilightCommentItem;

            set => SetProperty(ref _twilightCommentItem, value, nameof(TwilightCommentItem));
        }

        public int EntryItemPosition
        {
            get => _entryItemPosition;

            set
            {
                if (SetProperty(ref _entryItemPosition, value, nameof(EntryItemPosition)) && _isLoaded && value != -1)
                {
                    Configure.Instance.LastEntryItemPositions[Configure.Instance.LastDefaultEntryItem?.DefaultEntryPath ?? string.Empty] = value;
                }
            }
        }

        public EntryItem EntryItemValue
        {
            get => _entryItemValue;

            set
            {
                if (SetProperty(ref _entryItemValue, value, nameof(EntryItemValue)))
                {
                    OnPropertyChanged(nameof(IsEntryItemEventNote));
                    if (value != null)
                    {
                        if (ViewModels.Instance.NoteFileValue.IsOpened)
                        {
                            ViewModels.Instance.NoteFileValue.EntryItemValue = value;
                        }
                        MoveEntryView();
                        if (_isLoaded)
                        {
                            LastEntryItems[Configure.Instance.LastDefaultEntryItem?.DefaultEntryPath ?? string.Empty] = value;
                        }
                    }
                    NotifyNoteFile();
                }
            }
        }

        public bool IsCommentMode
        {
            get => _isCommentMode;

            set
            {
                if (SetProperty(ref _isCommentMode, value, nameof(IsCommentMode)))
                {
                    OnPropertyChanged(nameof(CanModifyModeComponent));
                    if (value)
                    {
                        _defaultModeComponentValue.CopyAs(ModeComponentValue, null, false);
                    }
                    else
                    {
                        ModeComponentValue.CopyAs(_defaultModeComponentValue, null, false);
                    }
                }
            }
        }

        public async Task OnLoaded(nint handle)
        {
            StrongReferenceMessenger.Default.Send(new SetWindowedMode());

            StillSystem.Instance.Init(handle);
            await MIDISystem.Instance.HandleSystem().ConfigureAwait(false);

            AudioSystem.Instance.LoadDefaultAudioItems();
            AudioSystem.Instance.LoadBanalAudio();
            DrawingSystem.Instance.LoadDefaultDrawing();
            DrawingSystem.Instance.LoadVeilDrawing();

            await LevelSystem.Instance.LoadJSON(false).ConfigureAwait(false);
            await ValveSystem.Instance.Init().ConfigureAwait(false);
            await Task.Run(() =>
            {
                BaseUI.Instance.LoadUI(null, Configure.Instance.BaseUIItemValue, false);
                UI.Instance.LoadUI(null, Configure.Instance.UIItemValue, false);
            }).ConfigureAwait(false);

            _isLoaded = true;

            Utility.HandleParallelly(TVSystem.Instance.HandleSystem, false);
            Utility.HandleParallelly(IlluminationSystem.Instance.HandleSystem, false);
            DefaultControllerSystem.Instance.HandleSystem();
            Utility.HandleParallelly(DrawingSystem.Instance.HandleSystem);
            Utility.HandleParallelly(TwilightSystem.Instance.HandleSystem, false);
            Utility.HandleParallelly(PlatformSystem.Instance.HandleSystem, false);
            Utility.HandleParallelly(FlintSystem.Instance.HandleSystem, false);
            Utility.HandleParallelly(() => ControllerSystem.Instance.HandleSystem(handle));

            if (Configure.Instance.AudioMultiplierAtone)
            {
                AudioSystem.Instance.SetAudioMultiplierAtone(true, ModeComponentValue.AudioMultiplier);
            }

            StrongReferenceMessenger.Default.Send<FadeLoadingView>();

            if (!string.IsNullOrEmpty(Configure.Instance.ConfigureFault))
            {
                NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.Fault, NotifySystem.NotifyConfigure.Default, Configure.Instance.ConfigureFault);
            }
            if (!string.IsNullOrEmpty(GPUConfigure.Instance.GPUConfigureFault))
            {
                NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.Fault, NotifySystem.NotifyConfigure.Default, GPUConfigure.Instance.GPUConfigureFault);
            }
            if (!string.IsNullOrEmpty(DB.Instance.DBFault))
            {
                NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.Fault, NotifySystem.NotifyConfigure.Default, DB.Instance.DBFault);
            }

            if (!Configure.Instance.IsLoaded)
            {
                ViewModels.Instance.AssistValue.Open();
                Configure.Instance.IsLoaded = true;
            }

            SetDefaultEntryItems();

            if (Configure.Instance.AutoGetQwilight)
            {
                _ = GetQwilight(true);
            }
        }

        public void OnFileAs(DragEventArgs e)
        {
            var filePaths = e.Data.GetData(DataFormats.FileDrop) as string[];
            if (filePaths != null)
            {
                Task.Run(() =>
                {
                    var lastEventNoteID = string.Empty;
                    var lastYamlFileName = string.Empty;
                    DefaultEntryItem lastDefaultEntryItem = null;
                    foreach (var filePath in filePaths)
                    {
                        if (File.Exists(filePath))
                        {
                            if (QwilightComponent.NoteFileFormats.Any(format => filePath.IsTailCaselsss(format)))
                            {
                                FlintNoteFile(filePath, -1, 0);
                            }
                            else if (filePath.IsTailCaselsss(".zip"))
                            {
                                using var zipFile = ZipFile.Read(filePath);
                                var yamlFileName = Path.GetFileNameWithoutExtension(zipFile.Where(zipEntry => zipEntry.FileName.IsTailCaselsss(".yaml")).OrderBy(zipEntry => zipEntry.FileName).FirstOrDefault()?.FileName);
                                if (string.IsNullOrEmpty(yamlFileName))
                                {
                                    HandleNoteBundle(filePath);
                                }
                                else
                                {
                                    var savingUIItem = new NotifyItem
                                    {
                                        Text = LanguageSystem.Instance.SavingUIContents,
                                        Variety = NotifySystem.NotifyVariety.Levying,
                                        OnStop = wipeTotal => false,
                                    };
                                    try
                                    {
                                        UIHandler.Instance.HandleParallel(() => ViewModels.Instance.NotifyValue.NotifyItemCollection.Insert(0, savingUIItem));
                                        NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.Info, NotifySystem.NotifyConfigure.NotSave, savingUIItem.Text);
                                        zipFile.ExtractProgress += (sender, e) =>
                                        {
                                            if (e.EntriesTotal > 0)
                                            {
                                                savingUIItem.Status = e.EntriesExtracted;
                                                savingUIItem.MaxStatus = e.EntriesTotal;
                                            }
                                        };
                                        zipFile.ExtractAll(string.IsNullOrEmpty(Path.GetDirectoryName(yamlFileName)) ? Path.Combine(QwilightComponent.UIEntryPath, yamlFileName) : QwilightComponent.UIEntryPath, ExtractExistingFileAction.OverwriteSilently);
                                        savingUIItem.Variety = NotifySystem.NotifyVariety.Quit;
                                        savingUIItem.Text = LanguageSystem.Instance.SavedUIContents;
                                        NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.OK, NotifySystem.NotifyConfigure.Default, savingUIItem.Text);
                                        lastYamlFileName = yamlFileName;
                                    }
                                    catch (Exception e)
                                    {
                                        savingUIItem.Variety = NotifySystem.NotifyVariety.Stopped;
                                        savingUIItem.Text = string.Format(LanguageSystem.Instance.SaveUIFault, e.Message);
                                        NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.Fault, NotifySystem.NotifyConfigure.Default, savingUIItem.Text);
                                    }
                                    finally
                                    {
                                        savingUIItem.OnStop = wipeTotal => true;
                                    }
                                }
                            }
                            else if (filePath.IsTailCaselsss(".rar") || filePath.IsTailCaselsss(".7z"))
                            {
                                HandleNoteBundle(filePath);
                            }
                            else if (filePath.IsTailCaselsss(".lr2crs"))
                            {
                                var date = DateTime.Now;
                                using var fs = File.OpenRead(filePath);
                                foreach (var eventNote in (new XmlSerializer(typeof(XML.LR2CRS)).Deserialize(fs) as XML.LR2CRS).Items)
                                {
                                    try
                                    {
                                        var eventNoteID = eventNote.hash[32..];
                                        for (var m = eventNoteID.Length - 32; m > 0; m -= 32)
                                        {
                                            eventNoteID = eventNoteID.Insert(m, ":0/");
                                        }
                                        eventNoteID += ":0";
                                        var eventNoteName = eventNote.title;
                                        var eventNoteVariety = DB.EventNoteVariety.MD5;
                                        DB.Instance.SetEventNote(eventNoteID, eventNoteName, date, eventNoteVariety);
                                        lastEventNoteID = eventNoteID;
                                    }
                                    catch (SQLiteException)
                                    {
                                    }
                                }
                            }
                        }
                        else if (Directory.Exists(filePath))
                        {
                            var defaultEntryItem = new DefaultEntryItem
                            {
                                DefaultEntryVarietyValue = DefaultEntryItem.DefaultEntryVariety.Default,
                                DefaultEntryPath = filePath
                            };
                            if (!Configure.Instance.DefaultEntryItems.Contains(defaultEntryItem))
                            {
                                Configure.Instance.DefaultEntryItems.Add(defaultEntryItem);
                            }
                            lastDefaultEntryItem = defaultEntryItem;
                        }
                    }
                    if (!string.IsNullOrEmpty(lastEventNoteID))
                    {
                        NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.OK, NotifySystem.NotifyConfigure.Default, LanguageSystem.Instance.OpenedEventNotes);
                        LoadEventNoteEntryItems();
                        Want();
                    }
                    if (!string.IsNullOrEmpty(lastYamlFileName))
                    {
                        ViewModels.Instance.ConfigureValue.TabPosition = 0;
                        ViewModels.Instance.ConfigureValue.TabPositionComputing = 1;
                        ViewModels.Instance.ConfigureValue.TabPositionUI = lastYamlFileName.StartsWith('@') ? 0 : 1;
                        ViewModels.Instance.ConfigureValue.Open();
                    }
                    if (lastDefaultEntryItem != null)
                    {
                        Configure.Instance.LastDefaultEntryItem = lastDefaultEntryItem;
                        SetDefaultEntryItems();
                    }
                });
            }
        }

        public void OnSetInputWantPoint(bool hasPoint) => _isInputWantPointed = hasPoint;

        public void OnSetTwilightCommentaryPoint(bool hasPoint) => _isTwilightCommentaryPointed = hasPoint;

        public void OnSetPoint(bool hasPoint)
        {
            if (!hasPoint)
            {
                Computer?.AutoPause();
                DefaultControllerSystem.Instance.Init();
                ControllerSystem.Instance.Init();
                MIDISystem.Instance.Init();
            }
            HasPoint = hasPoint;
        }

        public void OnFitMode() => PointEntryView();

        public void OnWindowDPIModified(double windowDPI)
        {
            WindowDPI = windowDPI;
            OnModified();
            OnMove();
        }

        public void OnModified()
        {
            if (Configure.Instance.WindowedMode)
            {
                var windowArea = StrongReferenceMessenger.Default.Send<GetWindowArea>().Response;
                var windowAreaLength = windowArea.Width;
                var windowAreaHeight = windowArea.Height;
                Configure.Instance.WindowLengthV2 = (int)(windowAreaLength / WindowDPI);
                Configure.Instance.WindowHeightV2 = (int)(windowAreaHeight / WindowDPI);
            }
            if (!IsWPFViewVisible)
            {
                DrawingSystem.Instance.OnModified();
            }
        }

        public void OnMove()
        {
            var windowArea = StrongReferenceMessenger.Default.Send<GetWindowArea>().Response;
            var windowAreaPosition0 = windowArea.X;
            var windowAreaPosition1 = windowArea.Y;
            Configure.Instance.WindowPosition0V2 = windowAreaPosition0;
            Configure.Instance.WindowPosition1V2 = windowAreaPosition1;
        }

        public void OnTwilightCommentary(KeyEventArgs e)
        {
            if (e.Key == Key.Enter)
            {
                TwilightSystem.Instance.SendParallel(Event.Types.EventID.Commentary, new
                {
                    noteID = EntryItemValue.NoteFile.GetNoteID512(),
                    commentary = TwilightCommentary
                });
                var avatarID = TwilightSystem.Instance.AvatarID;
                var twilightCommentItem = TwilightCommentItemCollection.SingleOrDefault(twilightCommentItem => twilightCommentItem.AvatarWwwValue.AvatarID == avatarID);
                if (twilightCommentItem != null)
                {
                    twilightCommentItem.TwilightCommentary = string.IsNullOrEmpty(TwilightCommentary) ? string.Empty : $"💬 {TwilightCommentary}";
                }
                TwilightCommentary = string.Empty;
            }
        }

        public void OnDefaultCommentViewInputLower(KeyEventArgs e)
        {
            if (e.Key == Key.Delete && DefaultCommentItem != null)
            {
                if (StrongReferenceMessenger.Default.Send(new ViewAllowWindow
                {
                    Text = LanguageSystem.Instance.WipeCommentNotify,
                    Data = MESSAGEBOX_STYLE.MB_YESNO | MESSAGEBOX_STYLE.MB_ICONQUESTION | MESSAGEBOX_STYLE.MB_DEFBUTTON1
                }) == MESSAGEBOX_RESULT.IDYES)
                {
                    var defaultCommentFilePath = DefaultCommentItem.CommentID;
                    DefaultCommentItemCollection.Remove(DefaultCommentItem);
                    if (string.IsNullOrEmpty(EntryItemValue.EventNoteID))
                    {
                        Utility.WipeFile(Path.Combine(QwilightComponent.CommentEntryPath, Path.ChangeExtension(defaultCommentFilePath, ".zip")));
                    }
                    else
                    {
                        Utility.WipeFile(defaultCommentFilePath);
                    }
                    DB.Instance.WipeComment(defaultCommentFilePath);
                }
            }
        }

        public void OnWant()
        {
            _wantHandler.Stop();
            _wantHandler.Start();
        }

        public void OnPointLower(MouseButtonEventArgs e)
        {
            if (IsAvailable && IsNotModal())
            {
                var pointInput = e.ChangedButton;
                var isAlt = pointInput == MouseButton.Right;
                if (pointInput == MouseButton.Left || isAlt)
                {
                    var wpfView = StrongReferenceMessenger.Default.Send<GetWPFView>().Response;
                    var pointPosition = e.GetPosition(wpfView);
                    var pointPositionX = pointPosition.X;
                    var pointPositionY = pointPosition.Y;
                    var statusPoint = BaseUI.Instance.StatusPoint;
                    var inputNoteCountViewPoint = BaseUI.Instance.InputNoteCountViewPoint;
                    if (statusPoint?.Length >= 4 && new Bound(statusPoint).IsPoint(pointPosition))
                    {
                        var statusPosition0 = statusPoint[0];
                        var statusPosition1 = statusPoint[1];
                        var statusLength = statusPoint[2];
                        var statusHeight = statusPoint[3];
                        MoveStatus(isAlt ? -Component.LevyingWait : statusPoint[4] switch
                        {
                            0 => 1 - (pointPositionY - statusPosition1) / statusHeight,
                            1 => (pointPositionY - statusPosition1) / statusHeight,
                            2 => 1 - (pointPositionX - statusPosition0) / statusLength,
                            3 => (pointPositionX - statusPosition0) / statusLength,
                            _ => default,
                        }, e.ClickCount == 2);
                    }
                    else if (inputNoteCountViewPoint?.Length >= 4 && new Bound(inputNoteCountViewPoint).IsPoint(pointPosition))
                    {
                        MoveStatus(isAlt ? -Component.LevyingWait : (pointPositionX - inputNoteCountViewPoint[0]) / inputNoteCountViewPoint[2], e.ClickCount == 2);
                    }
                }
                if (pointInput == MouseButton.Middle)
                {
                    MoveEntryView();
                    PointEntryView();
                }
            }
        }

        public void SetLastDefaultEntryItem(DefaultEntryItem defaultEntryItem)
        {
            if (!IsDefaultEntryLoading && (Configure.Instance.LastDefaultEntryItem == null ^ defaultEntryItem == null))
            {
                Configure.Instance.LastDefaultEntryItem = defaultEntryItem;
                LoadDefaultEntryItem(false);
            }
        }

        public void OnEssentialInputLower(KeyEventArgs e)
        {
            if (ViewModels.Instance.InputValue.IsOpened || ViewModels.Instance.InputStandardValue.IsOpened || ViewModels.Instance.InputStandardControllerValue.IsOpened)
            {
                e.Handled = true;
            }
        }

        public void OnInputLower(KeyEventArgs e)
        {
            switch (e.Key)
            {
                case Key.System when e.SystemKey != Key.F4:
                case Key.Back:
                case Key.Escape:
                case Key.Space:
                    e.Handled = true;
                    break;
            }
        }

        public void OnEntryViewInputLower(KeyEventArgs e)
        {
            if (IsNoteFileMode)
            {
                var rawInput = e.Key;
                if (rawInput == Key.C && Utility.HasInput(VirtualKey.LeftControl))
                {
                    var dataBundle = new DataPackage();
                    if (IsEntryItemEventNote)
                    {
                        switch (EntryItemValue.EventNoteVariety)
                        {
                            case DB.EventNoteVariety.MD5:
                                if (EntryItemValue.NoteFiles.All(noteFile => !noteFile.IsLogical))
                                {
                                    dataBundle.SetText(string.Join('/', EntryItemValue.NoteFiles.Select(noteFile => noteFile.GetNoteID512())));
                                    Clipboard.SetContent(dataBundle);
                                }
                                else
                                {
                                    NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.Warning, NotifySystem.NotifyConfigure.Default, string.Join(", ", EntryItemValue.NoteFiles.Where(noteFile => !noteFile.IsLogical).Select(noteFile => noteFile.Title)));
                                }
                                foreach (var noteFile in EntryItemValue.NoteFiles.Where(noteFile => !noteFile.IsLogical))
                                {
                                    _ = TwilightSystem.Instance.PostWwwParallel($"{QwilightComponent.QwilightAPI}/note", noteFile.GetContents());
                                }
                                break;
                            case DB.EventNoteVariety.Qwilight:
                                dataBundle.SetText(EntryItemValue.EventNoteID);
                                Clipboard.SetContent(dataBundle);
                                foreach (var noteFile in EntryItemValue.NoteFiles.Where(noteFile => !noteFile.IsLogical))
                                {
                                    _ = TwilightSystem.Instance.PostWwwParallel($"{QwilightComponent.QwilightAPI}/note", noteFile.GetContents());
                                }
                                break;
                        }
                    }
                    else
                    {
                        if (IsNoteFileNotLogical)
                        {
                            dataBundle.SetText(EntryItemValue?.NoteFile?.GetNoteID512(null));
                            Clipboard.SetContent(dataBundle);
                        }
                    }
                }
                else
                {
                    var titleLetter = Utility.GetLetter(rawInput);
                    if (string.IsNullOrEmpty(titleLetter))
                    {
                        switch (rawInput)
                        {
                            case Key.Enter:
                                HandleLevyNoteFile();
                                break;
                            case Key.Left:
                                LowerNoteFile();
                                e.Handled = true;
                                break;
                            case Key.Right:
                                HigherNoteFile();
                                e.Handled = true;
                                break;
                            case Key.Back:
                                SetLastDefaultEntryItem(null);
                                break;
                            case Key.Up:
                                LowerEntryItem();
                                e.Handled = true;
                                break;
                            case Key.Down:
                                HigherEntryItem();
                                e.Handled = true;
                                break;
                            case Key.Delete:
                                if (Configure.Instance.LastDefaultEntryItem != null)
                                {
                                    var eventNoteID = EntryItemValue?.EventNoteID;
                                    if (string.IsNullOrEmpty(eventNoteID))
                                    {
                                        if (IsNoteFileNotLogical)
                                        {
                                            if (EntryItemValue.CanWipeNoteFile && !Utility.HasInput(VirtualKey.LeftShift))
                                            {
                                                if (StrongReferenceMessenger.Default.Send(new ViewAllowWindow
                                                {
                                                    Text = LanguageSystem.Instance.WipeNoteFileNotify,
                                                    Data = MESSAGEBOX_STYLE.MB_YESNO | MESSAGEBOX_STYLE.MB_ICONQUESTION | MESSAGEBOX_STYLE.MB_DEFBUTTON1
                                                }) == MESSAGEBOX_RESULT.IDYES)
                                                {
                                                    var targetNoteFile = EntryItemValue.NoteFile;
                                                    Utility.WipeFile(targetNoteFile.NoteFilePath);
                                                    LoadEntryItem(targetNoteFile.DefaultEntryItem, targetNoteFile.EntryItem.EntryPath);
                                                    NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.OK, NotifySystem.NotifyConfigure.Default, LanguageSystem.Instance.WipeNoteFileOK);
                                                }
                                            }
                                            else
                                            {
                                                CloseAutoComputer("Default");
                                                if (StrongReferenceMessenger.Default.Send(new ViewAllowWindow
                                                {
                                                    Text = LanguageSystem.Instance.WipeEntryItemNotify,
                                                    Data = MESSAGEBOX_STYLE.MB_YESNO | MESSAGEBOX_STYLE.MB_ICONQUESTION | MESSAGEBOX_STYLE.MB_DEFBUTTON1
                                                }) == MESSAGEBOX_RESULT.IDYES)
                                                {
                                                    Utility.WipeEntry(EntryItemValue.EntryPath);
                                                    LoadEntryItem(EntryItemValue.DefaultEntryItem, EntryItemValue.EntryPath);
                                                    NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.OK, NotifySystem.NotifyConfigure.Default, LanguageSystem.Instance.WipeEntryOK);
                                                }
                                            }
                                        }
                                    }
                                    else
                                    {
                                        if (StrongReferenceMessenger.Default.Send(new ViewAllowWindow
                                        {
                                            Text = LanguageSystem.Instance.WipeEventNoteNotify,
                                            Data = MESSAGEBOX_STYLE.MB_YESNO | MESSAGEBOX_STYLE.MB_ICONQUESTION | MESSAGEBOX_STYLE.MB_DEFBUTTON1
                                        }) == MESSAGEBOX_RESULT.IDYES)
                                        {
                                            DB.Instance.WipeEventNote(eventNoteID);
                                            LoadEventNoteEntryItems();
                                            Want();
                                        }
                                    }
                                }
                                else
                                {
                                    var defaultEntryItem = EntryItemValue.DefaultEntryItem;
                                    var defaultEntryVarietyValue = defaultEntryItem?.DefaultEntryVarietyValue;
                                    if (defaultEntryVarietyValue == DefaultEntryItem.DefaultEntryVariety.Default || defaultEntryVarietyValue == DefaultEntryItem.DefaultEntryVariety.Favorite)
                                    {
                                        if (StrongReferenceMessenger.Default.Send(new ViewAllowWindow
                                        {
                                            Text = defaultEntryItem.WipeNotify,
                                            Data = MESSAGEBOX_STYLE.MB_YESNO | MESSAGEBOX_STYLE.MB_ICONQUESTION | MESSAGEBOX_STYLE.MB_DEFBUTTON1
                                        }) == MESSAGEBOX_RESULT.IDYES)
                                        {
                                            Configure.Instance.DefaultEntryItems.Remove(defaultEntryItem);
                                            SetDefaultEntryItems();
                                        }
                                    }
                                }
                                break;
                        }
                    }
                    else
                    {
                        var foundEntryItem = Utility.HasInput(VirtualKey.LeftShift) ? EntryItems.SkipLast(EntryItems.Count - EntryItemPosition).LastOrDefault(IsSatisfy) ?? EntryItems.LastOrDefault(IsSatisfy) : EntryItems.Skip(EntryItemPosition + 1).FirstOrDefault(IsSatisfy) ?? EntryItems.FirstOrDefault(IsSatisfy);
                        if (foundEntryItem != null)
                        {
                            EntryItemValue = foundEntryItem;
                        }

                        bool IsSatisfy(EntryItem entryItem) => entryItem.Title.IsFrontCaselsss(titleLetter);
                    }
                }
            }
        }

        public void OnEntryViewPointLower(MouseButtonEventArgs e)
        {
            if (e.ChangedButton == MouseButton.Right)
            {
                ViewModels.Instance.NoteFileValue.EntryItemValue = EntryItemValue;
                ViewModels.Instance.NoteFileValue.Open();
            }
        }

        public void OnDefaultCommentViewModified() => OnCommentItemModified(DefaultCommentItem);

        public void OnTwilightCommentViewModified() => OnCommentItemModified(TwilightCommentItem);

        void OnCommentItemModified(CommentItem commentItem)
        {
            IsCommentMode = commentItem != null;
            if (IsCommentMode)
            {
                ModeComponentValue.CopyAs(commentItem.ModeComponentValue, null, false);
            }
            VerifyNoteFile(ModeComponentValue.Salt);
        }

        public void OnDefaultComment()
        {
            var defaultCommentItem = DefaultCommentItem;
            if (defaultCommentItem != null)
            {
                if (EntryItemValue != null)
                {
                    try
                    {
                        IsCommentMode = false;
                        var defaultModeComponentValue = ModeComponentValue.Clone();
                        ModeComponentValue.CopyAs(defaultCommentItem.ModeComponentValue, null, false);
                        if (string.IsNullOrEmpty(EntryItemValue.EventNoteID))
                        {
                            using var fs = File.OpenRead(Path.Combine(QwilightComponent.CommentEntryPath, defaultCommentItem.CommentID));
                            SetQuitMode(new QuitCompute([EntryItemValue.NoteFile], [Comment.Parser.ParseFrom(fs)], defaultModeComponentValue, defaultCommentItem, null));
                        }
                        else
                        {
                            using var zipFile = ZipFile.Read(Path.Combine(QwilightComponent.CommentEntryPath, Path.ChangeExtension(defaultCommentItem.CommentID, ".zip")));
                            SetQuitMode(new QuitCompute(EntryItemValue.NoteFiles, Enumerable.Range(0, EntryItemValue.NoteFiles.Length).Select(i =>
                            {
                                var zipEntry = zipFile[i.ToString()];
                                using var rms = PoolSystem.Instance.GetDataFlow((int)zipEntry.UncompressedSize);
                                zipEntry.Extract(rms);
                                rms.Position = 0;
                                return Comment.Parser.ParseFrom(rms);
                            }).ToArray(), defaultModeComponentValue, defaultCommentItem, EntryItemValue));
                        }
                    }
                    catch (Exception e)
                    {
                        NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.Fault, NotifySystem.NotifyConfigure.Default, string.Format(LanguageSystem.Instance.FaultCommentContents, e.Message));
                    }
                }
            }
        }

        public async Task OnTwilightComment()
        {
            var noteID = EntryItemValue?.NoteFile?.GetNoteID512();
            var commentID = TwilightCommentItem?.CommentID;
            if (!string.IsNullOrEmpty(noteID) && !string.IsNullOrEmpty(commentID))
            {
                using var s = await TwilightSystem.Instance.GetWwwParallel($"{QwilightComponent.QwilightAPI}/comment?noteID={noteID}&commentID={commentID}").ConfigureAwait(false);
                var noteFile = EntryItemValue?.NoteFile;
                var twilightCommentItem = TwilightCommentItem;
                if (IsNoteFileMode && noteFile?.GetNoteID512() == noteID && twilightCommentItem?.CommentID == commentID)
                {
                    if (s.Length > 0)
                    {
                        IsCommentMode = false;
                        var defaultModeComponentValue = ModeComponentValue.Clone();
                        ModeComponentValue.CopyAs(twilightCommentItem.ModeComponentValue, null, false);
                        SetQuitMode(new QuitCompute([noteFile], [Comment.Parser.ParseFrom(s)], defaultModeComponentValue, twilightCommentItem, null));
                    }
                }
            }
        }

        public void OnLevyNoteFile(MouseButtonEventArgs e)
        {
            if (e.ClickCount >= 2 && e.ChangedButton == MouseButton.Left)
            {
                HandleLevyNoteFile();
            }
        }

        [RelayCommand]
        static void OnSignIn() => ViewModels.Instance.SignInValue.Open();

        [RelayCommand]
        static void OnLevelWindow() => ViewModels.Instance.LevelValue.Open();

        [RelayCommand]
        static void OnWantWindow() => ViewModels.Instance.WantValue.Open();

        [RelayCommand]
        static void OnViewMyAvatar()
        {
            var avatarViewModel = ViewModels.Instance.AvatarValue;
            avatarViewModel.CallingAvatarID = TwilightSystem.Instance.AvatarID;
            avatarViewModel.Open();
        }

        [RelayCommand]
        static void OnViewMyBundle() => TwilightSystem.Instance.SendParallel(Event.Types.EventID.CallBundle, TwilightSystem.Instance.AvatarID);

        [RelayCommand]
        static void OnNotSignIn()
        {
            if (StrongReferenceMessenger.Default.Send(new ViewAllowWindow
            {
                Text = LanguageSystem.Instance.NotSignInNotify,
                Data = MESSAGEBOX_STYLE.MB_YESNO | MESSAGEBOX_STYLE.MB_ICONQUESTION | MESSAGEBOX_STYLE.MB_DEFBUTTON1
            }) == MESSAGEBOX_RESULT.IDYES)
            {
                Configure.Instance.SetCipher(string.Empty);
                Configure.Instance.AutoSignIn = false;
                TwilightSystem.Instance.SendParallel<object>(Event.Types.EventID.NotSignIn, null);
            }
        }

        [RelayCommand]
        void OnViewFile()
        {
            var noteFilePath = EntryItemValue?.NoteFile?.NoteFilePath;
            if (string.IsNullOrEmpty(noteFilePath))
            {
                var lastDefaultEntryItem = Configure.Instance.LastDefaultEntryItem;
                if (lastDefaultEntryItem != null)
                {
                    if (lastDefaultEntryItem.DefaultEntryVarietyValue == DefaultEntryItem.DefaultEntryVariety.Default || lastDefaultEntryItem.DefaultEntryVarietyValue == DefaultEntryItem.DefaultEntryVariety.Essential)
                    {
                        Utility.OpenAs(lastDefaultEntryItem.DefaultEntryPath);
                    }
                }
                else
                {
                    Utility.OpenAs(EntryItemValue?.DefaultEntryItem?.DefaultEntryPath);
                }
            }
            else
            {
                Utility.OpenAs(Path.GetDirectoryName(noteFilePath));
            }
        }

        [RelayCommand]
        async Task OnViewAssistFile()
        {
            var noteFile = EntryItemValue.NoteFile;
            var assistFilePath = Path.Combine(noteFile.EntryItem.EntryPath, noteFile.AssistFileName);
            if (File.Exists(assistFilePath))
            {
                var format = DB.Instance.GetFormat(noteFile);
                if (format == -1)
                {
                    var formatComputer = CharsetDetector.DetectFromFile(assistFilePath).Detected;
                    format = formatComputer != null && formatComputer.Confidence >= 0.875 && formatComputer.Encoding != null ? formatComputer.Encoding.CodePage : 932;
                }
                var assistFileViewModel = ViewModels.Instance.AssistFileValue;
                assistFileViewModel.Title = noteFile.EntryItem.Title;
                assistFileViewModel.Assist = await File.ReadAllTextAsync(assistFilePath, Encoding.GetEncoding(format)).ConfigureAwait(false);
                assistFileViewModel.Open();
            }
        }

        [RelayCommand]
        static void OnModeComponent(int? e)
        {
            if (e.HasValue)
            {
                ViewModels.Instance.ModifyModeComponentValue.ModeComponentVariety = e.Value;
                ViewModels.Instance.ModifyModeComponentValue.Open();
            }
        }

        [RelayCommand]
        void OnPause() => Pause();

        public void Pause()
        {
            if (HasNotInput())
            {
                switch (ModeValue)
                {
                    case Mode.NoteFile:
                        if (AutoComputer != null)
                        {
                            AutoComputer.SetPause = !AutoComputer.SetPause;
                        }
                        else
                        {
                            _pausableAudioHandler.IsPausing = !_pausableAudioHandler.IsPausing;
                        }
                        break;
                    case Mode.Computing:
                        if (Computer.CanSetPosition)
                        {
                            Computer.SetPause = !Computer.SetPause;
                        }
                        break;
                }
            }
        }

        [RelayCommand]
        static void OnAutoSalt() => Configure.Instance.SaltAuto = !Configure.Instance.SaltAuto;

        [RelayCommand]
        static void OnConfigure() => ViewModels.Instance.ConfigureValue.Open();

        [RelayCommand]
        static void OnComment() => ViewModels.Instance.CommentValue.Open();

        [RelayCommand]
        void OnLowerTwilightCommentFavor()
        {
            TwilightSystem.Instance.SendParallel(Event.Types.EventID.SetFavor, new
            {
                noteID = EntryItemValue.NoteFile.GetNoteID512(),
                favor = TwilightCommentFavor == false ? null : false as bool?
            });
            LoadTwilightCommentItemCollection();
        }

        [RelayCommand]
        void OnHigherTwilightCommentFavor()
        {
            TwilightSystem.Instance.SendParallel(Event.Types.EventID.SetFavor, new
            {
                noteID = EntryItemValue.NoteFile.GetNoteID512(),
                favor = TwilightCommentFavor == true ? null : true as bool?
            });
            LoadTwilightCommentItemCollection();
        }

        public MainViewModel()
        {
            _loadDefaultCommentHandler.Tick += (sender, e) =>
            {
                (sender as DispatcherTimer).Stop();
                if (EntryItemValue != null)
                {
                    var targetNoteFiles = EntryItemValue.NoteFiles;
                    var commentItems = (IsEntryItemEventNote ? DB.Instance.GetCommentItems(targetNoteFiles[0], EntryItemValue.EventNoteID, targetNoteFiles.Length) : DB.Instance.GetCommentItems(EntryItemValue.NoteFile, EntryItemValue.EventNoteID, 1));
                    DefaultCommentItemCollection.Clear();
                    foreach (var commentItem in commentItems)
                    {
                        DefaultCommentItemCollection.Add(commentItem);
                    }
                    IsDefaultCommentLoading = false;
                }
            };
            _loadTwilightCommentHandler.Tick += async (sender, e) =>
            {
                (sender as DispatcherTimer).Stop();
                var noteID = EntryItemValue?.NoteFile?.GetNoteID512();
                if (!string.IsNullOrEmpty(noteID))
                {
                    var twilightWwwComment = await TwilightSystem.Instance.GetWwwParallel<JSON.TwilightWwwComment?>($"{QwilightComponent.QwilightAPI}/comment?noteID={noteID}&avatarID={(TwilightSystem.Instance.IsSignedIn ? TwilightSystem.Instance.AvatarID : string.Empty)}&language={Configure.Instance.Language}&isUbuntu={Configure.Instance.UbuntuNetItemTarget}");
                    var noteFile = EntryItemValue?.NoteFile;
                    if (noteFile?.GetNoteID512() == noteID)
                    {
                        if (twilightWwwComment.HasValue)
                        {
                            var twilightWwwCommentValue = twilightWwwComment.Value;
                            var comments = twilightWwwCommentValue.comments;
                            if (comments == null)
                            {
                                noteFile.IsBanned = true;
                                OnPropertyChanged(nameof(IsEntryItemBanned));
                            }
                            else
                            {
                                noteFile = EntryItemValue?.NoteFile;
                                var commentItems = Utility.GetCommentItems(comments, noteFile);
                                TwilightCommentTotalFavor = twilightWwwCommentValue.totalFavor.ToString("👍 #,##0");
                                TwilightCommentFavor = twilightWwwCommentValue.favor;
                                TwilightCommentItemCollection.Clear();
                                foreach (var commentItem in commentItems)
                                {
                                    TwilightCommentItemCollection.Add(commentItem);
                                }
                                var targetComment = commentItems.Where(comment => comment.AvatarWwwValue.AvatarID == TwilightSystem.Instance.AvatarID).SingleOrDefault();
                                if (targetComment != null)
                                {
                                    TwilightCommentText0 = (Array.IndexOf(commentItems, targetComment) + 1).ToString("##,##0");
                                    TwilightCommentText1 = commentItems.Length.ToString("/#,##0");
                                }
                                var handled = twilightWwwCommentValue.handled;
                                if (handled.HasValue)
                                {
                                    var handledValue = handled.Value;
                                    if (noteFile.HandledValue != handledValue && !(noteFile.HandledValue == BaseNoteFile.Handled.F && handledValue == BaseNoteFile.Handled.Not))
                                    {
                                        noteFile.HandledValue = handledValue;
                                        DB.Instance.SetHandled(noteFile);
                                    }
                                }
                            }
                        }
                        IsTwilightCommentLoading = false;
                    }
                }
            };
            _autoComputerHandler.Tick += (sender, e) =>
            {
                (sender as DispatcherTimer).Stop();
                if (IsNoteFileMode)
                {
                    HandleAutoComputerImmediately(true);
                }
            };
            _wantHandler.Tick += (sender, e) => Want();
            _fsw.Renamed += (sender, e) =>
            {
                if (e.OldFullPath.IsTailCaselsss(".crdownload") && QwilightComponent.BundleFileFormats.Any(format => e.FullPath.IsTailCaselsss(format)))
                {
                    var filePath = e.FullPath;
                    Utility.WaitUntilCanOpen(filePath);
                    var rar = filePath.IsTailCaselsss(".rar");
                    var lzma = filePath.IsTailCaselsss(".7z");
                    if (rar || lzma)
                    {
                        using IArchive rarLZMAFile = rar ? RarArchive.Open(filePath) : SevenZipArchive.Open(filePath);
                        if (rarLZMAFile.Entries.All(rarLZMAEntry => QwilightComponent.NoteFileFormats.Any(format => rarLZMAEntry.Key.IsTailCaselsss(format))))
                        {
                            Utility.OpenAs(filePath);
                        }
                        else
                        {
                            HandleNoteBundle(filePath);
                        }
                    }
                    else
                    {
                        using var zipFile = ZipFile.Read(filePath);
                        if (zipFile.All(zipEntry => QwilightComponent.NoteFileFormats.Any(format => zipEntry.FileName.IsTailCaselsss(format))))
                        {
                            Utility.OpenAs(filePath);
                        }
                        else
                        {
                            HandleNoteBundle(filePath);
                        }
                    }
                }
            };
        }

        public void HandleLevyNoteFile(BaseNoteFile noteFile = null, EntryItem entryItem = null, WwwLevelData wwwLevelDataValue = null, ModeComponent defaultModeComponentValue = null)
        {
            if ((noteFile != null && entryItem != null) || HasNotInput())
            {
                entryItem ??= EntryItemValue;
                noteFile ??= entryItem?.NoteFile;

                var onLevyNoteFile = noteFile?.OnLevyNoteFile;
                if (onLevyNoteFile != null)
                {
                    onLevyNoteFile();
                }
                else
                {
                    if (ViewModels.Instance.HasSiteViewModel(siteViewModel => siteViewModel.IsNetSite))
                    {
                        NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.Warning, NotifySystem.NotifyConfigure.Default, LanguageSystem.Instance.DefaultComputeInNetSiteFault);
                    }
                    else
                    {
                        var isSaltNoteFile = noteFile is SaltNoteFile;
                        if (isSaltNoteFile)
                        {
                            SaltEntryView();
                            entryItem = EntryItemValue;
                            noteFile = entryItem.NoteFile;
                        }

                        if (entryItem != null)
                        {
                            if (string.IsNullOrEmpty(entryItem.EventNoteID))
                            {
                                Utility.HandleUIAudio("Levy Note File");
                                IsCommentMode = false;
                                ModeComponentValue.ComputingValue = noteFile;
                                ModeComponentValue.CanModifyMultiplier = true;
                                ModeComponentValue.CanModifyAudioMultiplier = true;
                                SetComputingMode(new([noteFile], null, defaultModeComponentValue, TwilightSystem.Instance.AvatarID, TwilightSystem.Instance.GetAvatarName(), wwwLevelDataValue, null, null, null));
                            }
                            else
                            {
                                var noteFiles = entryItem.NoteFiles;
                                if (noteFiles.Any(noteFile => string.IsNullOrEmpty(noteFile.NoteFilePath)))
                                {
                                    NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.Warning, NotifySystem.NotifyConfigure.Default, LanguageSystem.Instance.NotAvailableEventNoteFileFault);
                                }
                                else
                                {
                                    Utility.HandleUIAudio("Levy Note File");
                                    IsCommentMode = false;
                                    ModeComponentValue.ComputingValue = noteFiles.First();
                                    ModeComponentValue.CanModifyMultiplier = true;
                                    ModeComponentValue.CanModifyAudioMultiplier = true;
                                    SetComputingMode(new(noteFiles, null, defaultModeComponentValue, TwilightSystem.Instance.AvatarID, TwilightSystem.Instance.GetAvatarName(), wwwLevelDataValue, null, entryItem, null));
                                }
                            }
                        }

                        if (isSaltNoteFile)
                        {
                            EntryItemPosition = 1;
                        }
                    }
                }
            }
        }

        public void Close()
        {
            _fsw.Dispose();

            IsCommentMode = false;
            var defaultModeComponentValue = Computer?.DefaultModeComponentValue;
            if (defaultModeComponentValue != null)
            {
                ModeComponentValue.CopyAs(defaultModeComponentValue);
            }

            Configure.Instance.Save(false);
            GPUConfigure.Instance.Save(false);
            DB.Instance.Save();
            FastDB.Instance.Save();

            AudioSystem.Instance.Dispose();
            AudioInputSystem.Instance.Dispose();
            TwilightSystem.Instance.Dispose();
            IlluminationSystem.Instance.Dispose();
            ValveSystem.Instance.Dispose();

            Utility.ModifyHwMode(QwilightComponent.DefaultHwMode);

            PIDClass.Instance.Dispose();

            if (File.Exists(_qwilightFileName))
            {
                if (_qwilightFileName.IsTailCaselsss(".zip"))
                {
                    Utility.CopyFile(Path.Combine(QwilightComponent.CPUAssetsEntryPath, "Igniter.exe"), Path.Combine(QwilightComponent.UtilityEntryPath, "Igniter.exe"));
                    try
                    {
                        Process.Start(new ProcessStartInfo(Path.Combine(QwilightComponent.UtilityEntryPath, "Igniter.exe"), $"\"{_qwilightFileName}\"")
                        {
                            UseShellExecute = true
                        });
                    }
                    catch
                    {
                        Utility.OpenAs(_qwilightFileName);
                    }
                }
                else
                {
                    Utility.OpenAs(_qwilightFileName);
                }
            }
        }

        void WipeEntryItems(Func<EntryItem, bool> wipeEntryItemCondition, Func<BaseNoteFile, bool> wipeNoteIDCondition, bool wipeEventNoteEntryItems)
        {
            foreach (var (entryItemID, entryItem) in _entryItems)
            {
                if (wipeEntryItemCondition(entryItem))
                {
                    _entryItems.Remove(entryItemID, out _);
                }
            }
            if (wipeNoteIDCondition != null)
            {
                foreach (var (noteID, noteFile) in NoteID512s)
                {
                    if (wipeNoteIDCondition(noteFile))
                    {
                        NoteID512s.Remove(noteID, out _);
                    }
                }
                foreach (var (noteID, noteFile) in NoteID128s)
                {
                    if (wipeNoteIDCondition(noteFile))
                    {
                        NoteID128s.Remove(noteID, out _);
                    }
                }
            }
            if (wipeEventNoteEntryItems)
            {
                EventNoteEntryItems.Clear();
            }
        }

        public void LoadEventNoteEntryItems()
        {
            WipeEntryItems(entryItem => !string.IsNullOrEmpty(entryItem.EventNoteID), null, true);
            foreach (var (eventNoteID, eventNoteName, eventNoteDate, eventNoteVariety) in DB.Instance.GetEventNotes())
            {
                try
                {
                    var noteIDs = eventNoteVariety switch
                    {
                        DB.EventNoteVariety.Qwilight => NoteID512s,
                        DB.EventNoteVariety.MD5 => NoteID128s,
                        _ => default,
                    };
                    var entryItem = new EntryItem
                    {
                        Title = eventNoteName,
                        EventNoteID = eventNoteID,
                        EventNoteName = eventNoteName,
                        EventNoteVariety = eventNoteVariety,
                        ModifiedDate = eventNoteDate,
                        EntryItemID = Interlocked.Increment(ref _lastEntryItemID)
                    };
                    var noteFiles = eventNoteID.Split('/').Select(noteID => noteIDs.TryGetValue(noteID, out var noteFile) ? noteFile : new NotAvailableNoteFile(noteID, entryItem.DefaultEntryItem, entryItem));
                    var (latestDate, handledCount) = DB.Instance.GetDate(default, eventNoteID);
                    entryItem.LatestDate = latestDate;
                    entryItem.HandledCount = handledCount;
                    entryItem.NoteFiles = noteFiles.ToArray();
                    entryItem.WellNoteFiles = noteFiles.ToList();
                    _entryItems[entryItem.EntryItemID] = entryItem;
                    EventNoteEntryItems[eventNoteID] = entryItem;
                }
                catch
                {
                }
            }
        }

        public void HandleNoteBundle(string filePath)
        {
            var savingFileItem = new NotifyItem
            {
                Text = LanguageSystem.Instance.SavingFileContents,
                Variety = NotifySystem.NotifyVariety.Levying,
                OnStop = wipeTotal => false,
            };
            try
            {
                UIHandler.Instance.HandleParallel(() => ViewModels.Instance.NotifyValue.NotifyItemCollection.Insert(0, savingFileItem));
                NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.Info, NotifySystem.NotifyConfigure.NotSave, savingFileItem.Text);
                var bundleEntryItem = Configure.Instance.LastDefaultEntryItem ?? DefaultEntryItem.EssentialBundle;
                if (bundleEntryItem.DefaultEntryVarietyValue != DefaultEntryItem.DefaultEntryVariety.Default && bundleEntryItem.DefaultEntryVarietyValue != DefaultEntryItem.DefaultEntryVariety.Essential)
                {
                    bundleEntryItem = DefaultEntryItem.EssentialBundle;
                }
                var bundleEntryPath = Path.Combine(bundleEntryItem.DefaultEntryPath, Path.GetFileNameWithoutExtension(filePath));
                Directory.CreateDirectory(bundleEntryPath);
                var rar = filePath.IsTailCaselsss(".rar");
                var lzma = filePath.IsTailCaselsss(".7z");
                if (rar || lzma)
                {
                    using IArchive rarLZMAFile = rar ? RarArchive.Open(filePath) : SevenZipArchive.Open(filePath);
                    foreach (var rarLZMAEntry in rarLZMAFile.Entries)
                    {
                        try
                        {
                            rarLZMAEntry.WriteToDirectory(bundleEntryPath, new()
                            {
                                ExtractFullPath = true
                            });
                        }
                        catch
                        {
                        }
                    }
                }
                else
                {
                    using var zipFile = ZipFile.Read(filePath, new()
                    {
                        Encoding = Encoding.GetEncoding(932)
                    });
                    zipFile.ExtractProgress += (sender, e) =>
                    {
                        if (e.EntriesTotal > 0)
                        {
                            savingFileItem.Status = e.EntriesExtracted;
                            savingFileItem.MaxStatus = e.EntriesTotal;
                        }
                    };
                    zipFile.ExtractAll(bundleEntryPath, ExtractExistingFileAction.OverwriteSilently);
                }
                LoadEntryItem(bundleEntryItem, bundleEntryPath);
                savingFileItem.Variety = NotifySystem.NotifyVariety.Quit;
                savingFileItem.Text = LanguageSystem.Instance.SavedFileContents;
                NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.OK, NotifySystem.NotifyConfigure.Default, savingFileItem.Text);
            }
            catch (Exception e)
            {
                savingFileItem.Variety = NotifySystem.NotifyVariety.Stopped;
                savingFileItem.Text = string.Format(LanguageSystem.Instance.SaveFileFault, e.Message);
                NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.Fault, NotifySystem.NotifyConfigure.Default, savingFileItem.Text);
            }
            finally
            {
                savingFileItem.OnStop = wipeTotal => true;
            }
        }

        void MoveStatus(double status, bool isEnter)
        {
            if (!_autoComputerHandler.IsEnabled && AutoComputer?.IsHandling == true)
            {
                AutoComputer.LevyingWait = AutoComputer.Length * status;
                AutoComputer.SetUndo = true;
                if (isEnter)
                {
                    EnterAutoComputingMode();
                }
            }
        }

        public void EnterAutoComputingMode()
        {
            if (!IsComputingMode)
            {
                Fade(() =>
                {
                    Computer = AutoComputer;
                    ModeValue = Mode.Computing;
                    Configure.Instance.NotifyTutorial(Configure.TutorialID.ModifyAutoMode);
                }, AutoComputer, true, 2);
            }
        }

        public void LoadDefaultEntryItem(bool isF5)
        {
            var lastDefaultEntryItem = Configure.Instance.LastDefaultEntryItem;
            if (lastDefaultEntryItem == null)
            {
                Want();
            }
            else
            {
                _setCancelDefaultEntryLoading = new();
                IsDefaultEntryLoading = true;
                Task.Run(() =>
                {
                    using (_setCancelDefaultEntryLoading)
                    {
                        try
                        {
                            switch (lastDefaultEntryItem.DefaultEntryVarietyValue)
                            {
                                case DefaultEntryItem.DefaultEntryVariety.Total:
                                    foreach (var defaultEntryPath in DefaultEntryItems.Where(defaultEntryItem => defaultEntryItem.DefaultEntryVarietyValue == DefaultEntryItem.DefaultEntryVariety.Essential || defaultEntryItem.DefaultEntryVarietyValue == DefaultEntryItem.DefaultEntryVariety.Default))
                                    {
                                        LoadDefaultEntryItemImpl(defaultEntryPath);
                                    }
                                    break;
                                case DefaultEntryItem.DefaultEntryVariety.Essential:
                                case DefaultEntryItem.DefaultEntryVariety.Default:
                                    LoadDefaultEntryItemImpl(lastDefaultEntryItem);
                                    break;
                                case DefaultEntryItem.DefaultEntryVariety.Favorite:
                                    foreach (var frontEntryPath in lastDefaultEntryItem.FrontEntryPaths)
                                    {
                                        LoadDefaultEntryItemImpl(frontEntryPath == QwilightComponent.BundleEntryPath ? DefaultEntryItem.EssentialBundle : new()
                                        {
                                            DefaultEntryVarietyValue = DefaultEntryItem.DefaultEntryVariety.Default,
                                            DefaultEntryPath = frontEntryPath
                                        });
                                    }
                                    break;
                            }

                            void LoadDefaultEntryItemImpl(DefaultEntryItem defaultEntryItem)
                            {
                                var defaultEntryPath = defaultEntryItem.DefaultEntryPath;
                                if (defaultEntryPath != null)
                                {
                                    var defaultEntryDate = Directory.GetLastWriteTime(defaultEntryPath);
                                    isF5 = isF5 || defaultEntryDate > FastDB.Instance.GetDefaultEntryItemDate(defaultEntryPath);
                                    if (isF5)
                                    {
                                        FastDB.Instance.SetDefaultEntryItemDate(defaultEntryPath, defaultEntryDate);
                                        FastDB.Instance.WipeDefaultEntryItem(defaultEntryPath);
                                    }
                                }
                                if ((isF5 && _alreadyLoadedDefaultEntryItems.Remove(defaultEntryItem)) || !_alreadyLoadedDefaultEntryItems.Contains(defaultEntryItem))
                                {
                                    WipeEntryItems(entryItem => defaultEntryItem == entryItem.DefaultEntryItem, noteFile => noteFile.DefaultEntryItem == defaultEntryItem, false);
                                    var defaultEntryData = FastDB.Instance.GetDefaultEntryItems(defaultEntryPath);
                                    var entryPaths = new ConcurrentBag<string>(defaultEntryData);
                                    var loadedDefaultEntryPathsLength = 0;
                                    var defaultEntryPathsLength = 0;
                                    if (entryPaths.IsEmpty)
                                    {
                                        var defaultEntryPaths = Utility.GetEntry(defaultEntryPath);
                                        defaultEntryPathsLength = defaultEntryPaths.Length;
                                        loadedDefaultEntryPathsLength = 0;
                                        if (Directory.Exists(defaultEntryPath))
                                        {
                                            LoadEntry(defaultEntryPath);
                                        }
                                        void LoadEntry(string targetEntryPath)
                                        {
                                            _setCancelDefaultEntryLoading.Token.ThrowIfCancellationRequested();
                                            foreach (var entryPath in defaultEntryPath == targetEntryPath ? defaultEntryPaths : Utility.GetEntry(targetEntryPath))
                                            {
                                                LoadEntry(entryPath);
                                                if (defaultEntryPath == targetEntryPath)
                                                {
                                                    Status = (double)Interlocked.Increment(ref loadedDefaultEntryPathsLength) / defaultEntryPathsLength;
                                                }
                                            }
                                            entryPaths.Add(targetEntryPath);
                                            FastDB.Instance.SetDefaultEntryItem(defaultEntryPath, targetEntryPath);
                                        }
                                    }
                                    loadedDefaultEntryPathsLength = 0;
                                    defaultEntryPathsLength = entryPaths.Count;
                                    try
                                    {
                                        if (isF5)
                                        {
                                            foreach (var entryPath in entryPaths)
                                            {
                                                FastDB.Instance.WipeEntryItem(entryPath);
                                            }
                                        }
                                        Utility.HandleLowlyParallelly(entryPaths, Configure.Instance.LoadingBin, entryPath =>
                                        {
                                            LoadEntryItem(defaultEntryItem, entryPath, _setCancelDefaultEntryLoading);
                                            Status = (double)Interlocked.Increment(ref loadedDefaultEntryPathsLength) / defaultEntryPathsLength;
                                        }, _setCancelDefaultEntryLoading.Token);
                                    }
                                    catch (OperationCanceledException)
                                    {
                                        throw;
                                    }
                                    catch
                                    {
                                        _alreadyLoadedDefaultEntryItems.Remove(defaultEntryItem);
                                        FastDB.Instance.WipeDefaultEntryItem(defaultEntryPath);
                                    }
                                }
                                _alreadyLoadedDefaultEntryItems.Add(defaultEntryItem);
                            }
                        }
                        catch (OperationCanceledException)
                        {
                        }
                        finally
                        {
                            IsDefaultEntryLoading = false;
                            Status = 0.0;
                            LoadEventNoteEntryItems();
                            Want();
                            NotifySystem.Instance.NotifyPending();
                            ViewModels.Instance.SiteContainerValue.SetComputingValues();
                        }
                    }
                });
            }
        }

        public void LoadEntryItem(DefaultEntryItem defaultEntryItem, string entryPath, bool wantEntryItem = true)
        {
            var targetEntryPaths = new List<string>();
            targetEntryPaths.Add(entryPath);
            if (Directory.Exists(entryPath))
            {
                LoadEntry(entryPath);
                void LoadEntry(string targetEntryPath)
                {
                    foreach (var entryPath in Utility.GetEntry(targetEntryPath))
                    {
                        LoadEntry(entryPath);
                    }
                    targetEntryPaths.Add(targetEntryPath);
                }
            }

            var wantEntryItems = wantEntryItem ? new List<EntryItem>() : null;
            foreach (var targetEntryPath in targetEntryPaths)
            {
                foreach (var entryItem in _entryItems.Values.Where(entryItem => entryItem.EntryPath == targetEntryPath))
                {
                    _entryItems.Remove(entryItem.EntryItemID, out _);
                }
                FastDB.Instance.WipeEntryItem(targetEntryPath);
                var entryItems = LoadEntryItem(defaultEntryItem, targetEntryPath, null);
                wantEntryItems?.AddRange(entryItems);
            }
            LoadEventNoteEntryItems();
            Want(wantEntryItems?.LastOrDefault());
            NotifySystem.Instance.NotifyPending();
            ViewModels.Instance.SiteContainerValue.SetComputingValues();
        }

        IEnumerable<EntryItem> LoadEntryItem(DefaultEntryItem defaultEntryItem, string entryPath, CancellationTokenSource setCancelDefaultEntryLoading)
        {
            foreach (var (noteID, _) in NoteID512s.Where(pair => pair.Value.EntryItem.EntryPath == entryPath))
            {
                NoteID512s.Remove(noteID, out _);
            }
            foreach (var (noteID, _) in NoteID128s.Where(pair => pair.Value.EntryItem.EntryPath == entryPath))
            {
                NoteID128s.Remove(noteID, out _);
            }
            var tmpEntryItem = Configure.Instance.GroupEntry ? NewEntryItem() : null;
            var targetNoteFiles = new List<BaseNoteFile>();
            var fastEntryItems = FastDB.Instance.GetEntryItems(entryPath).ToArray();
            if (fastEntryItems.Length > 0)
            {
                foreach (var fastEntryItem in fastEntryItems)
                {
                    var noteFilePath = fastEntryItem.noteFilePath;
                    var noteID128 = fastEntryItem.noteID128;
                    var noteID256 = fastEntryItem.noteID256;
                    var noteID512 = fastEntryItem.noteID512;
                    foreach (var dataID in fastEntryItem.dataIDs)
                    {
                        var entryItem = tmpEntryItem ?? NewEntryItem();
                        var noteFile = BaseNoteFile.GetNoteFiles(noteFilePath, defaultEntryItem, entryItem, dataID)?.Single();
                        if (noteFile != null)
                        {
                            try
                            {
                                noteFile.SetNoteIDs(noteID128, noteID256, noteID512);
                                if (!FastDB.Instance.GetNoteFile(noteFile))
                                {
                                    noteFile.Compile(Environment.TickCount, setCancelDefaultEntryLoading);
                                }
                                noteFile.SetData();
                                targetNoteFiles.Add(noteFile);
                            }
                            catch (OperationCanceledException)
                            {
                                break;
                            }
                            catch (Exception e)
                            {
                                NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.Warning, NotifySystem.NotifyConfigure.Save, $"{Path.GetFileName(noteFilePath)} ({e.Message})", true, null, () => Utility.OpenAs(Path.GetDirectoryName(noteFilePath)));
                            }
                        }
                    }
                }
            }
            else
            {
                foreach (var noteFilePath in Utility.GetFiles(entryPath).Where(noteFilePath => QwilightComponent.NoteFileFormats.Any(format => noteFilePath.IsTailCaselsss(format))))
                {
                    var entryItem = tmpEntryItem ?? NewEntryItem();
                    var noteFiles = BaseNoteFile.GetNoteFiles(noteFilePath, defaultEntryItem, entryItem, -1);
                    if (noteFiles != null)
                    {
                        var dataIDs = noteFiles.Select(noteFile => noteFile.DataID).ToArray();
                        foreach (var noteFile in noteFiles)
                        {
                            try
                            {
                                if (!FastDB.Instance.GetNoteFile(noteFile))
                                {
                                    noteFile.Compile(Environment.TickCount, setCancelDefaultEntryLoading);
                                }
                                noteFile.SetData();
                                targetNoteFiles.Add(noteFile);
                            }
                            catch (OperationCanceledException)
                            {
                                break;
                            }
                            catch (Exception e)
                            {
                                NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.Warning, NotifySystem.NotifyConfigure.Save, $"{Path.GetFileName(noteFile.NoteFilePath)}:{noteFile.DataID} ({e.Message})", true, null, () => Utility.OpenAs(Path.GetDirectoryName(noteFilePath)));
                            }
                            finally
                            {
                                FastDB.Instance.SetEntryItem(entryPath, noteFile, dataIDs);
                            }
                        }
                    }
                }
                if (targetNoteFiles.Count > 0)
                {
                    FastDB.Instance.SetEntryItem(entryPath, null, Array.Empty<int>());
                }
            }
            if (targetNoteFiles.Count > 0)
            {
                foreach (var targetNoteFile in targetNoteFiles)
                {
                    NoteID512s[targetNoteFile.GetNoteID512()] = targetNoteFile;
                    NoteID128s[targetNoteFile.GetNoteID128()] = targetNoteFile;
                }
                if (tmpEntryItem != null)
                {
                    targetNoteFiles.Sort((x, y) =>
                    {
                        var level = x.LevelValue.CompareTo(y.LevelValue);
                        return level != 0 ? level : x.LevelTextValue.CompareTo(y.LevelTextValue);
                    });
                    tmpEntryItem.NoteFiles = targetNoteFiles.ToArray();
                    tmpEntryItem.CompatibleNoteFiles = tmpEntryItem.NoteFiles;
                    tmpEntryItem.WellNoteFiles = targetNoteFiles;
                    tmpEntryItem.NotePosition = Math.Min(DB.Instance.GetNotePosition(entryPath), targetNoteFiles.Count - 1);
                    _entryItems[tmpEntryItem.EntryItemID] = tmpEntryItem;
                    return [tmpEntryItem];
                }
                else
                {
                    foreach (var targetNoteFile in targetNoteFiles)
                    {
                        targetNoteFile.EntryItem.NoteFiles = [targetNoteFile];
                        targetNoteFile.EntryItem.CompatibleNoteFiles = targetNoteFiles.ToArray();
                        targetNoteFile.EntryItem.WellNoteFiles = targetNoteFile.EntryItem.NoteFiles.ToList();
                        targetNoteFile.EntryItem.NotePosition = 0;
                        _entryItems[targetNoteFile.EntryItem.EntryItemID] = targetNoteFile.EntryItem;
                    }
                    return targetNoteFiles.Select(targetNoteFile => targetNoteFile.EntryItem);
                }
            }
            else
            {
                return Array.Empty<EntryItem>();
            }

            EntryItem NewEntryItem() => new()
            {
                DefaultEntryItem = defaultEntryItem,
                ModifiedDate = Directory.GetLastWriteTime(entryPath),
                EntryPath = entryPath,
                EntryItemID = Interlocked.Increment(ref _lastEntryItemID)
            };
        }

        public void InitModeComponent()
        {
            ModeComponentValue.InitModeComponent();
            NotifyBPMText();
            NotifyHighestInputCountText();
            OnJudgmentMeterMillisModified();
            ViewModels.Instance.SiteContainerValue.CallSetModeComponent();
            ViewModels.Instance.WwwLevelValue.NotifyIsCompatible();
            HandleAutoComputer();
        }

        public void SaltEntryView()
        {
            var entryItems = EntryItems.ToArray();
            EntryItemValue = Utility.GetSaltedValue(entryItems
                .Skip(Array.FindIndex(entryItems, entryItem => !entryItem.IsLogical))
                .SkipLast(entryItems.Length - Array.FindLastIndex(entryItems, entryItem => !entryItem.IsLogical) - 1)
                .Except([EntryItemValue])
                .ToArray());
        }

        public void Want(EntryItem wantEntryItem = null)
        {
            _wantHandler.Stop();
            if (IsNoteFileMode)
            {
                UIHandler.Instance.HandleParallel(() =>
                {
                    var inputWant = Configure.Instance.InputWant;
                    var isNotWantInput = string.IsNullOrEmpty(inputWant);
                    var lastDefaultEntryItem = Configure.Instance.LastDefaultEntryItem;
                    var validEntryItems = new List<EntryItem>();
                    var lastDefaultEntryPath = lastDefaultEntryItem?.DefaultEntryPath ?? string.Empty;
                    if (lastDefaultEntryItem == null)
                    {
                        validEntryItems.Add(EntryItem.DefaultEntryConfigureEntryItem);
                        validEntryItems.AddRange(DefaultEntryItems.Select(defaultEntryItem => defaultEntryItem.GetEntryItem(true, Interlocked.Increment(ref _lastEntryItemID))).Where(entryItem => isNotWantInput || entryItem.Title.Contains(inputWant) || entryItem.Artist.Contains(inputWant)));
                        EntryItems = new(validEntryItems);
                        OnPropertyChanged(nameof(EntryItems));
                    }
                    else
                    {
                        var fitMode = Configure.Instance.FitModeValue;
                        var inputWantNoteVariety = Configure.Instance.InputWantNoteVariety;
                        var defaultEntryVariety = lastDefaultEntryItem.DefaultEntryVarietyValue;
                        var isTotalWantNoteVariety = Configure.Instance.IsTotalWantNoteVariety;
                        var hasEventNoteVariety = inputWantNoteVariety[(int)BaseNoteFile.NoteVariety.EventNote];
                        var isDefaultEntryNotFavorite = defaultEntryVariety != DefaultEntryItem.DefaultEntryVariety.Favorite;
                        var isDefaultEntryLogical = defaultEntryVariety == DefaultEntryItem.DefaultEntryVariety.Total || !isDefaultEntryNotFavorite;
                        var entryItems = _entryItems.Values.Where(entryItem =>
                        {
                            var defaultEntryItem = entryItem.DefaultEntryItem;
                            return defaultEntryItem?.DefaultEntryVarietyValue != DefaultEntryItem.DefaultEntryVariety.Net && (isDefaultEntryLogical || !string.IsNullOrEmpty(entryItem.EventNoteID) || lastDefaultEntryItem == defaultEntryItem);
                        }).ToArray();
                        var isTotalWantBanned = Configure.Instance.WantBannedValue == Configure.WantBanned.Total;
                        var inputWantInputMode = Configure.Instance.InputWantInputMode;
                        var inputWantLevel = Configure.Instance.InputWantLevel;
                        var IsNotWantLevel = !Configure.Instance.WantLevelTextValue;
                        var inputWantHandled = Configure.Instance.InputWantHandled;
                        var lowestWantLevelTextValue = Configure.Instance.LowestWantLevelTextValue;
                        var highestWantLevelTextValue = Configure.Instance.HighestWantLevelTextValue;
                        var isNotWantBPM = !Configure.Instance.WantBPM;
                        var lowestWantBPM = Configure.Instance.LowestWantBPM;
                        var highestWantBPM = Configure.Instance.HighestWantBPM;
                        var isNotWantAverageInputCount = !Configure.Instance.WantAverageInputCount;
                        var lowestWantAverageInputCount = Configure.Instance.LowestWantAverageInputCount;
                        var highestWantAverageInputCount = Configure.Instance.HighestWantAverageInputCount;
                        var isNotWantHighestInputCount = !Configure.Instance.WantHighestInputCount;
                        var lowestWantHighestInputCount = Configure.Instance.LowestWantHighestInputCount;
                        var highestWantHighestInputCount = Configure.Instance.HighestWantHighestInputCount;
                        var wantLevelIDs = Configure.Instance.WantLevelIDs;
                        var isWantLevelSystem = Configure.Instance.WantLevelSystem;
                        var isNotWantLevelItem = wantLevelIDs.Length == 0;
                        var isNotWantHellBPM = !Configure.Instance.WantHellBPM;
                        var levelID128s = new Dictionary<string, string>(LevelSystem.Instance.LevelID128s);
                        var levelID256s = new Dictionary<string, string>(LevelSystem.Instance.LevelID256s);
                        var levelID128NoteFiles = new Dictionary<string, LevelNoteFile>(LevelSystem.Instance.LevelID128NoteFiles);
                        var levelID256NoteFiles = new Dictionary<string, LevelNoteFile>(LevelSystem.Instance.LevelID256NoteFiles);
                        var logicalNoteFiles = new HashSet<BaseNoteFile>();
                        var titles = new List<string>();
                        var bpms = new List<double>();
                        var lengths = new List<double>();
                        var artists = new List<string>();
                        foreach (var entryItem in entryItems)
                        {
                            var isEntryItemEventNote = !string.IsNullOrEmpty(entryItem.EventNoteID);
                            var wellNoteFiles = entryItem.WellNoteFiles;
                            wellNoteFiles.Clear();
                            var noteFiles = entryItem.NoteFiles;
                            if (isEntryItemEventNote)
                            {
                                if (noteFiles.Any(noteFile => IsSatisfy(noteFile, true)))
                                {
                                    wellNoteFiles.AddRange(noteFiles);
                                    validEntryItems.Add(entryItem);
                                }
                            }
                            else
                            {
                                foreach (var noteFile in noteFiles)
                                {
                                    if (!logicalNoteFiles.Contains(noteFile) && IsSatisfy(noteFile, false))
                                    {
                                        wellNoteFiles.Add(noteFile);
                                        logicalNoteFiles.Add(noteFile);
                                    }
                                }
                                if (wellNoteFiles.Count > 0)
                                {
                                    if (!wellNoteFiles.Contains(entryItem.NoteFile))
                                    {
                                        entryItem.NotePosition = Array.IndexOf(noteFiles, wellNoteFiles.First());
                                    }
                                    validEntryItems.Add(entryItem);
                                }
                            }
                            if (wellNoteFiles.Count > 0)
                            {
                                var levelTextValue = 0.0;
                                var wantLevelID = string.Empty;
                                var highestInputCount = 0;
                                var averageInputCount = 0.0;
                                var totalNotes = 0;
                                DateTime? latestDate = null;
                                var handledCount = 0;
                                titles.Clear();
                                bpms.Clear();
                                lengths.Clear();
                                artists.Clear();
                                foreach (var wellNoteFile in wellNoteFiles)
                                {
                                    levelID128NoteFiles.Remove(wellNoteFile.GetNoteID128());
                                    levelID256NoteFiles.Remove(wellNoteFile.GetNoteID256());
                                    titles.Add(Utility.GetTitle(wellNoteFile.Title));
                                    bpms.Add(wellNoteFile.BPM);
                                    artists.Add(wellNoteFile.Artist);
                                    lengths.Add(wellNoteFile.Length);
                                    totalNotes = Math.Max(totalNotes, wellNoteFile.TotalNotes);
                                    highestInputCount = Math.Max(highestInputCount, wellNoteFile.HighestInputCount);
                                    averageInputCount = Math.Max(averageInputCount, wellNoteFile.AverageInputCount);
                                    if (!double.IsNaN(wellNoteFile.LevelTextValue))
                                    {
                                        levelTextValue = Math.Max(levelTextValue, wellNoteFile.LevelTextValue);
                                    }
                                    if (!isEntryItemEventNote)
                                    {
                                        if ((latestDate ?? DateTime.MinValue) < (wellNoteFile.LatestDate ?? DateTime.MinValue))
                                        {
                                            latestDate = wellNoteFile.LatestDate;
                                        }
                                        if (string.IsNullOrEmpty(wantLevelID) || LevelSystem.Instance.WantLevelIDEquality.Compare(wellNoteFile.WantLevelID, wantLevelID) > 0)
                                        {
                                            wantLevelID = wellNoteFile.WantLevelID;
                                        }
                                        handledCount += wellNoteFile.HandledCount;
                                    }
                                }
                                entryItem.Artist = Utility.GetFavoriteItem(artists);
                                entryItem.BPM = Utility.GetFavoriteItem(bpms);
                                entryItem.Length = Utility.GetFavoriteItem(lengths);
                                entryItem.TotalNotes = totalNotes;
                                entryItem.LevelTextValue = levelTextValue;
                                entryItem.HighestInputCount = highestInputCount;
                                if (!isEntryItemEventNote)
                                {
                                    entryItem.Title = Utility.GetFavoriteItem(titles);
                                    entryItem.LatestDate = latestDate;
                                    entryItem.HandledCount = handledCount;
                                    entryItem.WantLevelID = wantLevelID;
                                }
                                fitMode.SetFittedText(entryItem);
                            }
                        }
                        fitMode.Fit(validEntryItems);
                        if (validEntryItems.Count >= 2)
                        {
                            validEntryItems.Insert(0, EntryItem.SaltEntryItem);
                        }
                        validEntryItems.Insert(0, lastDefaultEntryItem.GetEntryItem(false, Interlocked.Increment(ref _lastEntryItemID)));
                        if (isWantLevelSystem)
                        {
                            validEntryItems.AddRange(levelID128NoteFiles.Values.Concat(levelID256NoteFiles.Values).Where(levelNoteFile => IsAtLeastSatisfy(levelNoteFile, false)).Distinct().GroupBy(arg => arg.WantLevelID).OrderBy(wantLevelID => wantLevelID.Key, LevelSystem.Instance.WantLevelIDEquality).Select(levelNoteFiles => new EntryItem
                            {
                                Title = levelNoteFiles.Key,
                                NoteFiles = levelNoteFiles.ToArray(),
                                WellNoteFiles = levelNoteFiles.Cast<BaseNoteFile>().ToList(),
                                IsLogical = true,
                                EntryPath = levelNoteFiles.Key,
                                LogicalVarietyValue = EntryItem.LogicalVariety.Level,
                                EntryItemID = Interlocked.Increment(ref _lastEntryItemID)
                            }));
                        }
                        EntryItems = new(validEntryItems);
                        OnPropertyChanged(nameof(EntryItems));

                        bool IsAtLeastSatisfy(BaseNoteFile noteFile, bool isEntryItemEventNote)
                        {
                            var noteID128 = noteFile.GetNoteID128();
                            var noteID256 = noteFile.GetNoteID256();
                            if (isWantLevelSystem && levelID128s.TryGetValue(noteID128, out var levelID128) && (isNotWantLevelItem || wantLevelIDs.Contains(levelID128)))
                            {
                                noteFile.WantLevelID = levelID128;
                            }
                            else if (isWantLevelSystem && levelID256s.TryGetValue(noteID256, out var levelID256) && (isNotWantLevelItem || wantLevelIDs.Contains(levelID256)))
                            {
                                noteFile.WantLevelID = levelID256;
                            }
                            else
                            {
                                noteFile.WantLevelID = string.Empty;
                            }
                            return (!isWantLevelSystem || isNotWantLevelItem || !string.IsNullOrEmpty(noteFile.WantLevelID)) &&
                            (isTotalWantNoteVariety || (hasEventNoteVariety ? isEntryItemEventNote || inputWantNoteVariety[(int)noteFile.NoteVarietyValue] : !isEntryItemEventNote && inputWantNoteVariety[(int)noteFile.NoteVarietyValue])) &&
                            (isNotWantInput ||
                                (noteFile.Title.ContainsCaselsss(inputWant)) ||
                                (noteFile.Artist.ContainsCaselsss(inputWant)) ||
                                (noteFile.LevelText.ContainsCaselsss(inputWant)) ||
                                (noteFile.Genre.ContainsCaselsss(inputWant)) ||
                                (noteFile.Tag.ContainsCaselsss(inputWant))
                            );
                        }

                        bool IsSatisfy(BaseNoteFile noteFile, bool isEntryItemEventNote)
                        {
                            var levelTextValue = noteFile.LevelTextValue;
                            var bpm = noteFile.BPM;
                            var averageInputCount = noteFile.AverageInputCount;
                            var highestInputCount = noteFile.HighestInputCount;
                            return IsAtLeastSatisfy(noteFile, isEntryItemEventNote) &&
                            (isDefaultEntryNotFavorite || noteFile.FavoriteEntryItems.Contains(lastDefaultEntryItem)) &&
                            (isDefaultEntryLogical || noteFile.DefaultEntryItem == lastDefaultEntryItem) &&
                            (isTotalWantBanned || !noteFile.IsBanned) &&
                            inputWantInputMode[(int)noteFile.InputMode] &&
                            inputWantLevel[(int)noteFile.LevelValue] &&
                            inputWantHandled[(int)noteFile.HandledValue] &&
                            (IsNotWantLevel || double.IsNaN(levelTextValue) || (lowestWantLevelTextValue <= levelTextValue && levelTextValue <= highestWantLevelTextValue)) &&
                            (isNotWantBPM || (lowestWantBPM <= bpm && bpm <= highestWantBPM)) &&
                            (isNotWantAverageInputCount || (lowestWantAverageInputCount <= averageInputCount && averageInputCount <= highestWantAverageInputCount)) &&
                            (isNotWantHighestInputCount || (lowestWantHighestInputCount <= highestInputCount && highestInputCount <= highestWantHighestInputCount)) &&
                            (isNotWantHellBPM || noteFile.IsHellBPM);
                        }
                    }

                    wantEntryItem ??= LastEntryItems.GetValueOrDefault(lastDefaultEntryPath);
                    EntryItemValue = EntryItems.Contains(wantEntryItem) ? wantEntryItem : EntryItems.ElementAtOrDefault(Configure.Instance.LastEntryItemPositions.GetValueOrDefault(lastDefaultEntryPath));
                });
            }
        }

        public void FlintNoteFile(string noteFilePath, int dataID, int levyingMeter)
        {
            var targetNoteFile = BaseNoteFile.GetNoteFiles(noteFilePath, null, new()
            {
                EntryPath = Path.GetDirectoryName(noteFilePath),
            }, dataID).Single();
            if (targetNoteFile != null)
            {
                targetNoteFile.Compile(Environment.TickCount);

                var defaultModeComponentValue = ModeComponentValue.Clone();
                ModeComponentValue.InitModeComponent();
                ModeComponentValue.ComputingValue = targetNoteFile;
                ModeComponentValue.CanModifyMultiplier = true;
                ModeComponentValue.CanModifyAudioMultiplier = true;
                SetComputingMode(new FlintCompute(targetNoteFile, defaultModeComponentValue, TwilightSystem.Instance.AvatarID, TwilightSystem.Instance.GetAvatarName(), levyingMeter));
            }
        }

        void Fade(Action onFade, DefaultCompute fadingViewComputer, bool isFadingComputerStable, int fadingViewLayer)
        {
            _fadeInHandler?.Stop();

            IsAvailable = false;

            FadingValue.Computer = fadingViewComputer;
            FadingValue.IsComputerStable = isFadingComputerStable;
            FadingValue.Layer = fadingViewLayer;

            var millis = BaseUI.Instance.FadingProperties[(int)ModeValue]?[FadingValue.Layer]?.Millis;
            var fadingCounter = Stopwatch.StartNew();
            new DispatcherTimer(QwilightComponent.StandardFrametime, DispatcherPriority.Render, (sender, e) =>
            {
                if (millis > 0)
                {
                    var millisValue = millis.Value;
                    FadingValue.Status = Math.Min(millisValue, fadingCounter.GetMillis()) / millisValue;
                }
                else
                {
                    FadingValue.Status = 1.0;
                }

                if (FadingValue.Status == 1.0)
                {
                    (sender as DispatcherTimer).Stop();

                    FadingValue.Layer = 0;
                    onFade();

                    var millis = BaseUI.Instance.FadingProperties[(int)ModeValue]?[FadingValue.Layer]?.Millis;
                    fadingCounter.Restart();
                    _fadeInHandler = new(QwilightComponent.StandardFrametime, DispatcherPriority.Render, (sender, e) =>
                    {
                        if (millis > 0)
                        {
                            var millisValue = millis.Value;
                            FadingValue.Status = 1.0 - Math.Min(millisValue, fadingCounter.GetMillis()) / millisValue;
                        }
                        else
                        {
                            FadingValue.Status = 0.0;
                        }

                        if (FadingValue.Status == 0.0)
                        {
                            (sender as DispatcherTimer).Stop();

                            IsAvailable = true;
                            StrongReferenceMessenger.Default.Send<PointZMaxView>();
                        }
                    }, UIHandler.Instance.Handler);
                }
            }, UIHandler.Instance.Handler);
        }

        public void InitMultiplierUnit()
        {
            if (HasNotInput())
            {
                switch (ModeValue)
                {
                    case Mode.NoteFile:
                        ModeComponentValue.InitMultiplierUnit();
                        break;
                    case Mode.Computing:
                        Computer.ModeComponentValue.InitMultiplierUnit();
                        break;
                }
            }
        }

        public void LowerMultiplier()
        {
            if (HasNotInput())
            {
                switch (ModeValue)
                {
                    case Mode.NoteFile:
                        if (ModeComponentValue.LowerMultiplier())
                        {
                            Utility.HandleUIAudio("Multiplier");
                            NotifyBPMText();
                        }
                        break;
                    case Mode.Computing:
                        Computer.LowerMultiplier();
                        break;
                }
            }
        }

        public void HigherMultiplier()
        {
            if (HasNotInput())
            {
                switch (ModeValue)
                {
                    case Mode.NoteFile:
                        if (ModeComponentValue.HigherMultiplier())
                        {
                            Utility.HandleUIAudio("Multiplier");
                            NotifyBPMText();
                        }
                        break;
                    case Mode.Computing:
                        Computer.HigherMultiplier();
                        break;
                }
            }
        }

        public void LowerAudioMultiplier()
        {
            if (HasNotInput())
            {
                switch (ModeValue)
                {
                    case Mode.NoteFile:
                        if (ModeComponentValue.LowerAudioMultiplier())
                        {
                            Utility.HandleUIAudio("Audio Multiplier");
                            NotifyBPMText();
                            NotifyHighestInputCountText();
                            HandleAutoComputer();
                            ViewModels.Instance.SiteContainerValue.CallSetModeComponent();
                        }
                        break;
                    case Mode.Computing:
                        Computer.LowerAudioMultiplier();
                        break;
                }
            }
        }

        public void HigherAudioMultiplier()
        {
            if (HasNotInput())
            {
                switch (ModeValue)
                {
                    case Mode.NoteFile:
                        if (ModeComponentValue.HigherAudioMultiplier())
                        {
                            Utility.HandleUIAudio("Audio Multiplier");
                            NotifyBPMText();
                            NotifyHighestInputCountText();
                            HandleAutoComputer();
                            ViewModels.Instance.SiteContainerValue.CallSetModeComponent();
                        }
                        break;
                    case Mode.Computing:
                        Computer.HigherAudioMultiplier();
                        break;
                }
            }
        }

        public void HigherDefaultSpinningMode()
        {
            if (HasNotInput())
            {
                Configure.Instance.DefaultSpinningModeValue = (Configure.DefaultSpinningMode)(((int)Configure.Instance.DefaultSpinningModeValue + 3) % 4);
            }
        }

        public void LowerDefaultSpinningMode()
        {
            if (HasNotInput())
            {
                Configure.Instance.DefaultSpinningModeValue = (Configure.DefaultSpinningMode)(((int)Configure.Instance.DefaultSpinningModeValue + 1) % 4);
            }
        }

        public void HandleModifyAutoMode()
        {
            if (HasNotInput())
            {
                Computer.ModifyAutoMode();
            }
        }

        public void HandleMediaMode()
        {
            if (HasNotInput())
            {
                Configure.Instance.Media = !Configure.Instance.Media;
            }
        }

        public void LowerEntryItem()
        {
            if (HasNotInput() && EntryItemPosition >= 1)
            {
                --EntryItemPosition;
                Utility.HandleUIAudio("Lower Entry Item");
                BaseUI.Instance.HandleEvent(BaseUI.EventItem.ModifyEntryItem);
            }
        }

        public void HigherEntryItem()
        {
            if (HasNotInput() && EntryItemPosition < EntryItems.Count - 1)
            {
                ++EntryItemPosition;
                Utility.HandleUIAudio("Higher Entry Item");
                BaseUI.Instance.HandleEvent(BaseUI.EventItem.ModifyEntryItem);
            }
        }

        public void LowerNoteFile()
        {
            if (HasNotInput() && EntryItemValue?.LowerNoteFile() == true)
            {
                NotifyNoteFile();
                Utility.HandleUIAudio("Lower Note File");
                BaseUI.Instance.HandleEvent(BaseUI.EventItem.ModifyNoteFile);
                DB.Instance.SetNotePosition(EntryItemValue);
            }
        }

        public void HigherNoteFile()
        {
            if (HasNotInput() && EntryItemValue?.HigherNoteFile() == true)
            {
                NotifyNoteFile();
                Utility.HandleUIAudio("Higher Note File");
                BaseUI.Instance.HandleEvent(BaseUI.EventItem.ModifyNoteFile);
                DB.Instance.SetNotePosition(EntryItemValue);
            }
        }

        public void HandleF1()
        {
            if (HasNotInput(ViewModels.Instance.AssistValue))
            {
                ViewModels.Instance.AssistValue.Toggle();
            }
        }

        public void HandleF5()
        {
            if (HasNotInput() && !IsDefaultEntryLoading)
            {
                var lastDefaultEntryItem = Configure.Instance.LastDefaultEntryItem;
                if (lastDefaultEntryItem != null)
                {
                    if (EntryItemValue != null && !EntryItemValue.IsLogical && string.IsNullOrEmpty(EntryItemValue.EventNoteID))
                    {
                        switch (StrongReferenceMessenger.Default.Send(new ViewAllowWindow
                        {
                            Text = string.Format(LanguageSystem.Instance.F5Notify1, lastDefaultEntryItem, Path.GetFileName(EntryItemValue.EntryPath)),
                            Data = MESSAGEBOX_STYLE.MB_YESNOCANCEL | MESSAGEBOX_STYLE.MB_ICONQUESTION | MESSAGEBOX_STYLE.MB_DEFBUTTON1
                        }).Response)
                        {
                            case MESSAGEBOX_RESULT.IDYES:
                                LoadDefaultEntryItem(true);
                                break;
                            case MESSAGEBOX_RESULT.IDNO:
                                LoadEntryItem(EntryItemValue.DefaultEntryItem, EntryItemValue.EntryPath);
                                break;
                        }
                    }
                    else
                    {
                        if (StrongReferenceMessenger.Default.Send(new ViewAllowWindow
                        {
                            Text = string.Format(LanguageSystem.Instance.F5Notify0, Configure.Instance.LastDefaultEntryItem),
                            Data = MESSAGEBOX_STYLE.MB_YESNO | MESSAGEBOX_STYLE.MB_ICONQUESTION | MESSAGEBOX_STYLE.MB_DEFBUTTON1
                        }) == MESSAGEBOX_RESULT.IDYES)
                        {
                            LoadDefaultEntryItem(true);
                        }
                    }
                }
            }
        }

        public void HandleF6()
        {
            if (IsComputingMode)
            {
                Utility.SetUIItem(Configure.Instance.UIItemValue, Configure.Instance.UIItemValue);
            }
            else
            {
                Utility.SetBaseUIItem(Configure.Instance.BaseUIItemValue, Configure.Instance.BaseUIItemValue);
            }
        }

        public void HandleF7()
        {
            if (HasNotInput(ViewModels.Instance.VoteValue))
            {
                ViewModels.Instance.VoteValue.Toggle();
            }
        }

        public void HandleF8()
        {
            if (TwilightSystem.Instance.IsEstablished)
            {
                ViewModels.Instance.SiteContainerValue.Toggle();
            }
        }

        public void HandleF9()
        {
            var targetNoteFile = ViewModels.Instance.NoteFileValue.IsOpened ? ViewModels.Instance.NoteFileValue.NoteFile : null;
            if (IsNoteFileMode || targetNoteFile != null)
            {
                var favoriteEntryViewModel = ViewModels.Instance.FavoriteEntryValue;
                if (!favoriteEntryViewModel.IsOpened)
                {
                    var favoriteEntryItems = Configure.Instance.DefaultEntryItems.Where(defaultEntryItem => defaultEntryItem.DefaultEntryVarietyValue == DefaultEntryItem.DefaultEntryVariety.Favorite).ToArray();
                    switch (favoriteEntryItems.Length)
                    {
                        case 0:
                            ViewModels.Instance.ModifyDefaultEntryValue.Open();
                            NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.Warning, NotifySystem.NotifyConfigure.Default, LanguageSystem.Instance.NotFavoritesF10);
                            break;
                        case 1:
                            var targetFavoriteEntryItem = favoriteEntryItems.Single();
                            DefaultEntryItem favoriteEntryItemModified = null;
                            var setFavorites = false;
                            if (targetNoteFile != null)
                            {
                                if (!targetNoteFile.IsLogical)
                                {
                                    setFavorites = !targetNoteFile.FavoriteEntryItems.Contains(targetFavoriteEntryItem);
                                    if (setFavorites)
                                    {
                                        if (targetNoteFile.FavoriteEntryItems.Add(targetFavoriteEntryItem))
                                        {
                                            favoriteEntryItemModified = targetFavoriteEntryItem;
                                            targetNoteFile.NotifyHasFavoriteEntryItem();
                                        }
                                    }
                                    else
                                    {
                                        if (targetNoteFile.FavoriteEntryItems.Remove(targetFavoriteEntryItem))
                                        {
                                            favoriteEntryItemModified = targetFavoriteEntryItem;
                                            targetNoteFile.NotifyHasFavoriteEntryItem();
                                        }
                                    }
                                    foreach (var favoriteEntryItem in targetNoteFile.FavoriteEntryItems)
                                    {
                                        favoriteEntryItem.FrontEntryPaths.Add(targetNoteFile.DefaultEntryItem.DefaultEntryPath);
                                    }
                                    DB.Instance.SetFavoriteEntry(targetNoteFile);
                                }
                            }
                            else
                            {
                                var noteFiles = EntryItemValue.NoteFiles;
                                setFavorites = !EntryItemValue.NoteFile.FavoriteEntryItems.Contains(targetFavoriteEntryItem);
                                foreach (var noteFile in noteFiles)
                                {
                                    if (!noteFile.IsLogical)
                                    {
                                        if (setFavorites)
                                        {
                                            if (noteFile.FavoriteEntryItems.Add(targetFavoriteEntryItem))
                                            {
                                                favoriteEntryItemModified = targetFavoriteEntryItem;
                                                noteFile.NotifyHasFavoriteEntryItem();
                                            }
                                        }
                                        else
                                        {
                                            if (noteFile.FavoriteEntryItems.Remove(targetFavoriteEntryItem))
                                            {
                                                favoriteEntryItemModified = targetFavoriteEntryItem;
                                                noteFile.NotifyHasFavoriteEntryItem();
                                            }
                                        }
                                        foreach (var favoriteEntryItem in noteFile.FavoriteEntryItems)
                                        {
                                            favoriteEntryItem.FrontEntryPaths.Add(noteFile.DefaultEntryItem.DefaultEntryPath);
                                        }
                                        DB.Instance.SetFavoriteEntry(noteFile);
                                    }
                                }
                            }
                            if (favoriteEntryItemModified != null)
                            {
                                NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.OK, NotifySystem.NotifyConfigure.Default, string.Format(setFavorites ? LanguageSystem.Instance.SetFavoritesF10 : LanguageSystem.Instance.WipeFavoritesF10, favoriteEntryItemModified.FavoriteEntryName), true, null, null, NotifySystem.SetFavoritesID);
                                if (favoriteEntryItemModified == Configure.Instance.LastDefaultEntryItem)
                                {
                                    Want();
                                }
                            }
                            break;
                        default:
                            UIHandler.Instance.HandleParallel(() =>
                            {
                                if (targetNoteFile != null)
                                {
                                    favoriteEntryViewModel.NoteFile = targetNoteFile;
                                    favoriteEntryViewModel.Mode = 0;
                                }
                                else
                                {
                                    favoriteEntryViewModel.EntryItem = EntryItemValue;
                                    favoriteEntryViewModel.Mode = 1;
                                }
                                favoriteEntryViewModel.Toggle();
                            });
                            break;
                    }
                }
            }
        }

        public void HandleF10()
        {
            if (TwilightSystem.Instance.IsSignedIn && HasNotInput(ViewModels.Instance.WwwLevelValue))
            {
                ViewModels.Instance.WwwLevelValue.Toggle();
            }
        }

        public void HandleF11()
        {
            if (HasNotInput(ViewModels.Instance.NotifyValue))
            {
                ViewModels.Instance.NotifyValue.Toggle();
            }
        }

        public void HandleF12() => StillSystem.Instance.Save();

        public void HandleESC()
        {
            if (IsAvailable)
            {
                switch (ModeValue)
                {
                    case Mode.NoteFile:
                        if (CloseOpenedViewModel())
                        {
                            return;
                        }
                        if (IsCommentMode)
                        {
                            DefaultCommentItem = null;
                            TwilightCommentItem = null;
                            PointEntryView();
                            return;
                        }
                        if (IsDefaultEntryLoading)
                        {
                            _setCancelDefaultEntryLoading.Cancel();
                            return;
                        }
                        if (System16Components.Is1221 || System16Components.Is1225)
                        {
                            StrongReferenceMessenger.Default.Send(new WipeSystem16View());
                            HandleAutoComputer();
                            return;
                        }
                        StrongReferenceMessenger.Default.Send(new Quit
                        {
                            ViewAllowWindow = true
                        });
                        break;
                    case Mode.Computing:
                        if (!CloseOpenedViewModel())
                        {
                            if (string.IsNullOrEmpty(UI.Instance.FaultText))
                            {
                                if (Computer.IsPausingWindowOpened)
                                {
                                    Computer.Unpause();
                                }
                                else
                                {
                                    Computer.Pause();
                                }
                            }
                            else
                            {
                                Computer.SetNoteFileMode();
                            }
                        }
                        break;
                    case Mode.Quit:
                        if (!CloseOpenedViewModel())
                        {
                            Computer.SetNoteFileMode();
                        }
                        break;
                }

                bool CloseOpenedViewModel()
                {
                    var zMaxValue = int.MinValue;
                    BaseViewModel zMaxViewModel = null;
                    foreach (var windowViewModel in ViewModels.Instance.WindowViewModels)
                    {
                        var zValue = windowViewModel.Zvalue;
                        if (windowViewModel.IsOpened && zMaxValue < zValue)
                        {
                            zMaxValue = zValue;
                            zMaxViewModel = windowViewModel;
                        }
                    }
                    if (zMaxViewModel != null)
                    {
                        zMaxViewModel.Close();
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
            }
        }

        public void HandleShift(bool isInput)
        {
            if (HasNotInput())
            {
                if (isInput)
                {
                    if (_wasLowerMillis && !IsCommentMode)
                    {
                        _wasLowerMillis = false;
                        var millis = Environment.TickCount;
                        if (_lastLowerMillis.HasValue)
                        {
                            if (millis - _lastLowerMillis.Value > 500)
                            {
                                _lastLowerMillis = millis;
                            }
                            else
                            {
                                InitModeComponent();
                                _lastLowerMillis = null;
                            }
                        }
                        else
                        {
                            _lastLowerMillis = millis;
                        }
                    }
                }
                else
                {
                    _wasLowerMillis = true;
                }
            }
        }

        public void HandleSpace()
        {
            if (HasNotInput(ViewModels.Instance.ConfigureValue))
            {
                switch (ModeValue)
                {
                    case Mode.NoteFile:
                    case Mode.Computing when Computer.IsPausingWindowOpened:
                    case Mode.Quit:
                        ViewModels.Instance.ConfigureValue.Toggle();
                        break;
                }
            }
        }

        public void HandleEnter()
        {
            if (HasNotInput())
            {
                switch (ModeValue)
                {
                    case Mode.Computing:
                        if (Computer.IsPausingWindowOpened)
                        {
                            switch (Configure.Instance.DefaultSpinningModeValue)
                            {
                                case Configure.DefaultSpinningMode.Unpause:
                                    Computer.Unpause();
                                    break;
                                case Configure.DefaultSpinningMode.Configure:
                                    ViewModels.Instance.ConfigureValue.Open();
                                    break;
                                case Configure.DefaultSpinningMode.Undo when Computer.CanUndo:
                                    Computer.SetUndo = true;
                                    break;
                                case Configure.DefaultSpinningMode.Stop:
                                    Computer.Unpause();
                                    Computer.SetNoteFileMode();
                                    break;
                            }
                        }
                        else
                        {
                            if (Computer.IsPassable && !Computer.IsPausing)
                            {
                                Computer.SetPass = true;
                            }
                            if (Computer.IsEscapable && !Computer.IsPausing)
                            {
                                Computer.SetEscape = true;
                            }
                        }
                        break;
                    case Mode.Quit:
                        Computer.SetNoteFileMode();
                        break;
                }
            }
        }

        public void HandleInitComment()
        {
            if (HasNotInput())
            {
                if (ViewModels.Instance.HasSiteViewModel(siteViewModel => siteViewModel.IsNetSite))
                {
                    NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.Warning, NotifySystem.NotifyConfigure.Default, LanguageSystem.Instance.DefaultComputeInNetSiteFault);
                }
                else
                {
                    IsCommentMode = false;
                    var defaultModeComponentValue = Computer.DefaultModeComponentValue ?? ModeComponentValue.Clone();
                    var defaultMultiplierValue = defaultModeComponentValue.MultiplierValue;
                    ModeComponentValue.CopyAs(Computer.ModeComponentValue, Computer.MyNoteFiles.First());
                    ModeComponentValue.CanModifyMultiplier = true;
                    ModeComponentValue.MultiplierValue = defaultMultiplierValue;
                    ModeComponentValue.CanModifyAudioMultiplier = true;
                    SetComputingMode(new(Computer.MyNoteFiles, null, defaultModeComponentValue, TwilightSystem.Instance.AvatarID, TwilightSystem.Instance.GetAvatarName(), Computer.WwwLevelDataValue, null, Computer.EventNoteEntryItem));
                }
            }
        }

        public void HandleViewComment()
        {
            if (HasNotInput())
            {
                if (Computer.IsPostableItemMode)
                {
                    NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.Warning, NotifySystem.NotifyConfigure.Default, LanguageSystem.Instance.PostableItemModeViewCommentFault);
                }
                else
                {
                    IsCommentMode = false;
                    var defaultModeComponentValue = Computer.DefaultModeComponentValue ?? ModeComponentValue.Clone();
                    ModeComponentValue.CopyAs(Computer.ModeComponentValue, Computer.MyNoteFiles.First(), false);
                    ModeComponentValue.SentMultiplier = Computer.TotallyLevyingMultiplier;
                    ModeComponentValue.CanModifyMultiplier = false;
                    ModeComponentValue.AudioMultiplier = Computer.TotallyLevyingAudioMultiplier;
                    ModeComponentValue.CanModifyAudioMultiplier = false;
                    SetComputingMode(new CommentCompute(Computer.MyNoteFiles, Computer.Comments, defaultModeComponentValue, Computer.AvatarID, Computer.AvatarName, null, Computer.EventNoteEntryItem, null, double.NaN));
                }
            }
        }

        public void HandleViewComment(NetItem netItem)
        {
            if (netItem.Comment != null && HasNotInput())
            {
                IsCommentMode = false;
                var defaultModeComponentValue = Computer.DefaultModeComponentValue ?? ModeComponentValue.Clone();
                ModeComponentValue.CopyAs(netItem.CommentItem.ModeComponentValue, Computer.NoteFile, false);
                SetComputingMode(new CommentCompute([Computer.NoteFile], [netItem.Comment], defaultModeComponentValue, netItem.AvatarID, netItem.AvatarName, null, null, null, Computer.LoopingCounter));
            }
        }

        public void Input<T>(T[][][] inputConfigure, T rawInput, bool isInput, DefaultCompute.InputFlag inputFlag = DefaultCompute.InputFlag.Not, byte inputPower = byte.MaxValue)
        {
            if (HasNotInput())
            {
                var inputMap = inputConfigure[(int)Computer.InputMode];
                for (var i = inputMap.Length - 1; i > 0; --i)
                {
                    if (Array.IndexOf(inputMap[i], rawInput) != -1)
                    {
                        Computer.Input(isInput ? i : -i, inputFlag, inputPower);
                    }
                }
            }
        }

        public void PostItem(int postableItemPosition)
        {
            if (HasNotInput())
            {
                Computer.PostItem(postableItemPosition);
            }
        }

        public void HandleUndo()
        {
            if (HasNotInput())
            {
                switch (ModeValue)
                {
                    case Mode.Computing:
                        if (Computer.CanUndo && Computer.IsPausingWindowOpened)
                        {
                            Computer.SetUndo = true;
                        }
                        break;
                    case Mode.Quit:
                        HandleInitComment();
                        break;
                }
            }
        }

        void MoveEntryView() => StrongReferenceMessenger.Default.Send(new MoveEntryView
        {
            Target = EntryItemValue
        });

        public void PointEntryView() => StrongReferenceMessenger.Default.Send<PointEntryView>();

        public void SetWPFViewVisibility()
        {
            IsWPFViewVisible = IsNoteFileMode || ViewModels.Instance.WindowViewModels.Any(windowViewModel => windowViewModel.IsOpened);
        }

        public async Task GetQwilight(bool isSilent)
        {
            var savingQwilightItem = new NotifyItem
            {
                Text = LanguageSystem.Instance.SavingQwilightContents,
                Variety = NotifySystem.NotifyVariety.Levying,
                OnStop = wipeTotal => false
            };
            try
            {
                var taehuiQwilight = await TwilightSystem.Instance.GetWwwParallel<JSON.TaehuiQwilight?>($"{QwilightComponent.TaehuiNetFE}/qwilight/qwilight.json").ConfigureAwait(false);
                if (taehuiQwilight.HasValue)
                {
                    var taehuiQwilightValue = taehuiQwilight.Value;
                    var date = Version.Parse(taehuiQwilightValue.date);
                    if (QwilightComponent.Date < date || QwilightComponent.HashText != taehuiQwilightValue.hash)
                    {
                        await SaveQwilight();
                    }
                    else if (!isSilent)
                    {
                        if (StrongReferenceMessenger.Default.Send(new ViewAllowWindow
                        {
                            Text = LanguageSystem.Instance.AlreadyLatestDate,
                            Data = MESSAGEBOX_STYLE.MB_YESNO | MESSAGEBOX_STYLE.MB_ICONQUESTION | MESSAGEBOX_STYLE.MB_DEFBUTTON1
                        }) == MESSAGEBOX_RESULT.IDYES)
                        {
                            await SaveQwilight();
                        }
                    }

                    async ValueTask SaveQwilight()
                    {
                        var data = ArrayPool<byte>.Shared.Rent(QwilightComponent.SendUnit);
                        try
                        {
                            UIHandler.Instance.HandleParallel(() => ViewModels.Instance.NotifyValue.NotifyItemCollection.Insert(0, savingQwilightItem));
                            NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.Info, NotifySystem.NotifyConfigure.NotSave, savingQwilightItem.Text);
                            var title = taehuiQwilightValue.title;
                            var tmpFileName = Path.GetTempFileName();
                            var target = $"{QwilightComponent.TaehuiNetFE}/qwilight/{title}";
                            using (var wwwClient = new HttpClient())
                            {
                                using (var hrm = await wwwClient.GetAsync(target, HttpCompletionOption.ResponseHeadersRead).ConfigureAwait(false))
                                {
                                    savingQwilightItem.MaxStatus = hrm.Content.Headers.ContentLength ?? 0L;
                                }
                                using (var fs = File.OpenWrite(tmpFileName))
                                using (var ws = await wwwClient.GetStreamAsync(target).ConfigureAwait(false))
                                {
                                    var length = 0;
                                    while ((length = await ws.ReadAsync(data.AsMemory(0, data.Length)).ConfigureAwait(false)) > 0)
                                    {
                                        await fs.WriteAsync(data.AsMemory(0, length)).ConfigureAwait(false);
                                        savingQwilightItem.Status += length;
                                    }
                                }
                            }
                            savingQwilightItem.Variety = NotifySystem.NotifyVariety.Quit;
                            savingQwilightItem.Text = LanguageSystem.Instance.SavedQwilightContents;
                            savingQwilightItem.OnStop = wipeTotal =>
                            {
                                if (!wipeTotal)
                                {
                                    Utility.WipeFile(_qwilightFileName);
                                }
                                return true;
                            };
                            NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.Info, NotifySystem.NotifyConfigure.NotSave, savingQwilightItem.Text);
                            var qwilightFileName = Path.ChangeExtension(tmpFileName, Path.GetExtension(title));
                            Utility.MoveFile(tmpFileName, qwilightFileName);
                            _qwilightFileName = qwilightFileName;
                        }
                        finally
                        {
                            ArrayPool<byte>.Shared.Return(data);
                        }
                    }
                }
            }
            catch (Exception e)
            {
                if (!isSilent)
                {
                    savingQwilightItem.Text = string.Format(LanguageSystem.Instance.GetQwilightFault, e.Message);
                    NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.Fault, NotifySystem.NotifyConfigure.NotSave, savingQwilightItem.Text);
                }
            }
        }

        public void WipeFavoriteEntry()
        {
            foreach (var entryItem in _entryItems.Values)
            {
                entryItem.WipeFavoriteEntry();
            }
        }

        public void LoadDefaultCommentItemCollection()
        {
            UIHandler.Instance.HandleParallel(DefaultCommentItemCollection.Clear);
            IsDefaultCommentLoading = IsNoteFileNotLogical;
            if (IsDefaultCommentLoading)
            {
                _loadDefaultCommentHandler.Stop();
                _loadDefaultCommentHandler.Start();
            }
        }

        public void LoadTwilightCommentItemCollection()
        {
            UIHandler.Instance.HandleParallel(TwilightCommentItemCollection.Clear);
            TwilightCommentTotalFavor = "👍";
            TwilightCommentFavor = null;
            TwilightCommentText0 = string.Empty;
            TwilightCommentText1 = string.Empty;
            IsTwilightCommentLoading = IsNoteFileNotLogical && !IsEntryItemBanned;
            if (IsTwilightCommentLoading)
            {
                _loadTwilightCommentHandler.Stop();
                _loadTwilightCommentHandler.Start();
            }
        }

        public async Task CallHOFAPI()
        {
            switch (Configure.Instance.HOFViewTabPosition)
            {
                case 3:
                    IsHOFLevelLoading = true;
                    var twilightWwwHOF = await TwilightSystem.Instance.GetWwwParallel<JSON.TwilightWwwHOF[]>($"{QwilightComponent.QwilightAPI}/hof/level");
                    if (twilightWwwHOF != null)
                    {
                        LevelHOFItemCollection.Clear();
                        foreach (var data in twilightWwwHOF)
                        {
                            LevelHOFItemCollection.Add(new(data, value => $"LV. {value}"));
                        }
                    }
                    IsHOFLevelLoading = false;
                    break;
                case 0:
                    switch (Configure.Instance.HOFViewTotalTabPosition)
                    {
                        case 0:
                            IsHOFTotalTotalLoading = true;
                            twilightWwwHOF = await TwilightSystem.Instance.GetWwwParallel<JSON.TwilightWwwHOF[]>($"{QwilightComponent.QwilightAPI}/hof/totalTotal");
                            if (twilightWwwHOF != null)
                            {
                                TotalTotalHOFItemCollection.Clear();
                                foreach (var data in twilightWwwHOF)
                                {
                                    TotalTotalHOFItemCollection.Add(new(data, value => value.ToString(LanguageSystem.Instance.HandledContents)));
                                }
                            }
                            IsHOFTotalTotalLoading = false;
                            break;
                        case 1:
                            IsHOFTotalHighestLoading = true;
                            twilightWwwHOF = await TwilightSystem.Instance.GetWwwParallel<JSON.TwilightWwwHOF[]>($"{QwilightComponent.QwilightAPI}/hof/totalHighest");
                            if (twilightWwwHOF != null)
                            {
                                TotalHighestHOFItemCollection.Clear();
                                foreach (var data in twilightWwwHOF)
                                {
                                    TotalHighestHOFItemCollection.Add(new(data, value => value.ToString(LanguageSystem.Instance.CountContents)));
                                }
                            }
                            IsHOFTotalHighestLoading = false;
                            break;
                        case 2:
                            IsHOFTotalStandLoading = true;
                            twilightWwwHOF = await TwilightSystem.Instance.GetWwwParallel<JSON.TwilightWwwHOF[]>($"{QwilightComponent.QwilightAPI}/hof/totalStand");
                            if (twilightWwwHOF != null)
                            {
                                TotalStandHOFItemCollection.Clear();
                                foreach (var data in twilightWwwHOF)
                                {
                                    TotalStandHOFItemCollection.Add(new(data, value => value.ToString(LanguageSystem.Instance.StandContents)));
                                }
                            }
                            IsHOFTotalStandLoading = false;
                            break;
                        case 3:
                            IsHOFTotalBandLoading = true;
                            twilightWwwHOF = await TwilightSystem.Instance.GetWwwParallel<JSON.TwilightWwwHOF[]>($"{QwilightComponent.QwilightAPI}/hof/totalBand");
                            if (twilightWwwHOF != null)
                            {
                                TotalBandHOFItemCollection.Clear();
                                foreach (var data in twilightWwwHOF)
                                {
                                    TotalBandHOFItemCollection.Add(new(data, value => value.ToString(LanguageSystem.Instance.BandContents)));
                                }
                            }
                            IsHOFTotalBandLoading = false;
                            break;
                    }
                    break;
                case 1:
                    switch (Configure.Instance.HOFViewAtTabPosition)
                    {
                        case 0:
                            IsHOFAtTotalLoading = true;
                            twilightWwwHOF = await TwilightSystem.Instance.GetWwwParallel<JSON.TwilightWwwHOF[]>($"{QwilightComponent.QwilightAPI}/hof/atTotal");
                            if (twilightWwwHOF != null)
                            {
                                AtTotalHOFItemCollection.Clear();
                                foreach (var data in twilightWwwHOF)
                                {
                                    AtTotalHOFItemCollection.Add(new(data, value => value.ToString(LanguageSystem.Instance.HandledContents)));
                                }
                            }
                            IsHOFAtTotalLoading = false;
                            break;
                        case 1:
                            IsHOFAtHighestLoading = true;
                            twilightWwwHOF = await TwilightSystem.Instance.GetWwwParallel<JSON.TwilightWwwHOF[]>($"{QwilightComponent.QwilightAPI}/hof/atHighest");
                            if (twilightWwwHOF != null)
                            {
                                AtHighestHOFItemCollection.Clear();
                                foreach (var data in twilightWwwHOF)
                                {
                                    AtHighestHOFItemCollection.Add(new(data, value => value.ToString(LanguageSystem.Instance.CountContents)));
                                }
                            }
                            IsHOFAtHighestLoading = false;
                            break;
                        case 2:
                            IsHOFAtStandLoading = true;
                            twilightWwwHOF = await TwilightSystem.Instance.GetWwwParallel<JSON.TwilightWwwHOF[]>($"{QwilightComponent.QwilightAPI}/hof/atStand");
                            if (twilightWwwHOF != null)
                            {
                                AtStandHOFItemCollection.Clear();
                                foreach (var data in twilightWwwHOF)
                                {
                                    AtStandHOFItemCollection.Add(new(data, value => value.ToString(LanguageSystem.Instance.StandContents)));
                                }
                            }
                            IsHOFAtStandLoading = false;
                            break;
                        case 3:
                            IsHOFAtBandLoading = true;
                            twilightWwwHOF = await TwilightSystem.Instance.GetWwwParallel<JSON.TwilightWwwHOF[]>($"{QwilightComponent.QwilightAPI}/hof/atBand");
                            if (twilightWwwHOF != null)
                            {
                                AtBandHOFItemCollection.Clear();
                                foreach (var data in twilightWwwHOF)
                                {
                                    AtBandHOFItemCollection.Add(new(data, value => value.ToString(LanguageSystem.Instance.BandContents)));
                                }
                            }
                            IsHOFAtBandLoading = false;
                            break;
                    }
                    break;
                case 2:
                    switch (Configure.Instance.HOFViewAbilityTabPosition)
                    {
                        case 0:
                            IsHOFAbility5KLoading = true;
                            twilightWwwHOF = await TwilightSystem.Instance.GetWwwParallel<JSON.TwilightWwwHOF[]>($"{QwilightComponent.QwilightAPI}/hof/ability/5K");
                            if (twilightWwwHOF != null)
                            {
                                Ability5KHOFItemCollection.Clear();
                                foreach (var data in twilightWwwHOF)
                                {
                                    Ability5KHOFItemCollection.Add(new(data, value => value.ToString("#,##0.## Point")));
                                }
                            }
                            IsHOFAbility5KLoading = false;
                            break;
                        case 1:
                            IsHOFAbility7KLoading = true;
                            twilightWwwHOF = await TwilightSystem.Instance.GetWwwParallel<JSON.TwilightWwwHOF[]>($"{QwilightComponent.QwilightAPI}/hof/ability/7K");
                            if (twilightWwwHOF != null)
                            {
                                Ability7KHOFItemCollection.Clear();
                                foreach (var data in twilightWwwHOF)
                                {
                                    Ability7KHOFItemCollection.Add(new(data, value => value.ToString("#,##0.## Point")));
                                }
                            }
                            IsHOFAbility7KLoading = false;
                            break;
                        case 2:
                            IsHOFAbility9KLoading = true;
                            twilightWwwHOF = await TwilightSystem.Instance.GetWwwParallel<JSON.TwilightWwwHOF[]>($"{QwilightComponent.QwilightAPI}/hof/ability/9K");
                            if (twilightWwwHOF != null)
                            {
                                Ability9KHOFItemCollection.Clear();
                                foreach (var data in twilightWwwHOF)
                                {
                                    Ability9KHOFItemCollection.Add(new(data, value => value.ToString("#,##0.## Point")));
                                }
                            }
                            IsHOFAbility9KLoading = false;
                            break;
                    }
                    break;
            }
        }

        public void NotifyNoteFile()
        {
            IsCommentMode = false;
            VerifyNoteFile(Configure.Instance.SetSalt ? ModeComponentValue.Salt : Environment.TickCount);
            LoadCommentItemCollection();
            TwilightSystem.Instance.SendParallel(Event.Types.EventID.SetSituation, new
            {
                situationValue = (int)UbuntuItem.UbuntuSituation.NoteFileMode,
                situationText = EntryItemValue?.NoteFile?.PlatformText ?? "Idle"
            });
        }

        public void LoadCommentItemCollection()
        {
            if (!BaseUI.Instance.HasCommentPoint || ViewModels.Instance.CommentValue.IsOpened)
            {
                switch (Configure.Instance.CommentViewTabPosition)
                {
                    case 0:
                        LoadDefaultCommentItemCollection();
                        break;
                    case 1:
                        LoadTwilightCommentItemCollection();
                        break;
                    case 2:
                        _ = CallHOFAPI();
                        break;
                }
            }
        }

        public void VerifyNoteFile(int salt)
        {
            if (EntryItemValue != null)
            {
                if (IsNoteFileNotLogical)
                {
                    var targetNoteFile = EntryItemValue.NoteFile;
                    if (!FastDB.Instance.GetNoteFile(targetNoteFile) || targetNoteFile.IsSalt)
                    {
                        try
                        {
                            targetNoteFile.Compile(salt);
                        }
                        catch
                        {
                        }
                    }
                    ViewModels.Instance.SiteContainerValue.CallSetNoteFile();
                    ModeComponentValue.ComputingValue = targetNoteFile;
                    ModeComponentValue.Salt = salt;
                    ModeComponentValue.SetAutoLowestLongNoteModify();
                    ModeComponentValue.SetAutoHighestLongNoteModify();
                    ModeComponentValue.SetAutoSetNotePutMillis();
                    OnJudgmentMeterMillisModified();
                    targetNoteFile.NotifyModel();
                }
                EntryItemValue.NotifyModel();
            }
            OnPropertyChanged(nameof(IsNoteFileNotLogical));
            OnPropertyChanged(nameof(IsNoteFileAvailable));
            OnPropertyChanged(nameof(HasAssistFile));
            OnPropertyChanged(nameof(LengthText));
            OnPropertyChanged(nameof(IsBPM1Visible));
            OnPropertyChanged(nameof(IsBPMVisible));
            OnPropertyChanged(nameof(IsEntryItemBanned));
            Configure.Instance.UIConfigureValue.NotifyInputMode();
            NotifyBPMText();
            NotifyHighestInputCountText();
            NotifyCanTwilightCommentary();
            NotifyCanTwilightFavor();
            NotifyCanSaveAsBundle();
            HandleAutoComputer();
        }

        public void OnJudgmentMeterMillisModified()
        {
            var noteFile = EntryItemValue?.NoteFile;
            if (noteFile != null)
            {
                if (Configure.Instance.AutoJudgmentMeterMillis)
                {
                    Configure.Instance.JudgmentMeterMillis = Math.Min
                    (
                        Math.Abs(Component.GetJudgmentMillis(Configure.Instance.AutoJudgmentMeterMillisItemValue.Judged, ModeComponentValue, noteFile.JudgmentStage, Component.LatestJudgmentModeDate, Component.LatestJudgmentMapDate, Component.LatestLongNoteAssistDate, 0)),
                        Math.Abs(Component.GetJudgmentMillis(Configure.Instance.AutoJudgmentMeterMillisItemValue.Judged, ModeComponentValue, noteFile.JudgmentStage, Component.LatestJudgmentModeDate, Component.LatestJudgmentMapDate, Component.LatestLongNoteAssistDate, 1))
                    );
                }
                noteFile.SetJudgmentMillisTexts(ModeComponentValue);
            }
        }

        public void NotifyBPMText() => OnPropertyChanged(nameof(BPMText));

        public void NotifyHighestInputCountText() => OnPropertyChanged(nameof(HighestInputCountText));

        public override void NotifyModel()
        {
            base.NotifyModel();
            StrongReferenceMessenger.Default.Send<SetFitInputs>();
            DrawingSystem.Instance.OnModified();
            BaseUI.Instance.NotifyModel();
            UI.Instance.NotifyModel();
            TwilightSystem.Instance.NotifyModel();
            Configure.Instance.NotifyModel();
            LanguageSystem.Instance.NotifyModel();
            ControllerSystem.Instance.NotifyModel();
            MIDISystem.Instance.NotifyModel();
            Configure.Instance.NotifyModel();
            AvatarTitleSystem.Instance.WipeAvatarTitles();
            ViewModels.Instance.ModifyModeComponentValue.SetModeComponentItems();
        }

        public void SetNoteFileMode(string faultText = null)
        {
            switch (ModeValue)
            {
                case Mode.Computing:
                    Fade(HandleImpl, Computer, true, 1);
                    break;
                case Mode.Quit:
                    Fade(HandleImpl, GetHandlingComputer(), true, 1);
                    break;
            }

            void HandleImpl()
            {
                if (Computer.DefaultModeComponentValue != null)
                {
                    ModeComponentValue.CopyAs(Computer.DefaultModeComponentValue, Computer);
                    ViewModels.Instance.SiteContainerValue.CallSetModeComponent();
                }
                ModeComponentValue.CanModifyMultiplier = true;
                ModeComponentValue.CanModifyAudioMultiplier = true;
                ModeValue = Mode.NoteFile;
                Computer.AtNoteFileMode();
                EntryItemValue = null;
                Want();
                if (!string.IsNullOrEmpty(faultText))
                {
                    NotifySystem.Instance.Notify(NotifySystem.NotifyVariety.Warning, NotifySystem.NotifyConfigure.Default, faultText);
                }
            }
        }

        public void SetComputingMode(DefaultCompute targetMigrateComputer)
        {
            switch (ModeValue)
            {
                case Mode.NoteFile:
                    Fade(HandleImpl, targetMigrateComputer, false, 1);
                    break;
                case Mode.Computing:
                    HandleImpl();
                    break;
                case Mode.Quit:
                    Fade(HandleImpl, GetHandlingComputer(), true, 1);
                    break;
            }

            void HandleImpl()
            {
                var defaultComputer = Computer;
                (AutoComputer ?? defaultComputer)?.Migrate(targetMigrateComputer);
                targetMigrateComputer.NoteFile.SetConfigure();
                Computer = targetMigrateComputer;
                Computer.HandleCompiler();
                ModeValue = Mode.Computing;
                defaultComputer?.Close();
                CloseAutoComputer();
            }
        }

        public void SetQuitMode(DefaultCompute defaultComputer)
        {
            switch (ModeValue)
            {
                case Mode.NoteFile:
                    Fade(HandleImpl, defaultComputer, false, 0);
                    break;
                case Mode.Computing:
                    Fade(HandleImpl, Computer, true, Computer.FadingViewLayer);
                    break;
                case Mode.Quit:
                    HandleImpl();
                    break;
            }

            void HandleImpl()
            {
                defaultComputer.SetJudgmentMillis();
                defaultComputer.AtQuitMode();
                defaultComputer.NotifyCompute();
                Computer = defaultComputer;
                ModeValue = Mode.Quit;
            }
        }

        public void SetDefaultEntryItems()
        {
            var defaultEntryItems = Configure.Instance.DefaultEntryItems;
            var lastDefaultEntryItem = Configure.Instance.LastDefaultEntryItem;
            Utility.SetUICollection(DefaultEntryItems, new List<DefaultEntryItem>(defaultEntryItems)
            {
                DefaultEntryItem.Total,
                DefaultEntryItem.EssentialBundle
            }, defaultEntryItem =>
            {
                if (defaultEntryItem == lastDefaultEntryItem)
                {
                    Configure.Instance.LastDefaultEntryItem = null;
                }
                WipeEntryItems(entryItem => defaultEntryItem == entryItem.DefaultEntryItem, noteFile => defaultEntryItem == noteFile.DefaultEntryItem, false);
                _alreadyLoadedDefaultEntryItems.Remove(defaultEntryItem);
            });
            DefaultEntryItems.Sort((x, y) =>
            {
                if ((x.DefaultEntryVarietyValue == DefaultEntryItem.DefaultEntryVariety.Default || x.DefaultEntryVarietyValue == DefaultEntryItem.DefaultEntryVariety.Favorite) && (y.DefaultEntryVarietyValue == DefaultEntryItem.DefaultEntryVariety.Default || y.DefaultEntryVarietyValue == DefaultEntryItem.DefaultEntryVariety.Favorite))
                {
                    return defaultEntryItems.IndexOf(x).CompareTo(defaultEntryItems.IndexOf(y));
                }
                else
                {
                    return x.DefaultEntryVarietyValue.CompareTo(y.DefaultEntryVarietyValue);
                }
            });
            LoadDefaultEntryItem(false);
        }

        public void WipeLoadedDefaultEntryItems()
        {
            _alreadyLoadedDefaultEntryItems.Clear();
            FastDB.Instance.WipeDefaultEntryItems();
        }

        public void HandleAutoComputer()
        {
            _autoComputerHandler.Stop();
            _autoComputerHandler.Start();
        }

        public void HandleAutoComputerImmediately(bool doTrailerAudio)
        {
            if (!ViewModels.Instance.VoteValue.IsOpened && !ViewModels.Instance.LevelVoteValue.IsOpened)
            {
                var targetNoteFile = EntryItemValue?.NoteFile;
                if (targetNoteFile != null)
                {
                    if (targetNoteFile.IsLogical)
                    {
                        CloseAutoComputer(targetNoteFile.LogicalAudioFileName);
                    }
                    else
                    {
                        if (Configure.Instance.AutoCompute)
                        {
                            if (AutoComputer == null || !targetNoteFile.IsContinuous(AutoComputer.NoteFile) || AutoComputer.SetStop)
                            {
                                NewAutoComputer(double.NaN, false);
                            }
                            else if (targetNoteFile != AutoComputer.NoteFile ||
                                !ModeComponentValue.IsCompatible(AutoComputer.CompatibleModeComponentValue) ||
                                Configure.Instance.LoopUnit != AutoComputer.Comment.LoopUnit ||
                                Configure.Instance.LoadedMedia != AutoComputer.LoadedMedia ||
                                Configure.Instance.BanalMedia != AutoComputer.BanalMedia || Configure.Instance.AlwaysBanalMedia != AutoComputer.AlwaysBanalMedia || Configure.Instance.BanalMediaFilePath != AutoComputer.BanalMediaFilePath ||
                                Configure.Instance.BanalFailedMedia != AutoComputer.BanalFailedMedia || Configure.Instance.AlwaysBanalFailedMedia != AutoComputer.AlwaysBanalFailedMedia || Configure.Instance.BanalFailedMediaFilePath != AutoComputer.BanalFailedMediaFilePath)
                            {
                                NewAutoComputer(AutoComputer.IsHandling && AutoComputer.TrailerAudioHandler.IsHandling != true ? AutoComputer.LoopingCounter : AutoComputer.LevyingWait, true);
                            }
                            else
                            {
                                if (Configure.Instance.AlwaysNotP2Position != AutoComputer.AlwaysNotP2Position ||
                                    Configure.Instance.InputMappingValue != AutoComputer.InputMappingValue)
                                {
                                    AutoComputer.SetUIMap();
                                }
                            }
                        }
                        else
                        {
                            CloseAutoComputer("Default");
                        }
                        targetNoteFile.SetConfigure();

                        void NewAutoComputer(double levyingWait, bool doMigrate)
                        {
                            ModeComponentValue.ComputingValue = targetNoteFile;
                            var autoComputer = new AutoCompute([targetNoteFile], null, TwilightSystem.Instance.AvatarID, TwilightSystem.Instance.GetAvatarName(), -1, levyingWait);
                            var targetMigrateComputer = doMigrate ? autoComputer : null;
                            var isMigrate = AutoComputer != null && targetMigrateComputer != null;
                            if (isMigrate)
                            {
                                AutoComputer.Migrate(targetMigrateComputer);
                            }
                            var trailerAudioFilePath = Utility.GetFilePath(targetNoteFile.TrailerAudioPath, Utility.FileFormatFlag.Audio);
                            if (doTrailerAudio && !string.IsNullOrEmpty(trailerAudioFilePath) && (!doMigrate || AutoComputer?.TrailerAudioHandler?.IsHandling != false))
                            {
                                CloseAutoComputer(null);
                                var trailerAudioHandler = autoComputer.TrailerAudioHandler;
                                if (!isMigrate)
                                {
                                    AudioSystem.Instance.HandleImmediately(trailerAudioFilePath, autoComputer, trailerAudioHandler, true);
                                }
                                trailerAudioHandler.IsHandling = true;
                                autoComputer.SetPause = true;
                            }
                            else
                            {
                                CloseAutoComputer(isMigrate ? null : "Default");
                            }
                            AutoComputer = autoComputer;
                            AutoComputer.HandleCompiler();
                            if (IsComputingMode)
                            {
                                Computer.Close();
                                Computer = AutoComputer;
                            }
                        }
                    }
                }
                else
                {
                    CloseAutoComputer("Default");
                }
            }
        }

        public void CloseAutoComputer(string audioFileName = null, int randomMillis = -1)
        {
            _autoComputerHandler.Stop();
            AutoComputer?.Close();
            AutoComputer = null;
            ClosePausableAudioHandler(audioFileName, randomMillis);
        }

        public void ClosePausableAudioHandler(string audioFileName = null, int randomMillis = -1)
        {
            var defaultAudioVarietyValue = Configure.Instance.DefaultAudioVarietyValue;
            if (randomMillis >= 0)
            {
                _randomMillis = randomMillis;
            }
            if (audioFileName == "Default")
            {
                if (System16Components.Is1221)
                {
                    audioFileName = Path.Combine(QwilightComponent.AssetsEntryPath, "System 16", "Audio", "1221.mp3");
                }
                else if (System16Components.Is1225)
                {
                    audioFileName = Path.Combine(QwilightComponent.AssetsEntryPath, "System 16", "Audio", "1225.mp3");
                }
                else
                {
                    switch (defaultAudioVarietyValue)
                    {
                        case Configure.DefaultAudioVariety.Not:
                            audioFileName = null;
                            break;
                        case Configure.DefaultAudioVariety.Favor:
                            audioFileName = AudioSystem.Instance.GetDefaultAudioFileName(_randomMillis);
                            break;
                        case Configure.DefaultAudioVariety.UI:
                            audioFileName = BaseUI.Instance.GetDefaultAudioFileName(_randomMillis);
                            break;
                    }
                }
            }
            if (_pausableAudioHandler.AudioFileName != audioFileName)
            {
                _pausableAudioHandler.SetAudioPosition((uint)(AudioSystem.Instance.Fade(_pausableAudioHandler, QwilightComponent.StandardWaitMillis)));

                if (IsNoteFileMode || audioFileName == null)
                {
                    _pausableAudioHandler.AudioFileName = audioFileName;
                    _pausableAudioHandler.IsPausing = audioFileName == null;
                    if (audioFileName != null)
                    {
                        if (AudioSystem.Instance.DefaultAudioItemMap.TryGetValue(audioFileName, out var audioItem))
                        {
                            AudioSystem.Instance.Handle(new()
                            {
                                AudioLevyingPosition = _pausableAudioHandler.GetAudioPosition(),
                                AudioItem = audioItem
                            }, AudioSystem.MainAudio, 1.0, false, _pausableAudioHandler, QwilightComponent.StandardWaitMillis);
                        }
                        else
                        {
                            Utility.HandleUIAudio(audioFileName, null, _pausableAudioHandler, QwilightComponent.StandardWaitMillis, AudioSystem.MainAudio);
                        }
                    }
                }
            }
        }
    }
}