using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using MergeHub.Models;
using MergeHub.Services;
using MergeHub.Views;
using UbisamBase.Core.Messaging;

namespace MergeHub.ViewModels
{
    /// <summary>
    /// Git 탭 - 저장소 조작 전부.
    /// 열기/클론 · 원격 · 브랜치 · 병합 · 이력 조작(revert/cherry-pick/rebase/reset) ·
    /// 스테이징/커밋 · 태그 · 서브모듈 · mergetool 등록.
    /// </summary>
    public sealed partial class GitViewModel : ObservableObject
    {
        private readonly GitWorkspace _workspace;

        public GitViewModel(GitWorkspace workspace)
        {
            _workspace = workspace;
            _workspace.Refreshed += () => OnPropertyChanged(nameof(SelectedCommit));

            // 파일 비교 탭에서 고른 커밋을 이력 선택 표시 · 커밋 내용 · 단추(Revert · Cherry-pick · Reset)가 따라간다(10차 B-1).
            // 커밋 내용(diff)은 여기서 바로 그리지 않는다 - 파일 비교 탭이 그 커밋의 목록 · 본문을 읽는 중이라,
            // 같은 작업 게이트를 먼저 잡으면 그쪽 읽기가 건너뛰어진다. 이 탭이 다시 보일 때 그린다.
            _workspace.CommitChosen += chooser =>
            {
                if (ReferenceEquals(chooser, this)) return;
                OnPropertyChanged(nameof(SelectedCommit));
                RaiseCanExecuteChanged();
                _diffPending = true;
            };
            _workspace.Refreshed += SyncStashSelection;
            _workspace.StateChanged += RaiseCanExecuteChanged;
            _workspace.PropertyChanged += (_, e) =>
            {
                if (e.PropertyName == nameof(GitWorkspace.MergeResolutionBody)) RefreshMergeMessageBody();
            };

            // 원격을 이미 쓰고 있으면 펼쳐 둔다 - 접어 두면 쓰던 사람이 사라진 줄 안다.
            _isRemoteOpen = _workspace.Settings.GitRemoteExpanded ||
                            !string.IsNullOrWhiteSpace(_workspace.RemoteUrl);
        }

        // ================= 원격 칸 접고 펴기 =================

        /// <summary>
        /// 원격 칸(원격 URL · Gitea 계정 · Fetch/Pull/Push)을 펼쳐 두었는지.
        ///
        /// <b>왜 접나</b> - 이 도구는 로컬에서 쓰는 머지툴이 우선이고 아직 원격 저장소가 없다.
        /// 그런데 화면에서는 원격이 위쪽 4분의 1을 차지한 채 전부 비활성이었다.
        /// <b>지우지는 않는다</b> - 사내 Gitea 가 생기면 다시 필요하다.
        /// </summary>
        [ObservableProperty]
        [NotifyPropertyChangedFor(nameof(RemoteToggleLabel))]
        private bool _isRemoteOpen;

        /// <summary>
        /// 단추 글자. <b>무엇이 숨어 있고 누르면 무슨 일이 나는지</b>를 함께 적는다.
        ///
        /// 처음에는 `▸ 원격 · 계정` 이라고만 했는데 <b>사용자가 못 찾았다</b> -
        /// 화살표 하나로는 "여기 접힌 것이 있다" 가 전해지지 않는다. 동사를 붙였다.
        /// </summary>
        public string RemoteToggleLabel =>
            IsRemoteOpen ? "▾ 원격 저장소 · 계정  접기" : "▸ 원격 저장소 · 계정  펴기";

        [RelayCommand]
        private void ToggleRemote()
        {
            IsRemoteOpen = !IsRemoteOpen;

            _workspace.Settings.GitRemoteExpanded = IsRemoteOpen;
            _workspace.SaveSettings();
        }

        public GitWorkspace Workspace => _workspace;

        private bool IsOpen() => _workspace.IsRepositoryOpen;

        // ================= 입력 =================

        public IReadOnlyList<ResetKind> ResetKinds { get; } =
            new[] { ResetKind.Soft, ResetKind.Mixed, ResetKind.Hard };

        [ObservableProperty] private ResetKind _selectedResetKind = ResetKind.Mixed;
        [ObservableProperty] private string _newBranchName = string.Empty;
        [ObservableProperty] private string _tagName = string.Empty;
        [ObservableProperty] private string _tagMessage = string.Empty;
        [ObservableProperty] private string _commitMessage = string.Empty;
        [ObservableProperty] private FileStatusInfo? _selectedStatusFile;
        [ObservableProperty] private ConflictInfo? _selectedConflict;
        [ObservableProperty] private TagInfo? _selectedTag;
        [ObservableProperty] private string _diffText = string.Empty;
        [ObservableProperty] private StashInfo? _selectedStash;
        [ObservableProperty] private string _blameText = string.Empty;
        [ObservableProperty] private string _blamePath = string.Empty;

        /// <summary>
        /// 커밋 비교의 <b>시작점</b>. 정해 두면 이력에서 고르는 커밋이 "끝점"이 되어
        /// 두 커밋 <b>사이</b>를 보여 준다. 비워 두면 지금까지처럼 "부모와 비교"다.
        /// </summary>
        [ObservableProperty]
        [NotifyPropertyChangedFor(nameof(DiffRangeText))]
        private CommitInfo? _diffFromCommit;

        public string DiffRangeText => DiffFromCommit is { } from
            ? $"{from.ShortSha} → 고른 커밋"
            : "부모 → 고른 커밋";

        partial void OnNewBranchNameChanged(string value) => RaiseCanExecuteChanged();
        partial void OnTagNameChanged(string value) => RaiseCanExecuteChanged();
        partial void OnCommitMessageChanged(string value) => RaiseCanExecuteChanged();
        partial void OnBlamePathChanged(string value) => RaiseCanExecuteChanged();
        partial void OnSelectedStatusFileChanged(FileStatusInfo? value) => RaiseCanExecuteChanged();
        partial void OnSelectedConflictChanged(ConflictInfo? value) => RaiseCanExecuteChanged();
        partial void OnSelectedTagChanged(TagInfo? value) => RaiseCanExecuteChanged();
        partial void OnSelectedStashChanged(StashInfo? value) => RaiseCanExecuteChanged();

        partial void OnDiffFromCommitChanged(CommitInfo? value)
        {
            RaiseCanExecuteChanged();
            _ = ShowDiffAsync(SelectedCommit);   // 기준이 바뀌었으니 지금 보고 있는 것도 다시 그린다
        }

        public BranchInfo? SelectedBranch
        {
            get => _workspace.SelectedBranch;
            set
            {
                if (ReferenceEquals(_workspace.SelectedBranch, value)) return;
                _workspace.SelectedBranch = value;
                OnPropertyChanged();
                RaiseCanExecuteChanged();
            }
        }

        /// <summary>파일 비교 탭에서 커밋을 골라, 이 탭의 커밋 내용이 아직 옛 커밋 것인지(10차 B-1).</summary>
        private bool _diffPending;

        /// <summary>이 탭이 다시 보일 때 부른다. 미뤄 둔 커밋 내용을 게이트가 빈 뒤에 그린다.</summary>
        public void ShowPendingDiff()
        {
            if (!_diffPending) return;
            _diffPending = false;
            _ = ShowDiffWhenIdleAsync();
        }

        private async Task ShowDiffWhenIdleAsync()
        {
            await _workspace.WhenIdleAsync();
            await ShowDiffAsync(SelectedCommit);
        }

