MainWindowTabTutorials.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Navigation;
using Subtitle_draft_GMTPC.Services;

namespace Subtitle_draft_GMTPC
{
    public partial class MainWindow : Window
    {
        #region Tutorials - Fields

        private static readonly HttpClient _tutorialsHttpClient = CreateTutorialsHttpClient();

        private readonly Dictionary<string, TutorialDocumentDefinition> _tutorialDocuments = CreateTutorialDocuments();
        private readonly Dictionary<string, string> _tutorialHtmlCache = new Dictionary<string, string>();
        private TutorialMarkdownPopupWindow _tutorialMarkdownPopupWindow;
        private TutorialsWorkbookPopupWindow _tutorialsWorkbookPopupWindow;
        private bool _isTutorialsLoading = false;
        private bool _isTutorialShortcutsExcelLoading = false;
        private bool _tutorialsInitialized = false;
        private bool _tutorialShortcutsExcelInitialized = false;
        private bool _isTutorialSearchPanelOpen = false;
        private bool _tutorialSearchSuppressTextChanged = false;
        private string _tutorialSearchText = string.Empty;

        private const string TutorialShortcutsExcelGoogleSheetsUrl =
            "https://docs.google.com/spreadsheets/d/1N-OoZzvmfz5Qag48z3Yq9_L-JhY8WIn491QR-5vjb8A/edit?usp=sharing";

        #endregion

        #region Tutorials - Initialization

        private async void InitializeTutorialsAsync()
        {
            if (_tutorialsInitialized || _isTutorialsLoading)
            {
                return;
            }

            _tutorialsInitialized = true;
            await LoadAllTutorialDocumentsAsync(false);
        }

        private static HttpClient CreateTutorialsHttpClient()
        {
            var client = new HttpClient();
            client.Timeout = TimeSpan.FromSeconds(30);
            client.DefaultRequestHeaders.UserAgent.ParseAdd("SubtitleDraftGMTPC/1.0");
            return client;
        }

        private static Dictionary<string, TutorialDocumentDefinition> CreateTutorialDocuments()
        {
            return new Dictionary<string, TutorialDocumentDefinition>
            {
                {
                        "overview",
                        new TutorialDocumentDefinition(
                            "Overview",
                        Path.Combine("Tutorials", "Hướng dẫn", "1-gioi-thieu-so-luoc.md"))
                },
                {
                    "workflow",
                    new TutorialDocumentDefinition(
                        "Workflow",
                        Path.Combine("Tutorials", "Tutorial", "Profiles", "README.md"))
                },
                {
                    "shortcut-default",
                    new TutorialDocumentDefinition(
                        "Default Shortcuts",
                        Path.Combine("Tutorials", "Shortcuts", "shortcut MMT - Vietnamese.md"))
                },
                {
                    "shortcut-translate-new",
                    new TutorialDocumentDefinition(
                        "Translate - New Subtitle",
                        Path.Combine("Tutorials", "Tutorial", "Profiles", "profile-01-translate-new-subtitle.md"))
                },
                {
                    "shortcut-translate-existing",
                    new TutorialDocumentDefinition(
                        "Translate - Existing Subtitle",
                        Path.Combine("Tutorials", "Tutorial", "Profiles", "profile-02-translate-existing-subtitle.md"))
                },
                {
                    "shortcut-edit-translated",
                    new TutorialDocumentDefinition(
                        "Edit Translated Subtitle",
                        Path.Combine("Tutorials", "Tutorial", "Profiles", "profile-03-edit-translated.md"))
                },
                {
                    "shortcut-quick-checker",
                    new TutorialDocumentDefinition(
                        "Quick Checker",
                        Path.Combine("Tutorials", "Tutorial", "Profiles", "profile-04-quick-checker.md"))
                }
            };
        }

        #endregion

        #region Tutorials - Load

