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 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));
            _workspace.Refreshed += SyncStashSelection;
            _workspace.StateChanged += RaiseCanExecuteChanged;

            // 원격을 이미 쓰고 있으면 펼쳐 둔다 - 접어 두면 쓰던 사람이 사라진 줄 안다.
            _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();
            }
        }

        public CommitInfo? SelectedCommit
        {
            get => _workspace.SelectedCommit;
            set
            {
                if (ReferenceEquals(_workspace.SelectedCommit, value)) return;
                _workspace.SelectedCommit = value;
                OnPropertyChanged();
                _ = ShowDiffAsync(value);
                RaiseCanExecuteChanged();
            }
        }

        // ================= 저장소 =================

        [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() => _workspace.RunAndRefreshAsync("pull", () =>
        {
            _workspace.ApplyCredentials();
            var result = _workspace.Git.Pull(_workspace.RemoteName);
            _workspace.MarkFetched();
            // 결과 한 줄은 GitService 가 로그에 적는다(Pull 은 Merge 를 거친다). 여기서 또 적으면 두 번 찍힌다(6차 C-1).
        });

        [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);

            // 머지 주석만 다른 충돌은 사람에게 묻지 않고 푼다. 양쪽 주석을 다 남긴다(6차 B-5).
            IReadOnlyList<string> noteOnly = result.HasConflicts && _workspace.Settings.IgnoreMergeNotes
                ? _workspace.Git.ResolveNoteOnlyConflicts()
                : Array.Empty<string>();
            var remaining = noteOnly.Count > 0 ? _workspace.Git.GetConflicts().Count : result.Conflicts.Count;

            _workspace.OnUi(() =>
            {
                // result.Message("충돌 N건 - 해결이 필요합니다.")는 GitService 가 이미 로그에 적었다(Progress).
                // 여기서 또 적으면 두 번 찍히고, 자동 해결 줄 뒤에 다시 나와 순서도 헷갈렸다(6차 C-1).
                if (noteOnly.Count > 0)
                    _workspace.AppendLog($"머지 주석만 다른 충돌 {noteOnly.Count}개 파일은 자동으로 풀었습니다. 남은 충돌 {remaining}건.");

                if (string.IsNullOrWhiteSpace(CommitMessage))
                    CommitMessage = $"Merge branch '{branch}' into {_workspace.CurrentBranch}";

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

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

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

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

        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;
                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);
                    }
                    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).
            _workspace.Git.Revert(SelectedCommit!.Sha);
        });

        [RelayCommand(CanExecute = nameof(HasCommit))]
        private Task CherryPickAsync() => _workspace.RunAndRefreshAsync("cherry-pick", () =>
        {
            // 결과 한 줄은 GitService 가 로그에 적는다(6차 C-1).
            _workspace.Git.CherryPick(SelectedCommit!.Sha);
        });

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

        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).
            _workspace.Git.RebaseStart(SelectedBranch!.FriendlyName);
        });

        private bool IsRebasing() => _workspace.IsRebaseInProgress;

        [RelayCommand(CanExecute = nameof(IsRebasing))]
        private Task RebaseContinueAsync() => _workspace.RunAndRefreshAsync("rebase continue", () =>
        {
            // 결과 한 줄은 GitService 가 로그에 적는다(6차 C-1).
            _workspace.Git.RebaseContinue();
        });

        [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) =================

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

        /// <summary>
        /// 마지막 커밋을 고쳐 쓴다(`git commit --amend`).
        ///
        /// 오타 난 메시지나 빠뜨린 파일을 <b>새 커밋을 쌓지 않고</b> 바로잡을 때 쓴다.
        /// 이미 올린 커밋을 고치면 남의 이력과 갈라지므로, <b>푸시 전에만</b> 쓰는 것이 원칙이다.
        /// </summary>
        [RelayCommand(CanExecute = nameof(CanAmend))]
        private Task AmendAsync() => _workspace.RunAndRefreshAsync("커밋 수정", () =>
        {
            var sha = _workspace.Git.Commit(CommitMessage, amend: true);
            _workspace.OnUi(() =>
            {
                CommitMessage = string.Empty;
                MessageUtil.ShowSuccessToast($"커밋 수정 완료 ({sha.Substring(0, 7)})");
            });
        });

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

        /// <summary>고칠 메시지를 처음부터 다시 치지 않도록 마지막 커밋의 메시지를 가져온다.</summary>
        [RelayCommand(CanExecute = nameof(CanLoadLastMessage))]
        private void LoadLastMessage() => CommitMessage = _workspace.Commits[0].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 target = FolderPicker.Pick("변경분 파일을 뽑아 놓을 폴더", ParentOf(_workspace.RepositoryPath));
            if (target is null) return Task.CompletedTask;

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

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

                _workspace.OnUi(() => MessageUtil.ShowSuccessToast(
                    skipped > 0
                        ? $"{written}개 파일 추출 (삭제되어 건너뜀 {skipped}개)"
                        : $"{written}개 파일 추출"));
            });
        }

        /// <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();
            AcceptMineCommand.NotifyCanExecuteChanged();
            AcceptTheirsCommand.NotifyCanExecuteChanged();
            AcceptBothCommand.NotifyCanExecuteChanged();

            RevertCommand.NotifyCanExecuteChanged();
            CherryPickCommand.NotifyCanExecuteChanged();
            ResetCommand.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();
            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();
        }
    }
}