        public CommitInfo? SelectedCommit
        {
            get => _workspace.SelectedCommit;
            set
            {
                if (ReferenceEquals(_workspace.SelectedCommit, value)) return;

                // 사람이 다른 커밋을 고른 것이면 파일 비교 탭도 따라간다(10차 B-1, 사용자 결정).
                // 저장 안 한 편집은 목록이 선택을 바꾸기 <b>전에</b> 화면이 물었다(ConfirmChooseCommit). 목록이 비워지며 들어온 null 은 고른 것이 아니다.
                var chosen = CommitSelection.IsOtherCommit(_workspace.SelectedCommit?.Sha, value?.Sha);
                _workspace.SelectedCommit = value;
                OnPropertyChanged();
                _ = ShowDiffAsync(value);
                RaiseCanExecuteChanged();
                if (chosen) _workspace.NotifyCommitChosen(this);
            }
        }

        /// <summary>
        /// 이력 목록이 선택을 바꾸기 <b>전에</b> 화면이 부른다(마우스 누름 · 방향키). 파일 비교 탭에 저장 안 한 편집이 있으면
        /// 파일 비교 탭 이력에서 고를 때와 같은 창으로 묻고, [취소] 면 false - 화면이 그 누름을 막는다(10차 B-1).
        ///
        /// 선택이 바뀐 <b>뒤에</b> 묻고 되돌리면, 창이 닫힌 뒤 목록이 누름 처리를 이어 가 [취소] 해도 다른 커밋이 선택된 채로 남았다.
        /// </summary>
        /// <param name="target">옮겨 갈 항목.</param>
        /// <returns>null = 창 없이 계속(목록이 알아서 고른다) · true = 물었고 계속(누름 도중에 창이 떠서 목록이 못 고르니 화면이 고른다) · false = [취소].</returns>
        public bool? ConfirmChooseCommit(CommitInfo? target)
        {
            if (target is null || !CommitSelection.IsOtherCommit(SelectedCommit?.Sha, target.Sha)) return null;
            return _workspace.ConfirmLeaveCommit?.Invoke();
        }
        // ================= 저장소 =================

        [RelayCommand]
        private Task OpenAsync() => _workspace.RunAndRefreshAsync("저장소 열기",
            () => _workspace.Git.Open(_workspace.RepositoryPath));

        private bool CanClone() => !string.IsNullOrWhiteSpace(_workspace.RemoteUrl);

        [RelayCommand(CanExecute = nameof(CanClone))]
        private Task CloneAsync() => _workspace.RunAndRefreshAsync("클론", () =>
        {
            _workspace.ApplyCredentials();
            _workspace.Git.Clone(_workspace.RemoteUrl, _workspace.RepositoryPath);
        });

        [RelayCommand(CanExecute = nameof(IsOpen))]
        private Task AddRemoteAsync() => _workspace.RunAndRefreshAsync("원격 추가", () =>
        {
            if (string.IsNullOrWhiteSpace(_workspace.RemoteUrl))
                throw new InvalidOperationException("원격 URL 을 입력하세요.");

            _workspace.ApplyCredentials();
            _workspace.Git.AddRemote(_workspace.RemoteName, _workspace.RemoteUrl);
            _workspace.Git.Fetch(_workspace.RemoteName);
            _workspace.MarkFetched();
        });

        [RelayCommand(CanExecute = nameof(IsOpen))]
        private Task RemoveRemoteAsync() => _workspace.RunAndRefreshAsync("원격 삭제",
            () => _workspace.Git.RemoveRemote(_workspace.RemoteName));

        [RelayCommand(CanExecute = nameof(IsOpen))]
        private Task FetchAsync() => _workspace.RunAndRefreshAsync("fetch", () =>
        {
            _workspace.ApplyCredentials();
            _workspace.Git.Fetch(_workspace.RemoteName);
            _workspace.MarkFetched();
        });

        [RelayCommand(CanExecute = nameof(IsOpen))]
        private Task PullAsync()
        {
            // 목록은 화면 스레드의 것이라 작업에 들어가기 전에 읽어 둔다.
            var tracked = _workspace.Branches.FirstOrDefault(b => b.IsCurrentHead)?.TrackedBranch;

            return _workspace.RunAndRefreshAsync("pull", () =>
            {
                _workspace.ApplyCredentials();
                var result = _workspace.Git.Pull(_workspace.RemoteName);
                _workspace.MarkFetched();

                // pull 도 병합이다. 머지 주석 자동 풀기 · 알림 · 병합 커밋 메시지를 [Merge] 와 같은 길로(7차 C-1).
                // 예전에는 여기서 아무것도 안 해 주석만 다른 충돌까지 사람에게 물었고, 알림도 커밋 메시지도 없었다.
                AfterMerge(result, MergeNames.PullMergeMessage(tracked, _workspace.CurrentBranch));
            });
        }

        [RelayCommand(CanExecute = nameof(IsOpen))]
        private Task PushAsync() => _workspace.RunAndRefreshAsync("push", () =>
        {
            _workspace.ApplyCredentials();
            _workspace.Git.Push(remoteName: _workspace.RemoteName);
        });

        [RelayCommand(CanExecute = nameof(IsOpen))]
        private Task RefreshAsync() => _workspace.RefreshAsync();

        // ================= 브랜치 =================

        private bool HasBranch() => SelectedBranch is not null;

        [RelayCommand(CanExecute = nameof(HasBranch))]
        private Task CheckoutAsync() => _workspace.RunAndRefreshAsync("체크아웃",
            () => _workspace.Git.Checkout(SelectedBranch!.FriendlyName));

        private bool CanCreateBranch() => IsOpen() && !string.IsNullOrWhiteSpace(NewBranchName);

        [RelayCommand(CanExecute = nameof(CanCreateBranch))]
        private Task CreateBranchAsync() => _workspace.RunAndRefreshAsync("브랜치 생성", () =>
        {
            _workspace.Git.CreateBranch(NewBranchName, SelectedCommit?.Sha, checkout: true);
            _workspace.OnUi(() => NewBranchName = string.Empty);
        });

        private bool CanDeleteBranch() => SelectedBranch is { IsRemote: false, IsCurrentHead: false };

        [RelayCommand(CanExecute = nameof(CanDeleteBranch))]
        private Task DeleteBranchAsync() => _workspace.RunAndRefreshAsync("브랜치 삭제",
            () => _workspace.Git.DeleteBranch(SelectedBranch!.FriendlyName));

        // ================= 병합 =================

        private bool CanMerge() => SelectedBranch is not null && !SelectedBranch.IsCurrentHead;

        [RelayCommand(CanExecute = nameof(CanMerge))]
        private Task MergeAsync() => _workspace.RunAndRefreshAsync("병합", () =>
        {
            var branch = SelectedBranch!.FriendlyName;
            var result = _workspace.Git.Merge(branch, commitOnSuccess: false);
            AfterMerge(result, MergeNames.BranchMergeMessage(branch, _workspace.CurrentBranch));
        });

        /// <summary>
        /// 병합(또는 pull) 결과를 받은 뒤 할 일. 작업 스레드에서 부른다(7차 C-1 에서 [Merge] 와 pull 이 함께 쓰게 뺐다).
        /// </summary>
        /// <param name="defaultMessage">커밋 메시지 칸이 비어 있고 병합 커밋이 남았을 때 채울 메시지.</param>
        private void AfterMerge(MergeResultInfo result, string defaultMessage) =>
            // 병합 커밋이 남는 경우에만 메시지를 채운다 - 이미 최신이거나 앞으로 감기면 커밋할 병합이 없다.
            AfterConflicts(result.HasConflicts, result.Conflicts.Count, result.Message,
                result.HasConflicts || result.Outcome == MergeOutcome.Merged ? defaultMessage : null,
                GitOperationKind.Merge);