        private async Task LoadAllTutorialDocumentsAsync(bool forceRefresh)
        {
            if (_isTutorialsLoading)
            {
                return;
            }

            try
            {
                _isTutorialsLoading = true;
                BtnRefreshTutorials.IsEnabled = false;
                TxtTutorialsStatus.Text = "Đang tải tài liệu từ GitHub...";

                ShowTutorialLoadingState();

                foreach (var pair in _tutorialDocuments)
                {
                    if (forceRefresh)
                    {
                        _tutorialHtmlCache.Remove(pair.Key);
                    }

                    var browser = GetTutorialBrowser(pair.Key);
                    if (browser == null)
                    {
                        continue;
                    }

                    var html = await GetTutorialHtmlAsync(pair.Key, pair.Value, forceRefresh);
                    browser.NavigateToString(html);
                }

                TxtTutorialsStatus.Text = string.Format(
                    "Đã tải {0} tài liệu từ Tutorials lúc {1:HH:mm:ss}.",
                    _tutorialDocuments.Count,
                    DateTime.Now);

                await LoadTutorialShortcutsExcelAsync(forceRefresh);
                UpdateTutorialMarkdownPopupForCurrentSelection(forceRefresh);

                ReapplyTutorialSearchToCurrentBrowser();
            }
            catch (Exception ex)
            {
                TxtTutorialsStatus.Text = "Không thể tải tutorials từ GitHub.";
                ShowTutorialErrorState(ex.Message);
            }
            finally
            {
                BtnRefreshTutorials.IsEnabled = true;
                _isTutorialsLoading = false;
            }
        }

        private async Task<string> GetTutorialHtmlAsync(string key, TutorialDocumentDefinition document, bool forceRefresh)
        {
            if (!forceRefresh && _tutorialHtmlCache.TryGetValue(key, out var cachedHtml))
            {
                return cachedHtml;
            }

            var markdown = await LoadTutorialMarkdownAsync(document, forceRefresh);
            var html = GitHubMarkdownHtmlRenderer.RenderDocument(markdown, document.SourceUrl, document.Title);
            _tutorialHtmlCache[key] = html;
            return html;
        }