        /// <summary>
        /// 충돌이 날 수 있는 작업(병합 · pull · rebase · cherry-pick · revert) 뒤에 할 일. 작업 스레드에서 부른다.
        /// 7차 C-2 에서 rebase · cherry-pick · revert 도 같은 길을 쓰게 했다 - 머지 주석 자동 풀기 · 알림 · 커밋 메시지.
        /// </summary>
        /// <param name="fillMessage">커밋 메시지 칸이 비어 있으면 채울 글. 없으면 null.</param>
        private void AfterConflicts(bool hasConflicts, int conflictCount, string resultMessage, string? fillMessage, GitOperationKind kind)
        {
            // 머지 주석만 다른 충돌은 사람에게 묻지 않고 푼다. 양쪽 주석을 다 남긴다(6차 B-5).
            IReadOnlyList<string> noteOnly = hasConflicts && _workspace.Settings.IgnoreMergeNotes
                ? _workspace.Git.ResolveNoteOnlyConflicts()
                : Array.Empty<string>();
            var remaining = noteOnly.Count > 0 ? _workspace.Git.GetConflicts().Count : conflictCount;
            var finish = OperationLabels.FinishHint(kind);

            _workspace.OnUi(() =>
            {
                // 결과 문장은 GitService 가 이미 로그에 적었다(Progress). 여기서 또 적으면 두 번 찍힌다(6차 C-1).
                if (noteOnly.Count > 0)
                    _workspace.AppendLog($"머지 주석만 다른 충돌 {noteOnly.Count}개 파일은 자동으로 풀었습니다. 남은 충돌 {remaining}건.");

                if (string.IsNullOrWhiteSpace(CommitMessage) && !string.IsNullOrWhiteSpace(fillMessage))
                {
                    CommitMessage = fillMessage!;

                    // 병합 메시지는 우리가 채운 것이다. 해결 내역이 쌓일 때마다 본문을 새로 붙이려고 기억해 둔다(8차 F-1).
                    if (kind == GitOperationKind.Merge)
                    {
                        _autoMergeMessage = MergeResolutionLog.WithBody(fillMessage, _workspace.MergeResolutionBody);
                        CommitMessage = _autoMergeMessage;
                    }
                }

                var autoNote = noteOnly.Count > 0 ? $" (머지 주석만 다른 {noteOnly.Count}건은 자동으로 풀림)" : string.Empty;
                var then = kind == GitOperationKind.Merge ? string.Empty : $" 다 풀면 {finish}.";

                if (hasConflicts && remaining > 0)
                    MessageUtil.ShowWarningToast($"충돌 {remaining}건{autoNote} - 충돌 탭에서 파일을 두 번 누르면 파일 비교 탭에서 세 칸으로 풉니다.{then}");
                else if (hasConflicts)
                    MessageUtil.ShowSuccessToast($"머지 주석만 다른 충돌 {noteOnly.Count}건을 자동으로 풀었습니다 - {finish}.");
                else
                    MessageUtil.ShowToast(resultMessage);
            });
        }

        /// <summary>메시지 칸에 우리가 채운 병합 메시지(본문 포함). 사람이 고치면 이것과 달라져 더는 건드리지 않는다.</summary>
        private string _autoMergeMessage = string.Empty;

        /// <summary>
        /// 충돌을 하나 풀 때마다 메시지 칸의 해결 내역을 새로 붙인다(8차 F-1). 사람이 칸을 고쳤으면 두고,
        /// 커밋할 때 <see cref="Services.GitService.CommitMerge"/> 가 본문을 붙인다 - 어느 쪽이든 기록은 남는다.
        /// </summary>
        private void RefreshMergeMessageBody()
        {
            if (_autoMergeMessage.Length == 0) return;

            if (!_workspace.IsMergeInProgress)
            {
                _autoMergeMessage = string.Empty;
                return;
            }

            if (!string.Equals(CommitMessage, _autoMergeMessage, StringComparison.Ordinal)) return;

            var updated = MergeResolutionLog.WithBody(_autoMergeMessage, _workspace.MergeResolutionBody);
            if (string.Equals(updated, CommitMessage, StringComparison.Ordinal)) return;

            _autoMergeMessage = updated;
            CommitMessage = updated;
        }

        /// <summary>충돌 탭 Accept 가 무엇으로 푼 것인지. BASE 로 되돌리기는 이 단추에 없어 적지 않는다.</summary>
        private static MergeResolutionKind? ToResolutionKind(ConflictResolution resolution) => resolution switch
        {
            ConflictResolution.Mine => MergeResolutionKind.Mine,
            ConflictResolution.Theirs => MergeResolutionKind.Theirs,
            ConflictResolution.Both => MergeResolutionKind.Both,
            _ => null
        };

        private bool CanAbort() =>
            _workspace.IsOperationInProgress || _workspace.IsMergeInProgress || _workspace.IsRebaseInProgress;

        [RelayCommand(CanExecute = nameof(CanAbort))]
        private Task AbortAsync() => _workspace.RunAndRefreshAsync("작업 취소",
            () => _workspace.Git.AbortOperation());

        /// <summary>충돌 탭의 끝내기 단추 글자 — 병합 커밋 · 계속 · 커밋(7차 C-2).</summary>
        public string FinishOperationLabel => OperationLabels.FinishButtonLabel(_workspace.OperationState.Kind);

        private bool CanFinishOperation()
        {
            if (!_workspace.OperationState.IsInProgress || _workspace.Conflicts.Count > 0) return false;

            // cherry-pick · revert 는 커밋할 것이 있어야 끝낼 수 있다. 이미 들어 있는 커밋을 가져오면 없다(8차 B-2).
            return _workspace.OperationState.Kind is not (GitOperationKind.CherryPick or GitOperationKind.Revert)
                   || _workspace.PendingHasChanges;
        }

        /// <summary>
        /// 충돌을 다 푼 작업을 끝낸다(7차 C-2). 병합은 병합 커밋, rebase 는 계속, cherry-pick · revert 는 원래 메시지로 커밋.
        /// 예전에는 [병합 커밋] 하나뿐이라 cherry-pick 은 충돌이 0 이 되면 끝낼 단추가 없었다.
        /// </summary>
        [RelayCommand(CanExecute = nameof(CanFinishOperation))]
        private Task FinishOperationAsync()
        {
            var kind = _workspace.OperationState.Kind;
            if (kind == GitOperationKind.Rebase) return RebaseContinueAsync();
            if (kind == GitOperationKind.Merge) return CommitMergeAsync();

            var name = kind == GitOperationKind.CherryPick ? "cherry-pick" : "revert";
            return _workspace.RunAndRefreshAsync($"{name} 커밋", () =>
            {
                var message = string.IsNullOrWhiteSpace(CommitMessage) ? null : CommitMessage;
                var sha = _workspace.Git.CommitPendingOperation(message);
                _workspace.OnUi(() =>
                {
                    CommitMessage = string.Empty;
                    MessageUtil.ShowSuccessToast($"{name} 커밋 완료 ({sha.Substring(0, 7)})");
                });
            });
        }

        private bool CanCommitMerge() => _workspace.IsMergeInProgress && _workspace.Conflicts.Count == 0;

        [RelayCommand(CanExecute = nameof(CanCommitMerge))]
        private Task CommitMergeAsync() => _workspace.RunAndRefreshAsync("병합 커밋", () =>
        {
            var message = string.IsNullOrWhiteSpace(CommitMessage) ? null : CommitMessage;
            var sha = _workspace.Git.CommitMerge(message);
            _workspace.OnUi(() =>
            {
                CommitMessage = string.Empty;
                _autoMergeMessage = string.Empty;
                MessageUtil.ShowSuccessToast($"병합 커밋 완료 ({sha.Substring(0, 7)})");
            });
        });

        /// <summary>
        /// 충돌 목록에서 고른 파일들(6차 B-6). Ctrl · Shift 로 여러 개를 고를 수 있다.
        /// ListBox.SelectedItems 는 바인딩이 안 돼 화면이 고를 때마다 넘겨준다.
        /// </summary>
        private IReadOnlyList<ConflictInfo> _selectedConflicts = Array.Empty<ConflictInfo>();

        public void SetSelectedConflicts(IReadOnlyList<ConflictInfo> conflicts)
        {
            _selectedConflicts = conflicts ?? Array.Empty<ConflictInfo>();
            OnPropertyChanged(nameof(ConflictSelectionText));
            RaiseCanExecuteChanged();
        }

        /// <summary>Accept 가 적용될 파일들. 여러 개를 골랐으면 그것들, 아니면 고른 하나.</summary>
        private IReadOnlyList<ConflictInfo> ConflictTargets =>
            _selectedConflicts.Count > 0 ? _selectedConflicts
            : SelectedConflict is { } one ? new[] { one } : Array.Empty<ConflictInfo>();

        /// <summary>여러 개를 골랐을 때 단추 옆에 띄우는 한 줄.</summary>
        public string ConflictSelectionText =>
            ConflictTargets.Count > 1 ? $"{ConflictTargets.Count}개 고름 - Accept 는 고른 파일 모두에 한 번에 적용됩니다" : string.Empty;

        private bool HasConflict() => ConflictTargets.Count > 0;

        [RelayCommand(CanExecute = nameof(HasConflict))]
        private Task AcceptMineAsync() => ResolveAsync(ConflictResolution.Mine);

        [RelayCommand(CanExecute = nameof(HasConflict))]
        private Task AcceptTheirsAsync() => ResolveAsync(ConflictResolution.Theirs);

        [RelayCommand(CanExecute = nameof(HasConflict))]
        private Task AcceptBothAsync()
        {
            // 파일 단위 "둘 다" 는 파일 두 벌을 통째로 이어 붙인다. 양쪽이 같은 이름으로 새로 만든 파일이면
            // 같은 형식이 두 번 나와 빌드가 안 된다(5차 C-1 에서 그랬다). 누르기 전에 무엇이 일어나는지 알린다(6차 A-5).
            var targets = ConflictTargets;
            var path = targets.Count <= 1
                ? targets.FirstOrDefault()?.Path ?? string.Empty
                : $"{targets.Count}개 파일 ({targets[0].Path} 외 {targets.Count - 1}개)";
            var go = MessageUtil.ShowYesNo(
                "파일 두 벌을 이어 붙입니다",
                $"{path}\n\n내 것 다음에 상대 것을 한 파일로 이어 붙입니다. 내 파일의 인코딩과 줄끝으로 씁니다.\n\n" +
                "양쪽이 같은 이름으로 새로 만든 파일이면 같은 형식이 두 번 나와 빌드가 안 될 수 있습니다.\n" +
                "줄마다 골라 둘 다 넣으려면 파일 비교 탭의 3분할에서 하세요.\n\n이어 붙일까요?");
            return go ? ResolveAsync(ConflictResolution.Both) : Task.CompletedTask;
        }

        /// <summary>
        /// 고른 충돌 파일을 파일 비교 탭의 3분할로 연다(6차 B-1). 목록을 두 번 누르거나 Enter 로도 온다.
        /// 켜짐/꺼짐을 따로 두지 않는다 - 고른 것이 없으면 아무 일도 안 한다. 이진 파일은 줄 단위로 볼 수 없어 알린다.
        /// </summary>
        [RelayCommand]
        private void OpenConflictInCompare()
        {
            var conflict = SelectedConflict;
            if (conflict is null) return;

            if (conflict.IsBinary)
            {
                MessageUtil.ShowWarningToast($"이진 파일이라 줄 단위로 볼 수 없습니다. 아래 Accept 단추로 한쪽을 고르세요: {conflict.Path}");
                return;
            }

            _workspace.RequestOpenConflict(conflict.Path);
        }

        /// <summary>
        /// 고른 충돌 파일들을 한 작업으로 푼다(6차 B-6).
        ///
        /// 예전에는 파일 하나마다 작업 하나였고, 작업이 끝날 때마다 저장소 전체를 다시 읽었다(한 개 약 1.5초).
        /// 이제는 고른 파일을 모두 풀고 <b>다시 읽기는 끝에 한 번</b>이다.
        /// 한 파일이 실패해도 나머지는 계속 풀고, 실패한 것은 로그와 알림으로 알린다.
        /// </summary>
        private Task ResolveAsync(ConflictResolution resolution)
        {
            var targets = ConflictTargets.ToList();
            if (targets.Count == 0) return Task.CompletedTask;

            var label = targets.Count == 1 ? $"충돌 해결({resolution})" : $"충돌 해결({resolution}) {targets.Count}개";

            return _workspace.RunAndRefreshAsync(label, () =>
            {
                var failed = new List<string>();
                var watch = Stopwatch.StartNew();

                foreach (var conflict in targets)
                {
                    try
                    {
                        _workspace.Git.ResolveConflict(conflict.Path, resolution);
                        if (ToResolutionKind(resolution) is { } kind) _workspace.Git.RecordResolution(conflict.Path, kind);
                    }
                    catch (Exception ex) when (ex is not OperationCanceledException)
                    {
                        failed.Add($"{conflict.Path}: {ex.Message}");
                    }
                }

                watch.Stop();

                _workspace.OnUi(() =>
                {
                    if (targets.Count > 1)
                        _workspace.AppendLog($"충돌 {targets.Count - failed.Count}개를 {resolution} 로 한 번에 풀었습니다 " +
                                             $"({watch.ElapsedMilliseconds}ms · 저장소 다시 읽기는 끝에 한 번)");

                    foreach (var line in failed) _workspace.AppendLog("충돌 해결 실패: " + line);
                    if (failed.Count > 0) MessageUtil.ShowWarningToast($"{failed.Count}개는 풀지 못했습니다 - 로그를 보세요");
                });
            });
        }

        // ================= 이력 조작 =================

        private bool HasCommit() => SelectedCommit is not null;

        [RelayCommand(CanExecute = nameof(HasCommit))]
        private Task RevertAsync() => _workspace.RunAndRefreshAsync("revert", () =>
        {
            // 결과 한 줄은 GitService 가 로그에 적는다. 여기서 또 적으면 두 번 찍힌다(6차 C-1). 뒷일은 병합과 같은 길로(7차 C-2).
            var result = _workspace.Git.Revert(SelectedCommit!.Sha);
            AfterConflicts(result.HasConflicts, result.Conflicts.Count, result.Message,
                _workspace.Git.GetPendingCommitMessage(), GitOperationKind.Revert);
        });

        [RelayCommand(CanExecute = nameof(HasCommit))]
        private Task CherryPickAsync() => _workspace.RunAndRefreshAsync("cherry-pick", () =>
        {
            // 결과 한 줄은 GitService 가 로그에 적는다(6차 C-1). 뒷일은 병합과 같은 길로(7차 C-2).
            var result = _workspace.Git.CherryPick(SelectedCommit!.Sha);
            AfterConflicts(result.HasConflicts, result.Conflicts.Count, result.Message,
                _workspace.Git.GetPendingCommitMessage(), GitOperationKind.CherryPick);
        });