        private async Task<string> LoadTutorialMarkdownAsync(TutorialDocumentDefinition document, bool forceRefresh)
        {
            try
            {
                return await LoadTutorialMarkdownFromGitHubAsync(document, forceRefresh);
            }
            catch
            {
                var filePath = document.GetFullPath();
                if (!File.Exists(filePath))
                {
                    throw;
                }

                using (var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
                using (var reader = new StreamReader(stream, true))
                {
                    return await reader.ReadToEndAsync();
                }
            }
        }

        private async Task<string> LoadTutorialMarkdownFromGitHubAsync(TutorialDocumentDefinition document, bool forceRefresh)
        {
            var requestUrl = document.RawSourceUrl + (forceRefresh ? "?t=" + DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() : string.Empty);
            using (var response = await _tutorialsHttpClient.GetAsync(requestUrl))
            {
                response.EnsureSuccessStatusCode();
                return await response.Content.ReadAsStringAsync();
            }
        }

        private async Task LoadTutorialShortcutsExcelAsync(bool forceRefresh)
        {
            if (_isTutorialShortcutsExcelLoading)
            {
                return;
            }

            if (_tutorialShortcutsExcelInitialized && !forceRefresh)
            {
                return;
            }

            try
            {
                _isTutorialShortcutsExcelLoading = true;
                TxtTutorialsExcelStatus.Text = "Đang tải workbook Google Sheets vào trong app...";

                var popup = EnsureTutorialsWorkbookPopupWindow();
                popup.WorkbookUrl = TutorialShortcutsExcelGoogleSheetsUrl;
                if (forceRefresh)
                {
                    popup.ReloadWorkbook();
                }

                _tutorialShortcutsExcelInitialized = true;
                TxtTutorialsExcelStatus.Text = "Workbook Google Sheets đã sẵn sàng.";
            }
            catch (Exception ex)
            {
                TxtTutorialsExcelStatus.Text = "Không thể tải workbook Excel.";
                MessageBox.Show("Không thể tải workbook Excel: " + ex.Message, "Lỗi", MessageBoxButton.OK, MessageBoxImage.Error);
            }
            finally
            {
                _isTutorialShortcutsExcelLoading = false;
            }
        }

        private void ShowTutorialLoadingState()
        {
            foreach (var pair in _tutorialDocuments)
            {
                var browser = GetTutorialBrowser(pair.Key);
                if (browser == null)
                {
                    continue;
                }

                browser.NavigateToString(BuildTutorialPlaceholderHtml(pair.Value.Title, "Đang tải nội dung từ Tutorials..."));
            }

            if (_tutorialMarkdownPopupWindow != null && _tutorialMarkdownPopupWindow.IsVisible)
            {
                _tutorialMarkdownPopupWindow.ShowHtml("Tutorials", BuildTutorialPlaceholderHtml("Tutorials", "Đang tải nội dung từ Tutorials..."));
            }
        }

        private void ShowTutorialErrorState(string message)
        {
            foreach (var pair in _tutorialDocuments)
            {
                var browser = GetTutorialBrowser(pair.Key);
                if (browser == null)
                {
                    continue;
                }

                browser.NavigateToString(BuildTutorialPlaceholderHtml(pair.Value.Title, "Lỗi tải dữ liệu: " + message));
            }

            if (_tutorialMarkdownPopupWindow != null && _tutorialMarkdownPopupWindow.IsVisible)
            {
                _tutorialMarkdownPopupWindow.ShowHtml("Tutorials", BuildTutorialPlaceholderHtml("Tutorials", "Lỗi tải dữ liệu: " + message));
            }
        }

        private static string BuildTutorialPlaceholderHtml(string title, string message)
        {
            return "<!DOCTYPE html><html><head><meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge\" /><meta charset=\"utf-8\" />"
                + "<style>body{margin:0;background:#16181d;color:#e6edf3;font-family:'Segoe UI',Arial,sans-serif;display:flex;align-items:center;justify-content:center;min-height:100vh;}div{max-width:720px;padding:24px;text-align:center;}h2{margin:0 0 12px;color:#fff;}p{margin:0;color:#aeb8c4;line-height:1.6;}</style>"
                + "</head><body><div><h2>" + System.Net.WebUtility.HtmlEncode(title) + "</h2><p>" + System.Net.WebUtility.HtmlEncode(message) + "</p></div></body></html>";
        }

        private WebBrowser GetTutorialBrowser(string key)
        {
            switch (key)
            {
                case "overview":
                    return BrowserTutorialOverview;
                case "workflow":
                    return BrowserTutorialWorkflow;
                default:
                    return null;
            }
        }

        #endregion

        #region Tutorials - Events

        private async void BtnRefreshTutorials_Click(object sender, RoutedEventArgs e)
        {
            await LoadAllTutorialDocumentsAsync(true);
        }

        private async void RefreshTutorialsFromLocalFolder()
        {
            await LoadAllTutorialDocumentsAsync(true);
        }

        private async void RefreshTutorialsFromGitHub()
        {
            await LoadAllTutorialDocumentsAsync(true);
        }

        private void TutorialsTabControl_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (!IsLoaded || _isTutorialsLoading)
            {
                return;
            }

            UpdateTutorialSearchModeForCurrentTab();
            TxtTutorialsStatus.Text = "Đang xem: " + GetCurrentTutorialTitle();
            if (IsShortcutsExcelTabActive())
            {
                OpenTutorialsWorkbookPopup();
            }
            else if (IsOverviewTabActive())
            {
                HideTutorialMarkdownPopup();
            }
            else
            {
                OpenTutorialMarkdownPopupForCurrentSelection();
            }
            ReapplyTutorialSearchToCurrentBrowser();
        }

        private void TutorialBrowser_LoadCompleted(object sender, NavigationEventArgs e)
        {
            ReapplyTutorialSearchToCurrentBrowser();
        }