        [RelayCommand(CanExecute = nameof(HasCommit))]
        private Task ResetAsync() => _workspace.RunAndRefreshAsync($"reset --{SelectedResetKind}",
            () => _workspace.Git.Reset(SelectedResetKind, SelectedCommit!.Sha));

        /// <summary>우클릭 메뉴 [메시지 바꾸기...] 에 걸어 둘 설명.</summary>
        public string RewordHint => CommitReword.MenuHint;

        /// <summary>
        /// 이력에서 고른 커밋의 메시지를 바꾼다(11차 C-2, `git rebase -i` 의 reword).
        ///
        /// HEAD 가 아니면 <b>그 커밋부터 HEAD 까지가 새 해시로 다시 써진다</b>. 그래서 좁은 범위에서만 한다 -
        /// 막을 까닭은 <see cref="CommitReword.BlockReason"/> 가 정하고, 여기서는 눌렀을 때 <b>왜 안 되는지 말해 준다</b>.
        /// 메뉴를 꺼 두지 않는 까닭: 꺼 두면 왜 안 되는지 알 길이 없고, 까닭은 저장소를 읽어 봐야 안다.
        ///
        /// 저장 안 한 편집은 <see cref="GitWorkspace.RunAndRefreshAsync"/> 가 지금까지의 Git 작업과 같은 창으로 묻는다.
        /// </summary>
        [RelayCommand(CanExecute = nameof(HasCommit))]
        private async Task RewordAsync()
        {
            var commit = SelectedCommit!;
            var info = _workspace.Git.InspectReword(commit.Sha);

            var blocked = CommitReword.BlockReason(
                info.Exists, AmendBlockedByOperation, !_workspace.IsWorkingTreeClean,
                info.IsAncestorOfHead, info.PushedTo, info.OtherBranches, info.TagsInRange, info.MergeCommits);

            if (blocked is not null)
            {
                MessageUtil.ShowWarningToast($"메시지를 바꿀 수 없습니다 - {blocked}");
                return;
            }

            var target = $"{commit.ShortSha} · {commit.AuthorName} · {commit.When.LocalDateTime:yyyy-MM-dd HH:mm}";
            var typed = RewordWindow.Ask(target, commit.Message,
                info.RewriteCount <= 1
                    ? "이 커밋이 새 해시로 다시 써집니다"
                    : $"이 커밋과 그 뒤 {info.RewriteCount - 1}개, 모두 {info.RewriteCount}개가 새 해시로 다시 써집니다");

            if (typed is null) return;

            if (!CommitReword.IsUsableMessage(typed))
            {
                MessageUtil.ShowWarningToast("메시지가 비어 있어 바꾸지 않았습니다");
                return;
            }

            if (!CommitReword.Changed(commit.Message, typed))
            {
                MessageUtil.ShowToast("메시지가 그대로라 다시 쓰지 않았습니다");
                return;
            }

            if (!MessageUtil.ShowYesNo("커밋 메시지 바꾸기",
                    CommitReword.Confirm(commit.ShortSha, commit.MessageShort, info.RewriteCount, _workspace.HeadSha)))
                return;

            var newTarget = string.Empty;
            var done = await _workspace.RunAndRefreshAsync("커밋 메시지 바꾸기", () =>
            {
                var result = _workspace.Git.RewordCommit(commit.Sha, typed);
                newTarget = result.NewTarget;
                _workspace.OnUi(() =>
                    MessageUtil.ShowSuccessToast(CommitReword.Done(result.OldHead, result.NewHead, result.Rewritten)));
            });

            // 고른 커밋을 <b>새 해시로</b> 따라간다. 그냥 두면 옛 해시가 사라져 선택이 HEAD 로 떨어진다(9차 A-1 · A-2).
            if (!done || newTarget.Length == 0) return;
            if (_workspace.Commits.FirstOrDefault(c => string.Equals(c.Sha, newTarget, StringComparison.Ordinal)) is { } moved)
                SelectedCommit = moved;
        }

        private bool CanRebase() =>
            SelectedBranch is not null && !SelectedBranch.IsCurrentHead && !_workspace.IsRebaseInProgress;

        [RelayCommand(CanExecute = nameof(CanRebase))]
        private Task RebaseAsync() => _workspace.RunAndRefreshAsync("rebase", () =>
        {
            // 결과 한 줄은 GitService 가 로그에 적는다(6차 C-1). 뒷일은 병합과 같은 길로(7차 C-2).
            var result = _workspace.Git.RebaseStart(SelectedBranch!.FriendlyName);
            AfterConflicts(result.Outcome == RebaseOutcome.Conflicts, result.Conflicts.Count, result.Message,
                null, GitOperationKind.Rebase);
        });

        private bool IsRebasing() => _workspace.IsRebaseInProgress;

        [RelayCommand(CanExecute = nameof(IsRebasing))]
        private Task RebaseContinueAsync() => _workspace.RunAndRefreshAsync("rebase continue", () =>
        {
            // 결과 한 줄은 GitService 가 로그에 적는다(6차 C-1). 다음 단계에서 또 충돌하면 병합과 같은 뒷일(7차 C-2).
            var result = _workspace.Git.RebaseContinue();
            AfterConflicts(result.Outcome == RebaseOutcome.Conflicts, result.Conflicts.Count, result.Message,
                null, GitOperationKind.Rebase);
        });

        [RelayCommand(CanExecute = nameof(IsRebasing))]
        private Task RebaseAbortAsync() => _workspace.RunAndRefreshAsync("rebase abort",
            () => _workspace.Git.RebaseAbort());

        // ================= 스테이징 / 커밋 =================

        [RelayCommand(CanExecute = nameof(IsOpen))]
        private Task StageAllAsync() => _workspace.RunAndRefreshAsync("전체 스테이징",
            () => _workspace.Git.StageAll());

        private bool HasStatusFile() => SelectedStatusFile is not null;

        [RelayCommand(CanExecute = nameof(HasStatusFile))]
        private Task StageSelectedAsync() => _workspace.RunAndRefreshAsync("스테이징",
            () => _workspace.Git.Stage(SelectedStatusFile!.Path));

        [RelayCommand(CanExecute = nameof(HasStatusFile))]
        private Task UnstageSelectedAsync() => _workspace.RunAndRefreshAsync("언스테이징",
            () => _workspace.Git.Unstage(SelectedStatusFile!.Path));

        [RelayCommand(CanExecute = nameof(HasStatusFile))]
        private Task RestoreSelectedAsync() => _workspace.RunAndRefreshAsync("변경 취소",
            () => _workspace.Git.RestoreFiles(new[] { SelectedStatusFile!.Path }));

        private bool CanCommit() => IsOpen() && !string.IsNullOrWhiteSpace(CommitMessage);

        [RelayCommand(CanExecute = nameof(CanCommit))]
        private Task CommitAsync() => _workspace.RunAndRefreshAsync("커밋", () =>
        {
            var sha = _workspace.Git.Commit(CommitMessage);
            _workspace.OnUi(() =>
            {
                CommitMessage = string.Empty;
                MessageUtil.ShowSuccessToast($"커밋 완료 ({sha.Substring(0, 7)})");
            });
        });

        [RelayCommand(CanExecute = nameof(IsOpen))]
        private Task StashSaveAsync() => _workspace.RunAndRefreshAsync("stash 저장",
            () => _workspace.Git.StashSave($"MergeHub {DateTime.Now:yyyy-MM-dd HH:mm}"));

        [RelayCommand(CanExecute = nameof(IsOpen))]
        private Task StashPopAsync() => _workspace.RunAndRefreshAsync("stash 적용",
            () => _workspace.Git.StashPop());

        // ================= 커밋 수정 (amend) =================