        private void TutorialBrowser_Navigating(object sender, NavigatingCancelEventArgs e)
        {
            if (e.Uri == null)
            {
                return;
            }

            var target = e.Uri.AbsoluteUri;
            if (string.Equals(target, "about:blank", StringComparison.OrdinalIgnoreCase))
            {
                return;
            }

            e.Cancel = true;

            try
            {
                Process.Start(new ProcessStartInfo(target)
                {
                    UseShellExecute = true
                });
            }
            catch (Exception ex)
            {
                MessageBox.Show("Không thể mở liên kết: " + ex.Message, "Lỗi", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        private void BtnToggleTutorialSearch_Click(object sender, RoutedEventArgs e)
        {
            ToggleTutorialSearchPanel();
        }

        private void BtnOpenTutorialExcelPopup_Click(object sender, RoutedEventArgs e)
        {
            OpenTutorialsWorkbookPopup();
        }

        private void TxtTutorialSearchBox_TextChanged(object sender, TextChangedEventArgs e)
        {
            if (_tutorialSearchSuppressTextChanged)
            {
                return;
            }

            _tutorialSearchText = TxtTutorialSearchBox.Text;
            ApplyTutorialSearch(resetIndex: true);
        }

        private void TxtTutorialSearchBox_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Enter)
            {
                e.Handled = true;
                if (Keyboard.Modifiers.HasFlag(ModifierKeys.Shift))
                {
                    NavigateTutorialSearch(false);
                }
                else
                {
                    NavigateTutorialSearch(true);
                }
            }
            else if (e.Key == Key.Escape)
            {
                e.Handled = true;
                CloseTutorialSearchPanel();
            }
        }

        private void BtnTutorialSearchPrev_Click(object sender, RoutedEventArgs e)
        {
            NavigateTutorialSearch(false);
        }

        private void BtnTutorialSearchNext_Click(object sender, RoutedEventArgs e)
        {
            NavigateTutorialSearch(true);
        }

        private void BtnTutorialSearchClear_Click(object sender, RoutedEventArgs e)
        {
            ClearTutorialSearch();
        }

        private void TutorialSearchOption_Changed(object sender, RoutedEventArgs e)
        {
            ApplyTutorialSearch(resetIndex: true);
        }

        private void UpdateTutorialSearchModeForCurrentTab()
        {
            var excelActive = IsShortcutsExcelTabActive();
            if (ChkTutorialRegex != null)
            {
                ChkTutorialRegex.IsEnabled = !excelActive;
                if (excelActive && ChkTutorialRegex.IsChecked == true)
                {
                    ChkTutorialRegex.IsChecked = false;
                }
            }
        }

        private void OpenTutorialMarkdownPopupForCurrentSelection()
        {
            var selectedKey = GetCurrentTutorialDocumentKey();
            if (string.IsNullOrWhiteSpace(selectedKey)
                || string.Equals(selectedKey, "overview", StringComparison.OrdinalIgnoreCase)
                || !_tutorialDocuments.ContainsKey(selectedKey))
            {
                HideTutorialMarkdownPopup();
                return;
            }

            var document = _tutorialDocuments[selectedKey];
            var popup = EnsureTutorialMarkdownPopupWindow();
            popup.Show();
            popup.Activate();
            popup.Topmost = true;
            popup.Topmost = false;

            var html = _tutorialHtmlCache.ContainsKey(selectedKey)
                ? _tutorialHtmlCache[selectedKey]
                : BuildTutorialPlaceholderHtml(document.Title, "Đang tải nội dung từ Tutorials...");

            popup.ShowHtml(document.Title, html);
        }

        private void UpdateTutorialMarkdownPopupForCurrentSelection(bool forceRefresh)
        {
            if (_tutorialMarkdownPopupWindow == null || !_tutorialMarkdownPopupWindow.IsVisible)
            {
                return;
            }

            var selectedKey = GetCurrentTutorialDocumentKey();
            if (string.IsNullOrWhiteSpace(selectedKey) || !_tutorialDocuments.ContainsKey(selectedKey))
            {
                return;
            }

            var document = _tutorialDocuments[selectedKey];
            string html;
            if (forceRefresh || !_tutorialHtmlCache.TryGetValue(selectedKey, out html))
            {
                html = BuildTutorialPlaceholderHtml(document.Title, "Đang tải nội dung từ Tutorials...");
            }

            _tutorialMarkdownPopupWindow.ShowHtml(document.Title, html);
        }

        private TutorialMarkdownPopupWindow EnsureTutorialMarkdownPopupWindow()
        {
            if (_tutorialMarkdownPopupWindow == null)
            {
                _tutorialMarkdownPopupWindow = new TutorialMarkdownPopupWindow
                {
                    Owner = this
                };
                _tutorialMarkdownPopupWindow.Closed += TutorialMarkdownPopupWindow_Closed;
            }

            return _tutorialMarkdownPopupWindow;
        }

        private string GetCurrentTutorialDocumentKey()
        {
            var selectedMainTab = TutorialsTabControl.SelectedItem as TabItem;
            if (selectedMainTab == null)
            {
                return "overview";
            }

            var mainHeader = Convert.ToString(selectedMainTab.Header);
            if (string.Equals(mainHeader, "Workflow", StringComparison.OrdinalIgnoreCase))
            {
                return "workflow";
            }

            return "overview";
        }

        private void TutorialMarkdownPopupWindow_Closed(object sender, System.EventArgs e)
        {
            if (ReferenceEquals(sender, _tutorialMarkdownPopupWindow))
            {
                _tutorialMarkdownPopupWindow = null;
            }
        }

        private void HideTutorialMarkdownPopup()
        {
            if (_tutorialMarkdownPopupWindow != null && _tutorialMarkdownPopupWindow.IsVisible)
            {
                _tutorialMarkdownPopupWindow.Hide();
            }
        }

        private string GetCurrentTutorialTitle()
        {
            if (TutorialsTabControl.SelectedItem == null)
            {
                return "Tutorials";
            }

            var selectedMainTab = TutorialsTabControl.SelectedItem as TabItem;
            if (selectedMainTab == null)
            {
                return "Tutorials";
            }

            return Convert.ToString(selectedMainTab.Header);
        }

        private bool IsTutorialsTabActive()
        {
            var selectedTab = MainTabControl.SelectedItem as TabItem;
            if (selectedTab == null)
            {
                return false;
            }

            return string.Equals(Convert.ToString(selectedTab.Header), "📚 Tutorials", StringComparison.OrdinalIgnoreCase);
        }

        #endregion

        #region Tutorials - Search

        private void ToggleTutorialSearchPanel()
        {
            if (_isTutorialSearchPanelOpen)
            {
                CloseTutorialSearchPanel();
                return;
            }

            _isTutorialSearchPanelOpen = true;
            TutorialSearchPanel.Visibility = Visibility.Visible;
            BtnToggleTutorialSearch.Content = "✕ Đóng tìm kiếm";
            TxtTutorialSearchBox.Focus();
            TxtTutorialSearchBox.SelectAll();
            ApplyTutorialSearch(resetIndex: false);
        }

        private void CloseTutorialSearchPanel()
        {
            _isTutorialSearchPanelOpen = false;
            TutorialSearchPanel.Visibility = Visibility.Collapsed;
            BtnToggleTutorialSearch.Content = "🔎 Tìm trong Tutorials";
        }

        private async void ClearTutorialSearch()
        {
            _tutorialSearchSuppressTextChanged = true;
            TxtTutorialSearchBox.Text = string.Empty;
            _tutorialSearchSuppressTextChanged = false;
            _tutorialSearchText = string.Empty;
            TxtTutorialSearchStatus.Text = string.Empty;
            await ClearTutorialSearchAsync();
            TxtTutorialSearchBox.Focus();
        }

        private async void NavigateTutorialSearch(bool forward)
        {
            if (string.IsNullOrWhiteSpace(TxtTutorialSearchBox.Text))
            {
                TxtTutorialSearchStatus.Text = "Nhập từ khóa cần tìm.";
                return;
            }

            _tutorialSearchText = TxtTutorialSearchBox.Text;
            if (IsShortcutsExcelTabActive())
            {
                OpenTutorialsWorkbookPopup();
                TxtTutorialSearchStatus.Text = "Workbook Excel đang mở bằng trình duyệt; hãy dùng Ctrl+F của trình duyệt để tìm.";
                return;
            }
            var result = InvokeTutorialSearchScript(forward ? "tutorialSearchNext" : "tutorialSearchPrev");
            UpdateTutorialSearchStatus(result);
        }

        private async void ApplyTutorialSearch(bool resetIndex)
        {
            _tutorialSearchText = TxtTutorialSearchBox.Text;

            if (string.IsNullOrWhiteSpace(_tutorialSearchText))
            {
                TxtTutorialSearchStatus.Text = string.Empty;
                await ClearTutorialSearchAsync();
                return;
            }

            if (IsShortcutsExcelTabActive())
            {
                OpenTutorialsWorkbookPopup();
                TxtTutorialSearchStatus.Text = "Workbook Excel đang mở bằng trình duyệt; hãy dùng Ctrl+F của trình duyệt để tìm.";
                return;
            }
            var result = InvokeTutorialSearchScript(
                "tutorialSearchApply",
                _tutorialSearchText,
                ChkTutorialMatchCase.IsChecked == true,
                ChkTutorialWholeWord.IsChecked == true,
                ChkTutorialRegex.IsChecked == true,
                resetIndex);

            UpdateTutorialSearchStatus(result);
        }

        private void ReapplyTutorialSearchToCurrentBrowser()
        {
            if (!_isTutorialSearchPanelOpen)
            {
                return;
            }

            ApplyTutorialSearch(resetIndex: true);
        }

        private Task ClearTutorialSearchAsync()
        {
            return Task.CompletedTask;
        }

        private string InvokeTutorialSearchScript(string scriptName, params object[] args)
        {
            try
            {
                var browser = GetCurrentTutorialBrowser();
                if (browser?.Document == null)
                {
                    return null;
                }

                var result = browser.InvokeScript(scriptName, args);
                return result != null ? Convert.ToString(result) : null;
            }
            catch
            {
                return null;
            }
        }

        private void UpdateTutorialSearchStatus(string result)
        {
            if (string.IsNullOrWhiteSpace(_tutorialSearchText))
            {
                TxtTutorialSearchStatus.Text = string.Empty;
                return;
            }

            if (string.IsNullOrWhiteSpace(result))
            {
                TxtTutorialSearchStatus.Text = "Chưa sẵn sàng tìm trong tài liệu này.";
                return;
            }

            var parts = result.Split(new[] { '|' }, 4);
            if (parts.Length == 0)
            {
                TxtTutorialSearchStatus.Text = "Không đọc được kết quả tìm kiếm.";
                return;
            }

            if (string.Equals(parts[0], "error", StringComparison.OrdinalIgnoreCase))
            {
                TxtTutorialSearchStatus.Text = parts.Length > 1 ? "Regex lỗi: " + parts[1] : "Regex lỗi.";
                return;
            }

            if (!string.Equals(parts[0], "ok", StringComparison.OrdinalIgnoreCase) || parts.Length < 4)
            {
                TxtTutorialSearchStatus.Text = "Không đọc được kết quả tìm kiếm.";
                return;
            }

            int total;
            int current;
            if (!int.TryParse(parts[1], out total) || !int.TryParse(parts[2], out current))
            {
                TxtTutorialSearchStatus.Text = "Không đọc được kết quả tìm kiếm.";
                return;
            }

            var contextTitle = parts[3];
            TxtTutorialSearchStatus.Text = total == 0
                ? "Không có kết quả trong " + contextTitle + "."
                : string.Format("{0}/{1} kết quả trong {2}", current, total, contextTitle);
        }

        private WebBrowser GetCurrentTutorialBrowser()
        {
            if (_tutorialMarkdownPopupWindow != null
                && _tutorialMarkdownPopupWindow.IsVisible
                && !IsShortcutsExcelTabActive()
                && !IsOverviewTabActive())
            {
                return _tutorialMarkdownPopupWindow.Browser;
            }

            var selectedMainTab = TutorialsTabControl.SelectedItem as TabItem;
            if (selectedMainTab == null)
            {
                return BrowserTutorialOverview;
            }

            var mainHeader = Convert.ToString(selectedMainTab.Header);
            if (string.Equals(mainHeader, "Workflow", StringComparison.OrdinalIgnoreCase))
            {
                return BrowserTutorialWorkflow;
            }

            return BrowserTutorialOverview;
        }

        private bool IsShortcutsExcelTabActive()
        {
            var selectedMainTab = TutorialsTabControl.SelectedItem as TabItem;
            if (selectedMainTab == null)
            {
                return false;
            }

            return string.Equals(Convert.ToString(selectedMainTab.Header), "Shortcuts Excel", StringComparison.OrdinalIgnoreCase);
        }

        private bool IsOverviewTabActive()
        {
            var selectedMainTab = TutorialsTabControl.SelectedItem as TabItem;
            if (selectedMainTab == null)
            {
                return false;
            }

            return string.Equals(Convert.ToString(selectedMainTab.Header), "Overview", StringComparison.OrdinalIgnoreCase);
        }

        private TutorialsWorkbookPopupWindow EnsureTutorialsWorkbookPopupWindow()
        {
            if (_tutorialsWorkbookPopupWindow == null)
            {
                _tutorialsWorkbookPopupWindow = new TutorialsWorkbookPopupWindow
                {
                    Owner = this,
                    WorkbookUrl = TutorialShortcutsExcelGoogleSheetsUrl
                };
                _tutorialsWorkbookPopupWindow.Closed += TutorialsWorkbookPopupWindow_Closed;
            }

            return _tutorialsWorkbookPopupWindow;
        }

        private void OpenTutorialsWorkbookPopup()
        {
            var popup = EnsureTutorialsWorkbookPopupWindow();
            popup.WorkbookUrl = TutorialShortcutsExcelGoogleSheetsUrl;

            if (!popup.IsVisible)
            {
                popup.Show();
            }

            popup.Activate();
            popup.Topmost = true;
            popup.Topmost = false;
            popup.Focus();
        }

        private void TutorialsWorkbookPopupWindow_Closed(object sender, System.EventArgs e)
        {
            if (ReferenceEquals(sender, _tutorialsWorkbookPopupWindow))
            {
                _tutorialsWorkbookPopupWindow = null;
            }
        }

        #endregion

        #region Tutorials - Models

        private sealed class TutorialDocumentDefinition
        {
            private const string GitHubRepoBaseUrl = "https://github.com/ghostminhtoan/Subtitle-draft-GMTPC/blob/master/";
            private const string GitHubRawBaseUrl = "https://raw.githubusercontent.com/ghostminhtoan/Subtitle-draft-GMTPC/master/";

            public TutorialDocumentDefinition(string title, string relativePath)
            {
                Title = title;
                RelativePath = relativePath;
            }

            public string Title { get; }

            public string RelativePath { get; }

            public string GetFullPath()
            {
                return Path.GetFullPath(Path.Combine(AppRuntimePaths.BaseDirectory, RelativePath));
            }

            public string SourceUrl
            {
                get
                {
                    return BuildGitHubBlobUrl(RelativePath);
                }
            }

            public string RawSourceUrl
            {
                get
                {
                    return BuildGitHubRawUrl(RelativePath);
                }
            }

            private static string BuildGitHubBlobUrl(string relativePath)
            {
                var normalizedPath = (relativePath ?? string.Empty).Replace('\\', '/');
                var segments = normalizedPath.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
                var encodedSegments = new List<string>(segments.Length);

                foreach (var segment in segments)
                {
                    encodedSegments.Add(Uri.EscapeDataString(segment));
                }

                return GitHubRepoBaseUrl + string.Join("/", encodedSegments);
            }

            private static string BuildGitHubRawUrl(string relativePath)
            {
                var normalizedPath = (relativePath ?? string.Empty).Replace('\\', '/');
                var segments = normalizedPath.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
                var encodedSegments = new List<string>(segments.Length);

                foreach (var segment in segments)
                {
                    encodedSegments.Add(Uri.EscapeDataString(segment));
                }

                return GitHubRawBaseUrl + string.Join("/", encodedSegments);
            }
        }

        #endregion
    }
}