        /// <summary>
        /// [커밋 수정] 을 켤 조건. <b>작업 중에는 끈다</b>(11차 C-1) - 병합 · rebase · cherry-pick · revert 가
        /// 도는 중에 누르면 "cannot create a tree from a not fully merged index" 로 실패했다.
        /// </summary>
        private bool CanAmend() =>
            CommitSelection.CanAmend(IsOpen(), !string.IsNullOrWhiteSpace(CommitMessage), AmendBlockedByOperation);

        /// <summary>병합 · rebase · cherry-pick · revert 가 도는 중인가.</summary>
        private bool AmendBlockedByOperation =>
            _workspace.IsMergeInProgress || _workspace.IsRebaseInProgress || _workspace.IsOperationInProgress;

        /// <summary>단추 설명. 작업 중이면 왜 꺼졌는지 말한다.</summary>
        public string AmendHint => CommitSelection.AmendHint(AmendBlockedByOperation);

        /// <summary>스테이징해 둔 파일 수 - 고치면 이 파일들도 함께 들어간다(충돌 중인 것은 빼고 센다).</summary>
        private int StagedFileCount => _workspace.StatusFiles.Count(f => f.IsStaged && !f.IsConflicted);

        /// <summary>지금 브랜치가 따라가는 원격 브랜치 이름(없으면 null).</summary>
        private string? HeadTrackedBranch => _workspace.Branches.FirstOrDefault(b => b.IsCurrentHead)?.TrackedBranch;

        /// <summary>
        /// HEAD 가 <b>이미 원격에 올라가 있는가</b> - 추적 브랜치가 있고 앞선 커밋이 0개면 올라간 것으로 본다.
        /// 이 수치는 마지막 fetch 시점 기준이라, fetch 전에 남이 올린 것까지는 알 수 없다(그래서 막지 않고 묻기만 한다).
        /// </summary>
        private bool IsHeadAlreadyPushed
        {
            get
            {
                var head = _workspace.Branches.FirstOrDefault(b => b.IsCurrentHead);
                return head?.TrackedBranch is not null && (head.AheadBy ?? 0) == 0;
            }
        }

        /// <summary>
        /// 마지막 커밋을 고쳐 쓴다(`git commit --amend`).
        ///
        /// 오타 난 메시지나 빠뜨린 파일을 <b>새 커밋을 쌓지 않고</b> 바로잡을 때 쓴다.
        /// 이미 올린 커밋을 고치면 남의 이력과 갈라지므로, <b>푸시 전에만</b> 쓰는 것이 원칙이다.
        ///
        /// 고치기 전 해시를 알림에 남긴다(11차 C-1) - 예전에는 새 해시만 알려 되돌릴 실마리가 없었다.
        /// 스테이징해 둔 파일이 있거나 이미 올린 커밋이면 <b>먼저 묻는다</b>(11차 C-1, 2026-09-18 사용자 결정).
        /// </summary>
        [RelayCommand(CanExecute = nameof(CanAmend))]
        private Task AmendAsync()
        {
            var oldSha = _workspace.HeadFullSha;

            // 누르기 전에 물을 것. [취소] 하면 커밋도 메시지 칸도 그대로 둔다.
            var warning = CommitSelection.AmendWarning(StagedFileCount, IsHeadAlreadyPushed, HeadTrackedBranch);
            if (warning is not null && !MessageUtil.ShowYesNo("커밋 수정", warning))
                return Task.CompletedTask;

            return _workspace.RunAndRefreshAsync("커밋 수정", () =>
            {
                var staged = _workspace.Git.GetStatus().StagedCount;
                var sha = _workspace.Git.Commit(CommitMessage, amend: true);
                _workspace.OnUi(() =>
                {
                    CommitMessage = string.Empty;
                    MessageUtil.ShowSuccessToast(CommitSelection.AmendDone(oldSha, sha, staged));
                });
            });
        }

        private bool CanLoadLastMessage() => IsOpen() && _workspace.Commits.Count > 0;

        /// <summary>
        /// 고칠 메시지를 처음부터 다시 치지 않도록 <b>HEAD 커밋</b>의 메시지를 가져온다.
        ///
        /// 예전에는 이력 목록의 맨 위(<c>Commits[0]</c>)를 가져왔다. [모든 브랜치] 를 켜면 맨 위가 다른 브랜치의
        /// 더 새 커밋이라, 그대로 [커밋 수정] 하면 <b>HEAD 제목이 남의 커밋 메시지로 바뀌었다</b>(11차 C-1).
        /// </summary>
        [RelayCommand(CanExecute = nameof(CanLoadLastMessage))]
        private void LoadLastMessage()
        {
            var pairs = _workspace.Commits.Select(c => (c.Sha, c.Message)).ToList();
            var message = CommitSelection.MessageOfHead(pairs, _workspace.HeadFullSha);

            if (message is null)
            {
                MessageUtil.ShowWarningToast("HEAD 커밋이 이력 목록에 없어 메시지를 가져오지 못했습니다.");
                return;
            }

            CommitMessage = message.TrimEnd();
        }

        // ================= stash 목록 =================

        /// <summary>
        /// 목록이 바뀌면 고른 stash 를 다시 잡는다.
        ///
        /// 그냥 두면 두 가지가 어긋난다 - ① 아무것도 안 고른 상태라 닫힌 콤보가 비어 보이고,
        /// ② 하나 꺼내 쓴 뒤 <b>번호가 한 칸씩 당겨지는데</b> 옛 항목을 붙들고 있으면
        /// 다음 "삭제"가 엉뚱한 것을 지운다.
        /// </summary>
        private void SyncStashSelection()
        {
            if (SelectedStash is { } picked &&
                _workspace.Stashes.Any(s => s.Index == picked.Index && s.Sha == picked.Sha)) return;

            SelectedStash = _workspace.Stashes.FirstOrDefault();
        }

        private bool HasStash() => SelectedStash is not null;

        /// <summary>고른 stash 를 꺼내 적용한다. 목록에서 골라야 하므로 "맨 위"에 갇히지 않는다.</summary>
        [RelayCommand(CanExecute = nameof(HasStash))]
        private Task StashApplySelectedAsync() => _workspace.RunAndRefreshAsync("stash 적용",
            () => _workspace.Git.StashPop(SelectedStash!.Index));

        [RelayCommand(CanExecute = nameof(HasStash))]
        private Task StashDropSelectedAsync() => _workspace.RunAndRefreshAsync("stash 삭제",
            () => _workspace.Git.StashDrop(SelectedStash!.Index));

        // ================= 두 커밋 사이 비교 =================

        /// <summary>지금 고른 커밋을 비교의 시작점으로 잡는다.</summary>
        [RelayCommand(CanExecute = nameof(HasCommit))]
        private void SetDiffFrom() => DiffFromCommit = SelectedCommit;

        private bool HasDiffFrom() => DiffFromCommit is not null;

        [RelayCommand(CanExecute = nameof(HasDiffFrom))]
        private void ClearDiffFrom() => DiffFromCommit = null;

        // ================= 변경분 파일 추출 =================

        private bool CanExportChanges() => HasCommit();

        /// <summary>
        /// 두 커밋 사이에 바뀐 파일만 골라 폴더로 뽑는다.
        ///
        /// 장비에 소스를 통째로 넣지 못하는 현장에서 <b>바뀐 것만</b> 들고 갈 때 쓴다.
        /// 비교 시작점을 잡아 두었으면 그 사이를, 아니면 고른 커밋의 부모부터 잰다.
        /// </summary>
        [RelayCommand(CanExecute = nameof(CanExportChanges))]
        private Task ExportChangesAsync()
        {
            // 저장소가 있는 자리에서 시작한다 - 뽑아 놓을 자리는 보통 그 근처다.
            var picked = FolderPicker.Pick("변경분 파일을 뽑아 놓을 폴더", ParentOf(_workspace.RepositoryPath));
            if (picked is null) return Task.CompletedTask;

            var to = SelectedCommit!;
            var from = DiffFromCommit?.Sha ?? to.ParentShas.FirstOrDefault() ?? to.Sha;

            // 고른 폴더에 바로 쏟지 않고 <b>그 아래 새 폴더</b>를 만든다(11차 A-3, 사용자 결정).
            // 예전에는 이미 있던 파일과 지난번에 뽑은 것이 말없이 섞였다. 이름에 범위와 날짜가 들어가
            // 여러 번 뽑아도 서로 밟지 않는다. 안내 글은 그 폴더 옆(= 고른 폴더 안)에 붙는다.
            var target = ExportPlan.UniquePath(picked, ExportPlan.FolderName(from, to.Sha, DateTime.Now));

            // 안내 글에 적을 "무엇에서 무엇까지" - 이력에 있는 커밋이면 제목 · 날짜까지 적는다.
            var fromLabel = RangeLabel(from, DiffFromCommit, isParentFallback: DiffFromCommit is null);
            var toLabel = RangeLabel(to.Sha, to, isParentFallback: false);
            var author = MergeNote.AuthorOf(_workspace.AuthorName);

            return _workspace.RunAsync("변경분 추출", () =>
            {
                var (written, skipped, items) = _workspace.Git.ExportChangedFiles(from, to.Sha, target);

                // 뽑은 폴더 <b>옆</b>에 안내 글을 둔다(11차 A-2, 사용자 결정) - 폴더를 장비에 통째로 넣어도
                // 소스 틈에 안내 파일이 섞이지 않는다. 지운 파일 · 이름 바뀐 옛 경로가 여기에만 남는다.
                var notePath = ExportReport.PathFor(target);
                var noteWritten = true;
                try
                {
                    TextFile.Write(notePath,
                        ExportReport.Build(_workspace.RepositoryPath, target, fromLabel, toLabel, items, DateTime.Now, author));
                }
                catch (Exception ex)
                {
                    // 파일은 다 뽑았는데 안내만 못 쓴 것이라 추출 자체를 실패로 만들지 않는다.
                    noteWritten = false;
                    _workspace.AppendLog($"변경분 안내를 쓰지 못했습니다: {ex.Message}");
                }

                if (noteWritten) _workspace.AppendLog($"변경분 안내: {notePath}");

                var folderName = Path.GetFileName(target);
                _workspace.OnUi(() => MessageUtil.ShowSuccessToast(
                    skipped > 0
                        ? $"{folderName} 에 {written}개 (지워야 할 파일 {skipped}개는 안내에)"
                        : $"{folderName} 에 {written}개 파일 추출"));
            });
        }

        /// <summary>
        /// 안내 글에 적을 커밋 한 줄. 이력에 있는 커밋이면 제목과 날짜까지 적고, 없으면 해시만 적는다.
        /// 시작점을 안 잡았을 때는 "부모" 라는 것을 드러낸다 - 폴더만 보고 무엇과 견줬는지 알 수 있어야 한다.
        /// </summary>
        private string RangeLabel(string sha, CommitInfo? known, bool isParentFallback)
        {
            var info = known ?? _workspace.Commits.FirstOrDefault(c => c.Sha == sha);
            var head = info is null
                ? (sha.Length > 7 ? sha.Substring(0, 7) : sha)
                : $"{info.ShortSha} {info.MessageShort} ({info.When:yyyy-MM-dd HH:mm})";

            return isParentFallback ? head + "  (고른 커밋의 부모)" : head;
        }

        /// <summary>저장소가 놓인 폴더. 대화상자를 그 자리에서 열어 주려고 쓴다.</summary>
        private static string ParentOf(string path)
        {
            try
            {
                var trimmed = path?.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
                if (string.IsNullOrEmpty(trimmed)) return string.Empty;

                var parent = Path.GetDirectoryName(trimmed);
                return Directory.Exists(parent) ? parent! : string.Empty;
            }
            catch (ArgumentException)
            {
                return string.Empty;   // 경로가 이상하면 대화상자 기본 자리에서 연다
            }
        }

        // ================= blame =================

        private bool CanBlame() => IsOpen() && !string.IsNullOrWhiteSpace(BlamePath);

        /// <summary>
        /// 줄마다 "누가 언제 이 줄을 만들었나"를 붙여 보여 준다.
        ///
        /// 머지 중에 "이 줄 왜 이렇게 됐지"를 묻게 되는데, 그때 커밋 이력을 뒤지는 대신
        /// 줄 옆에서 바로 답이 나오는 편이 빠르다.
        /// </summary>
        [RelayCommand(CanExecute = nameof(CanBlame))]
        private Task BlameAsync()
        {
            var path = BlamePath.Trim().Replace(Path.DirectorySeparatorChar, '/');
            var at = SelectedCommit?.Sha;

            return _workspace.RunAsync("blame", () =>
            {
                var lines = _workspace.Git.Blame(path, at);

                var sb = new StringBuilder();
                foreach (var line in lines)
                {
                    sb.Append(line.ShortSha).Append("  ")
                      .Append(line.When.ToString("yyyy-MM-dd")).Append("  ")
                      .Append(line.AuthorName.PadRight(10)).Append(" | ")
                      .Append(line.LineNumber.ToString("0000")).Append("  ")
                      .AppendLine(line.Text);
                }

                var text = sb.Length == 0 ? "(내용 없음)" : sb.ToString();
                _workspace.OnUi(() => BlameText = text);
            });
        }

        /// <summary>변경 목록에서 고른 파일을 blame 대상으로 옮겨 준다 - 경로를 다시 치지 않게.</summary>
        [RelayCommand(CanExecute = nameof(HasStatusFile))]
        private void BlameSelectedFile() => BlamePath = SelectedStatusFile!.Path;

        // ================= 태그 / 서브모듈 / 설정 =================

        private bool CanCreateTag() => IsOpen() && !string.IsNullOrWhiteSpace(TagName);

        [RelayCommand(CanExecute = nameof(CanCreateTag))]
        private Task CreateTagAsync() => _workspace.RunAndRefreshAsync("태그 생성", () =>
        {
            var message = string.IsNullOrWhiteSpace(TagMessage) ? null : TagMessage;
            _workspace.Git.CreateTag(TagName, SelectedCommit?.Sha ?? "HEAD", message);
            _workspace.OnUi(() => { TagName = string.Empty; TagMessage = string.Empty; });
        });

        private bool HasTag() => SelectedTag is not null;

        [RelayCommand(CanExecute = nameof(HasTag))]
        private Task DeleteTagAsync() => _workspace.RunAndRefreshAsync("태그 삭제",
            () => _workspace.Git.DeleteTag(SelectedTag!.Name));

        private bool CanUpdateSubmodules() => IsOpen() && _workspace.Submodules.Count > 0;

        [RelayCommand(CanExecute = nameof(CanUpdateSubmodules))]
        private Task UpdateSubmodulesAsync() => _workspace.RunAndRefreshAsync("서브모듈 업데이트", () =>
        {
            _workspace.ApplyCredentials();
            _workspace.Git.UpdateAllSubmodules();
        });

        [RelayCommand(CanExecute = nameof(IsOpen))]
        private Task RegisterMergeToolAsync() => _workspace.RunAsync("mergetool 등록", () =>
        {
            // net48 에는 Environment.ProcessPath 가 없다. 호스트는 UbisamBase.Shell.exe.
            var exe = Process.GetCurrentProcess().MainModule?.FileName
                      ?? Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "UbisamBase.Shell.exe");

            _workspace.Git.RegisterAsMergeTool("mergehub", exe, global: true);
            _workspace.OnUi(() => MessageUtil.ShowSuccessToast("git config 에 mergehub 등록 완료"));
        });

        // ================= 탐색기 우클릭 =================

        /// <summary>지금 우클릭 메뉴에 걸려 있는지. 버튼 이름을 이 값으로 바꾼다.</summary>
        [ObservableProperty]
        [NotifyPropertyChangedFor(nameof(ShellIntegrationLabel))]
        private bool _isShellRegistered = ShellIntegration.IsRegistered;

        public string ShellIntegrationLabel =>
            IsShellRegistered ? "탐색기 보내기 해제" : "탐색기 보내기 등록";

        /// <summary>
        /// 탐색기 <b>보내기</b> 메뉴에 이 프로그램을 넣고 뺀다.
        ///
        /// 우클릭 메뉴에 바로 넣는 레지스트리 방식은 이 PC 에서 뜨지 않았다
        /// (자세한 이유는 ShellIntegration 설명 참고). 보내기는 바로가기 파일 하나라
        /// 권한도 필요 없고, 여러 개를 골라 한 번에 보낼 수 있다.
        /// </summary>
        [RelayCommand]
        private void ToggleShellIntegration()
        {
            try
            {
                if (IsShellRegistered)
                {
                    ShellIntegration.Unregister();
                    MessageUtil.ShowToast("탐색기 보내기 메뉴에서 뺐습니다");
                }
                else
                {
                    ShellIntegration.Register(ShellIntegration.CurrentExecutable());
                    MessageUtil.ShowSuccessToast("우클릭 → 보내기 → " + ShellIntegration.MenuLabel + " 로 엽니다");
                }

                IsShellRegistered = ShellIntegration.IsRegistered;
            }
            catch (Exception ex)
            {
                MessageUtil.ShowErrorToast("보내기 등록 실패: " + ex.Message);
            }
        }

        /// <summary>CommunityToolkit 의 커맨드는 CommandManager 를 구독하지 않아 직접 알려야 한다.</summary>
        private void RaiseCanExecuteChanged()
        {
            OpenCommand.NotifyCanExecuteChanged();
            CloneCommand.NotifyCanExecuteChanged();
            AddRemoteCommand.NotifyCanExecuteChanged();
            RemoveRemoteCommand.NotifyCanExecuteChanged();
            FetchCommand.NotifyCanExecuteChanged();
            PullCommand.NotifyCanExecuteChanged();
            PushCommand.NotifyCanExecuteChanged();
            RefreshCommand.NotifyCanExecuteChanged();

            CheckoutCommand.NotifyCanExecuteChanged();
            CreateBranchCommand.NotifyCanExecuteChanged();
            DeleteBranchCommand.NotifyCanExecuteChanged();

            MergeCommand.NotifyCanExecuteChanged();
            AbortCommand.NotifyCanExecuteChanged();
            CommitMergeCommand.NotifyCanExecuteChanged();
            FinishOperationCommand.NotifyCanExecuteChanged();
            OnPropertyChanged(nameof(FinishOperationLabel));
            AcceptMineCommand.NotifyCanExecuteChanged();
            AcceptTheirsCommand.NotifyCanExecuteChanged();
            AcceptBothCommand.NotifyCanExecuteChanged();

            RevertCommand.NotifyCanExecuteChanged();
            CherryPickCommand.NotifyCanExecuteChanged();
            ResetCommand.NotifyCanExecuteChanged();
            RewordCommand.NotifyCanExecuteChanged();
            RebaseCommand.NotifyCanExecuteChanged();
            RebaseContinueCommand.NotifyCanExecuteChanged();
            RebaseAbortCommand.NotifyCanExecuteChanged();

            StageAllCommand.NotifyCanExecuteChanged();
            StageSelectedCommand.NotifyCanExecuteChanged();
            UnstageSelectedCommand.NotifyCanExecuteChanged();
            RestoreSelectedCommand.NotifyCanExecuteChanged();
            CommitCommand.NotifyCanExecuteChanged();
            StashSaveCommand.NotifyCanExecuteChanged();
            StashPopCommand.NotifyCanExecuteChanged();

            CreateTagCommand.NotifyCanExecuteChanged();
            DeleteTagCommand.NotifyCanExecuteChanged();
            UpdateSubmodulesCommand.NotifyCanExecuteChanged();
            RegisterMergeToolCommand.NotifyCanExecuteChanged();

            AmendCommand.NotifyCanExecuteChanged();
            OnPropertyChanged(nameof(AmendHint));   // 작업이 시작 · 끝나면 단추 설명도 바뀐다(11차 C-1)
            LoadLastMessageCommand.NotifyCanExecuteChanged();
            StashApplySelectedCommand.NotifyCanExecuteChanged();
            StashDropSelectedCommand.NotifyCanExecuteChanged();
            SetDiffFromCommand.NotifyCanExecuteChanged();
            ClearDiffFromCommand.NotifyCanExecuteChanged();
            ExportChangesCommand.NotifyCanExecuteChanged();
            BlameCommand.NotifyCanExecuteChanged();
            BlameSelectedFileCommand.NotifyCanExecuteChanged();
        }

        // ================= diff =================

        private Task ShowDiffAsync(CommitInfo? commit)
        {
            if (commit is null) return Task.CompletedTask;

            return _workspace.RunAsync("diff", () =>
            {
                // 비교 시작점을 잡아 두었으면 두 커밋 "사이", 아니면 지금까지처럼 부모와 견준다.
                var from = DiffFromCommit;
                var diffs = from is null
                    ? _workspace.Git.DiffCommitWithParent(commit.Sha)
                    : _workspace.Git.DiffCommits(from.Sha, commit.Sha);

                var sb = new StringBuilder();
                sb.AppendLine(from is null
                    ? $"{commit.ShortSha}  {commit.MessageShort}"
                    : $"{from.ShortSha} → {commit.ShortSha}  ({diffs.Count}개 파일)");
                sb.AppendLine($"{commit.AuthorName} <{commit.AuthorEmail}>  {commit.When:yyyy-MM-dd HH:mm}");
                sb.AppendLine(new string('-', 60));

                foreach (var d in diffs)
                {
                    sb.AppendLine($"[{d.ChangeKind}] {d.Path}  (+{d.LinesAdded} / -{d.LinesDeleted})");
                    if (d.IsBinary) { sb.AppendLine("  (binary)"); continue; }

                    foreach (var line in d.Lines)
                    {
                        var marker = line.Kind switch
                        {
                            DiffLineKind.Added => '+',
                            DiffLineKind.Deleted => '-',
                            DiffLineKind.HunkHeader => '@',
                            _ => ' '
                        };
                        sb.Append(marker).Append(' ').AppendLine(RenderLine(line));
                    }
                    sb.AppendLine();
                }

                var text = sb.ToString();
                _workspace.OnUi(() => DiffText = text);
            });
        }

        /// <summary>단어 단위 diff 가 켜져 있으면 바뀐 구간을 〔〕로 감싼다.</summary>
        private static string RenderLine(DiffLine line)
        {
            if (line.Words is null || line.Words.Count == 0) return line.Text;

            var sb = new StringBuilder();
            foreach (var word in line.Words)
            {
                if (word.Kind == WordDiffKind.Unchanged) sb.Append(word.Text);
                else sb.Append('〔').Append(word.Text).Append('〕');
            }
            return sb.ToString();
        }
    }
}