using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using CommunityToolkit.Mvvm.ComponentModel;
using MergeHub.Models;
using UbisamBase.Core.Logging;
using UbisamBase.Core.Messaging;
using UbisamBase.Core.SettingItems;

namespace MergeHub.Services
{
    /// <summary>
    /// 줄 단위로 견줄 파일 한 짝. 폴더 비교가 파일 비교로 넘기는 목록의 단위다.
    /// </summary>
    public sealed class ComparePair
    {
        public ComparePair(string left, string right, string name)
        {
            Left = left ?? string.Empty;
            Right = right ?? string.Empty;
            Name = name ?? string.Empty;
        }

        public string Left { get; }
        public string Right { get; }

        /// <summary>화면에 적을 이름. 대개 상대 경로다.</summary>
        public string Name { get; }
    }
    /// <summary>
    /// 홈(머지툴) 탭과 Git 탭이 함께 쓰는 저장소 상태.
    /// IGitService 는 스레드 안전하지 않으므로 모든 호출을 여기서 한 줄로 직렬화한다.
    /// DI 싱글턴으로 등록되어 두 화면이 같은 인스턴스를 본다.
    /// </summary>
    public sealed partial class GitWorkspace : ObservableObject
    {
        private readonly SemaphoreSlim _gate = new SemaphoreSlim(1, 1);
        private readonly SynchronizationContext? _uiContext;
        private readonly Logger _logger = new Logger("MergeHub");

        /// <summary>플랫폼에 등록된 사용자. 머지 주석에 남길 이름을 여기서 가져온다.</summary>
        private readonly UbisamBase.Core.Settings.CurrentUserService? _currentUser;

        public GitWorkspace(IGitService git, ISettingsService settingsService,
                            UbisamBase.Core.Settings.CurrentUserService currentUser)
        {
            Git = git;
            _currentUser = currentUser;
            _uiContext = SynchronizationContext.Current;
            _settingsService = settingsService;
            Settings = settingsService.RegisterSettings(nameof(MergeHubSettings), new MergeHubSettings());

            RepositoryPath = Settings.DefaultRepositoryPath;
            RemoteName = string.IsNullOrWhiteSpace(Settings.DefaultRemoteName) ? "origin" : Settings.DefaultRemoteName;
            RemoteUrl = Settings.GiteaUrl;
            UserName = Settings.GiteaUserName;

            Git.IgnoreWhitespace = Settings.IgnoreWhitespace;
            Git.WordLevelDiff = Settings.WordLevelDiff;

            // 작성자 이름은 여기서 한 번 정해 둔다.
            // 저장소를 읽을 때(ReadState)만 정하면 Git 없이 파일 두 개를 비교할 때 이름이 비고,
            // 그러면 주석에 등록한 이름 대신 윈도우 계정이 찍힌다.
            AuthorName = ResolveAuthorName();

            // 최근 목록은 켤 때 한 번 읽고, 바뀔 때마다 바로 쓴다.
            // 프로그램이 갑자기 꺼져도 목록이 남게 하려는 것이다 - 몇 줄짜리 글이라 쓰는 값이 싸다.
            Recent.Load(RecentPath);
            Recent.Changed += (_, _) => Recent.Save(RecentPath);

            // `git mergetool` · 탐색기 우클릭이 넘긴 것을 화면으로 보낸다.
            // 여기서 하는 이유 - 이 객체는 첫 화면이 만들어질 때 함께 만들어지므로
            // 요청을 남겨 둘 자리로 가장 이르다.
            RouteStartupArgs();

            // 설정 화면에서 이름을 바꾸면 바로 따라간다.
            if (_currentUser is not null)
            {
                _currentUser.PropertyChanged += (_, e) =>
                {
                    if (e.PropertyName == nameof(_currentUser.UserName)) AuthorName = ResolveAuthorName();
                };
            }

            Git.Progress += (_, message) =>
            {
                _logger.I(message);
                OnUi(() => AppendLog(message));
            };
        }

        public IGitService Git { get; }

        /// <summary>
        /// 최근에 견준 짝. 파일 비교와 폴더 비교가 함께 본다.
        ///
        /// 여기에 두는 까닭 - 두 화면이 서로를 모르는 채로 같은 목록을 봐야 하고,
        /// 이 객체가 이미 그 통로 노릇을 하고 있다.
        /// </summary>
        public RecentPairs Recent { get; } = new RecentPairs();

        /// <summary>
        /// 최근 목록을 두는 자리. 플랫폼 설정 폴더 아래에 둔다 - 장비마다 한 자리에 모인다.
        /// <b>설정 화면에는 내놓지 않는다.</b> 사람이 손으로 고칠 값이 아니고, 설정 목록만 어지럽힌다.
        /// </summary>
        private static string RecentPath => Path.Combine(
            UbisamBase.Core.Bootstrap.UbisamAppBuilder.ConfigRoot, "Settings", "MergeHub.Recent.txt");

        public MergeHubSettings Settings { get; }

        private readonly ISettingsService _settingsService;

        /// <summary>
        /// 지금 설정을 파일에 쓴다. 화면에서 켜고 끈 것이 다음에 켤 때도 남게 하려는 것이다.
        /// 설정 화면에서 고치는 값은 그쪽이 알아서 쓰므로 여기를 부를 일이 없다.
        /// </summary>
        public void SaveSettings() => _settingsService.Save(nameof(MergeHubSettings));

        /// <summary>저장소 상태가 다시 읽힐 때마다 발생. 화면들이 자기 패널을 갱신한다.</summary>
        public event Action? Refreshed;

        /// <summary>
        /// 작업이 끝나 커맨드의 실행 가능 여부가 달라졌을 수 있음을 알린다.
        /// CommunityToolkit 의 RelayCommand 는 CommandManager 를 구독하지 않아
        /// 각 ViewModel 이 직접 NotifyCanExecuteChanged 를 불러야 한다.
        /// </summary>
        public event Action? StateChanged;

        // ================= 공유 목록 =================

        public ObservableCollection<BranchInfo> Branches { get; } = new ObservableCollection<BranchInfo>();
        public ObservableCollection<CommitInfo> Commits { get; } = new ObservableCollection<CommitInfo>();

        /// <summary>커밋 + 브랜치 그래프 레인. 홈 화면의 커밋 트리가 이걸 바인딩한다.</summary>
        public ObservableCollection<CommitNode> CommitNodes { get; } = new ObservableCollection<CommitNode>();
        public ObservableCollection<FileStatusInfo> StatusFiles { get; } = new ObservableCollection<FileStatusInfo>();
        public ObservableCollection<ConflictInfo> Conflicts { get; } = new ObservableCollection<ConflictInfo>();
        public ObservableCollection<TagInfo> Tags { get; } = new ObservableCollection<TagInfo>();
        public ObservableCollection<SubmoduleInfo> Submodules { get; } = new ObservableCollection<SubmoduleInfo>();

        /// <summary>치워 둔 작업(stash) 목록. 새 것이 0번이다.</summary>
        public ObservableCollection<StashInfo> Stashes { get; } = new ObservableCollection<StashInfo>();

        // ================= 공유 상태 =================

        [ObservableProperty] private string _repositoryPath = string.Empty;
        [ObservableProperty] private string _remoteUrl = string.Empty;
        [ObservableProperty] private string _remoteName = "origin";
        [ObservableProperty] private string _userName = string.Empty;
        [ObservableProperty] private string _password = string.Empty;
        [ObservableProperty] private string _repositoryName = "-";
        [ObservableProperty] private string _currentBranch = "-";
        [ObservableProperty] private string _headSha = "-";
        [ObservableProperty] private string _workingTreeSummary = "저장소 없음";
        [ObservableProperty] private bool _isWorkingTreeClean = true;
        [ObservableProperty] private bool _isRepositoryOpen;
        [ObservableProperty] private bool _isRemoteConnected;

        /// <summary>원격 등록 여부만 나타낸다 - 서버 접속 확인은 Fetch 를 눌러야 이뤄진다.</summary>
        [ObservableProperty] private string _remoteStatusText = "원격 없음";

        /// <summary>현재 원격의 주소(clone/push 대상).</summary>
        [ObservableProperty] private string _remoteUrlText = "-";

        /// <summary>추적 브랜치와 비교한 앞섬/뒤처짐. 마지막 fetch 시점 기준이다.</summary>
        [ObservableProperty] private string _syncStatusText = "-";

        /// <summary>추적 브랜치와 완전히 같은 상태인지.</summary>
        [ObservableProperty] private bool _isUpToDate;

        [ObservableProperty] private string _lastFetchText = "fetch 이력 없음";

        /// <summary>머지 주석에 남길 작성자. 설정값 > git config user.name > 윈도우 계정 순.</summary>
        [ObservableProperty] private string _authorName = Environment.UserName;

        [ObservableProperty] private bool _isMergeInProgress;

        /// <summary>이번 병합에서 처음 난 충돌 파일 수(6차 C-1). 병합 중이 아니거나 모르면 null.</summary>
        [ObservableProperty] private int? _mergeConflictTotal;

        /// <summary>지금 병합에서 충돌을 어떻게 풀었는지 - 병합 커밋 본문에 붙는 글(8차 F-1). 병합 중이 아니거나 적힌 것이 없으면 null.</summary>
        [ObservableProperty] private string? _mergeResolutionBody;

        /// <summary>
        /// 충돌 탭 목록 위의 진행 한 줄(6차 C-1). 예전에는 몇 개를 풀었는지 알 수 없었다.
        /// 처음 충돌 수는 병합할 때 .git 에 적어 두므로 앱을 다시 켜도 이어진다.
        /// MergeHub 밖에서 시작한 병합이라 처음 수를 모르면 남은 수만 적는다.
        /// </summary>
        public string ConflictProgressText =>
            // 작업마다 다 푼 뒤 할 일이 다르다 - 병합 커밋 · [계속] · [커밋](7차 C-2). 병합의 글은 예전과 같다.
            OperationLabels.ProgressText(OperationState.Kind, Conflicts.Count, MergeConflictTotal, PendingHasChanges);

        /// <summary>진행 중인 작업이 커밋할 것을 들고 있는가(8차 B-2). 없으면 끝낼 수 없고 [작업 취소] 로 나간다.</summary>
        [ObservableProperty]
        [NotifyPropertyChangedFor(nameof(ConflictProgressText))]
        private bool _pendingHasChanges = true;

        /// <summary>진행 중인 git 작업과 두 쪽 이름(7차 C-2). 상태를 다시 읽을 때마다 갱신한다.</summary>
        [ObservableProperty]
        [NotifyPropertyChangedFor(nameof(IsOperationInProgress))]
        [NotifyPropertyChangedFor(nameof(ConflictProgressText))]
        private GitOperationState _operationState = GitOperationState.None;

        /// <summary>
        /// 병합 · rebase · cherry-pick · revert 중 무엇이든 진행 중인지. 충돌 수와 따로 본다 -
        /// 예전에는 충돌이 0 이 되면 cherry-pick 이 진행 중이라는 표시도 [작업 취소] 도 사라졌다(7차 C-2).
        /// </summary>
        public bool IsOperationInProgress => OperationState.IsInProgress;

        /// <summary>이력에 모든 브랜치의 커밋을 보일지(7차 C-2). 다른 브랜치 커밋을 골라 cherry-pick 할 때 켠다.</summary>
        [ObservableProperty] private bool _showAllBranchesInHistory;

        partial void OnShowAllBranchesInHistoryChanged(bool value)
        {
            if (IsRepositoryOpen) _ = RefreshAsync();
        }
        [ObservableProperty] private bool _isRebaseInProgress;
        [ObservableProperty] private string _pendingOperationText = string.Empty;
        [ObservableProperty] private CommitInfo? _selectedCommit;

        /// <summary>지난 새로고침 때 "작업 중 · 충돌 0" 이었는지. 그 상태가 막 된 순간에만 선택을 HEAD 로 옮긴다(9차 A-1).</summary>
        private bool _wasResolvedOperation;

        /// <summary>지난 새로고침 때의 HEAD(전체 해시). HEAD 를 보고 있다가 HEAD 가 움직이면 새 HEAD 를 따라가려고 둔다(9차 A-2).</summary>
        private string? _lastHeadSha;
        [ObservableProperty] private BranchInfo? _selectedBranch;
        [ObservableProperty] private string _log = string.Empty;

        // ================= 실행 =================

        /// <summary>
        /// 지금 도는 Git 작업이 끝날 때까지 기다린다. 아무 일도 하지 않는다.
        ///
        /// <see cref="RunAsync"/> 는 게이트가 막혀 있으면 기다리지 않고 건너뛴다(겹쳐 돌면 안 되니까).
        /// 그런데 새로고침 뒤처럼 "이건 꼭 해야 하는" 일이 그 순간 걸리면 조용히 빠진다 -
        /// 병합 중 [해결로 저장] 뒤 파일 목록이 안 바뀐 것이 그랬다(6차 A-2). 그럴 때 이걸로 기다렸다 다시 한다.
        /// </summary>
        public async Task WhenIdleAsync()
        {
            await _gate.WaitAsync();
            _gate.Release();
        }

        /// <summary>
        /// Git 호출 하나를 백그라운드에서 직렬 실행한다.
        /// 실패하면 로그 + Error 토스트를 띄우고 false 를 돌려준다.
        /// </summary>
        public async Task<bool> RunAsync(string operation, Action action)
        {
            // 이미 다른 Git 작업이 도는 중이면 겹쳐 실행하지 않는다.
            // 조용히 사라지면 원인을 못 찾으니 반드시 로그를 남긴다.
            if (!await _gate.WaitAsync(0))
            {
                _logger.W($"[{operation}] 다른 작업 진행 중이라 건너뜀");
                return false;
            }

            try
            {
                await Task.Run(action);
                return true;
            }
            catch (Exception ex)
            {
                _logger.E($"[{operation}] 실패", ex);
                OnUi(() =>
                {
                    AppendLog($"[{operation}] 실패: {ex.Message}");
                    MessageUtil.ShowErrorToast($"{operation} 실패: {ex.Message}");
                });
                return false;
            }
            finally
            {
                _gate.Release();
                OnUi(() => StateChanged?.Invoke());
            }
        }

        /// <summary>
        /// 저장하지 않은 편집이 있으면 물어봐 달라고 파일 비교 화면이 앉혀 두는 자리.
        ///
        /// 두 화면이 서로를 모르는 채로 이 판단을 나눠야 한다 - Git 탭은 "무슨 작업을 하려는지" 를 알고,
        /// 파일 비교 탭은 "고치던 것이 있는지" 를 안다. 이 객체가 그 사이 통로다.
        /// 앉은 사람이 없으면(파일 비교 탭을 아직 안 열었으면) 늘 계속한다.
        /// </summary>
        public Func<string, bool>? ConfirmDiscardEdits { get; set; }

        /// <summary>
        /// 작업 하나를 실행하고 성공하면 저장소 상태를 다시 읽는다.
        ///
        /// <b>다시 읽으면 파일 비교 화면의 본문도 새로 읽힌다.</b> 고치던 것이 있으면 그때 사라진다.
        /// 그래서 <b>작업을 시작하기 전에</b> 묻는다 - 이 자리에서는 아직 아무것도 바뀌지 않았으므로
        /// 취소가 뜻이 있다. 다 끝난 뒤 목록을 다시 세우는 자리에서 물으면 되돌릴 데가 없다
        /// (4차 A-1 에서 그 자리를 일부러 비워 뒀던 까닭이고, 5차 A-2 가 그 구멍을 메운다).
        /// </summary>
        public async Task<bool> RunAndRefreshAsync(string operation, Action action)
        {
            if (GitOperationKinds.TouchesFiles(operation) && ConfirmDiscardEdits is { } ask && !ask(operation)) return false;

            var ok = await RunAsync(operation, action);
            if (ok) await RefreshAsync();
            return ok;
        }



        /// <summary>
        /// 기본 경로가 Git 저장소로 보이는지. 워크트리는 .git 이 파일이라 둘 다 본다.
        ///
        /// 저장소가 아닌 폴더에 Open 을 걸면 실패 알림이 뜰 뿐 아니라, 그동안 작업 게이트를
        /// 쥐고 있어서 뒤이어 시작하는 "파일 두 개 비교"까지 통째로 취소된다.
        /// </summary>
        /// <remarks>
        /// <b>고른 자리에서 위로 거슬러 올라가 찾는다.</b> <c>.git</c> 은 최상위에만 있는데
        /// 사람은 지금 보고 있던 깊은 폴더를 고르기 마련이라, 그 자리만 보면
        /// 멀쩡한 저장소를 두고 "저장소가 아니다"라고 하게 된다.
        /// </remarks>
        public bool LooksLikeRepository => PathUtil.FindRepositoryRoot(RepositoryPath).Length > 0;

        /// <summary>설정에 기본 저장소 경로가 있으면 시작하자마자 연다.</summary>
        public Task TryAutoOpenAsync()
        {
            if (IsRepositoryOpen || string.IsNullOrWhiteSpace(RepositoryPath))
                return Task.CompletedTask;

            var root = PathUtil.FindRepositoryRoot(RepositoryPath);
            if (root.Length == 0) return Task.CompletedTask;

            // 하위 폴더가 저장돼 있었으면 최상위로 바로잡아 둔다 - 화면의 경로 칸도 함께 맞는다.
            RepositoryPath = root;

            return RunAndRefreshAsync("저장소 자동 열기", () => Git.Open(root));
        }

        /// <summary>
        /// 상태를 다시 읽고, **게이트를 놓은 뒤에** Refreshed 를 발생시킨다.
        /// 게이트를 쥔 채로 알리면 구독자가 거는 Git 호출이 전부 버려진다.
        /// </summary>
        public async Task RefreshAsync()
        {
            if (!await RunAsync("새로고침", ReadState)) return;

            OnUi(() =>
            {
                Refreshed?.Invoke();
                StateChanged?.Invoke();
            });
        }

        private void ReadState()
        {
            if (!Git.IsOpen) return;

            // 병합이 끝났는데 남은 처음 충돌 목록을 치운다 - MergeHub 밖(터미널)에서 끝낸 병합도 여기서 걸린다(7차 B-1).
            Git.ForgetStaleMergeConflicts();

            var info = Git.GetRepositoryInfo();
            var branches = Git.GetBranches();
            var commits = Git.GetCommits(maxCount: Settings.CommitPageSize <= 0 ? 200 : Settings.CommitPageSize,
                                         allBranches: ShowAllBranchesInHistory);
            var operation = Git.GetOperationState();
            var nodes = CommitGraphBuilder.Build(commits);
            var status = Git.GetStatus();
            var conflicts = Git.GetConflicts();
            var tags = Git.GetTags();
            var submodules = Git.GetSubmodules();
            var stashes = Git.GetStashes();
            var rebase = Git.GetRebaseStatus();
            var remotes = Git.GetRemotes();
            var mergeInProgress = Git.IsMergeInProgress;
            var pendingHasChanges = !operation.IsInProgress || Git.HasStagedChanges();
            var conflictTotal = mergeInProgress ? Git.GetMergeConflictTotal() : null;
            var resolvedOperation = CommitSelection.IsResolvedOperation(operation.IsInProgress, conflicts.Count);

            var remote = remotes.FirstOrDefault(r => r.Name == RemoteName) ?? remotes.FirstOrDefault();
            var head = branches.FirstOrDefault(b => b.IsCurrentHead);
            var author = ResolveAuthorName();

            // 병합 커밋 본문의 "누가" 와 메시지 칸에 미리 보일 해결 내역(8차 F-1).
            Git.ResolverName = author;
            var resolutionBody = mergeInProgress ? Git.GetResolutionBody() : null;

            OnUi(() =>
            {
                RepositoryPath = info.WorkingDirectory;
                RepositoryName = GetRepositoryName(info.WorkingDirectory);
                CurrentBranch = info.CurrentBranchName ?? "(detached)";
                HeadSha = string.IsNullOrEmpty(info.HeadSha) ? "-" : info.HeadSha!.Substring(0, 7);
                IsRepositoryOpen = true;

                IsRemoteConnected = remotes.Count > 0;
                RemoteStatusText = remotes.Count > 0 ? $"원격 {remotes.Count}개" : "원격 없음";
                RemoteUrlText = remote?.Url ?? "-";
                AuthorName = author;

                (SyncStatusText, IsUpToDate) = DescribeSync(head);

                IsMergeInProgress = mergeInProgress;
                IsRebaseInProgress = rebase.IsInProgress;
                OperationState = operation;
                PendingHasChanges = pendingHasChanges;
                // cherry-pick · revert 도 "병합 진행 중" 이라고 했다. 작업 이름으로 적는다(7차 C-2).
                PendingOperationText = OperationLabels.PendingText(operation);

                IsWorkingTreeClean = status.IsClean;
                WorkingTreeSummary = status.IsClean ? "Clean" : $"{status.Files.Count} files";

                // 목록을 갈아 끼우기 <b>전에</b> 고른 커밋을 적어 둔다. Git 탭 이력 목록이 비워지는 순간 선택을 놓치면
                // 바인딩이 null 을 밀어 넣는다 - 그 뒤에 보면 고른 커밋을 이미 잃었다(9차 A-2).
                var previousSha = SelectedCommit?.Sha;

                Replace(Branches, branches);
                Replace(Commits, commits);
                Replace(CommitNodes, nodes);
                Replace(StatusFiles, status.Files);
                Replace(Conflicts, conflicts);
                MergeConflictTotal = conflictTotal;
                MergeResolutionBody = resolutionBody;
                OnPropertyChanged(nameof(ConflictProgressText));
                Replace(Tags, tags);
                Replace(Submodules, submodules);
                Replace(Stashes, stashes);

                // 예전에는 "비었으면 맨 위" 였다. [모든 브랜치] 에서 맨 위는 HEAD 가 아니어서, cherry-pick 마지막 [Save] 뒤
                // 두 칸의 기준이 다른 브랜치 커밋이 되기도 했다. 해시로 되찾고, 없으면 HEAD. 작업 중 충돌이 막 0 이 되면 HEAD 로(9차 A-1).
                var entered = CommitSelection.EntersResolvedOperation(_wasResolvedOperation, operation.IsInProgress, conflicts.Count);
                _wasResolvedOperation = resolvedOperation;
                // HEAD 를 보고 있었으면 커밋 · 체크아웃 뒤 새 HEAD 를 따라간다 - 옛 HEAD 에 남으면 방금 커밋한 줄이 "남은 차이" 로 보였다(9차 A-2).
                var pick = CommitSelection.Choose(commits.Select(c => c.Sha).ToList(), previousSha, info.HeadSha, entered, _lastHeadSha);
                _lastHeadSha = info.HeadSha;
                SelectedCommit = pick < 0 ? null : Commits[pick];
            });
        }

        /// <summary>
        /// 추적 브랜치와 몇 개 차이 나는지 문장으로 만든다.
        /// 이 수치는 **마지막 fetch 시점** 기준이라, fetch 전에는 서버가 앞서 있어도 "최신"으로 보인다.
        /// </summary>
        private static (string Text, bool UpToDate) DescribeSync(BranchInfo? head)
        {
            if (head is null) return ("브랜치 없음", false);
            if (head.TrackedBranch is null) return ("추적 브랜치 없음", false);

            var ahead = head.AheadBy ?? 0;
            var behind = head.BehindBy ?? 0;

            if (ahead == 0 && behind == 0) return ($"최신 ({head.TrackedBranch})", true);
            if (ahead > 0 && behind > 0) return ($"갈라짐 ↑{ahead} ↓{behind}", false);
            if (behind > 0) return ($"뒤처짐 ↓{behind} - pull 필요", false);
            return ($"앞섬 ↑{ahead} - push 필요", false);
        }

        /// <summary>
        /// MergeHub 설정 &gt; 플랫폼에 등록된 사용자 &gt; git config user.name &gt; 윈도우 계정 순으로 고른다.
        ///
        /// 플랫폼 사용자를 Git 설정보다 앞에 두는 이유 - 처음 켤 때 사람이 직접 적어 넣은 이름이고,
        /// 장비를 여럿이 쓰는 현장에서는 그 이름이 실제로 작업한 사람이다.
        /// MergeHub 설정을 더 앞에 두는 것은 "이 도구에서만 다르게 남기고 싶다"는 뜻이라 존중한다.
        /// </summary>
        private string ResolveAuthorName()
        {
            if (!string.IsNullOrWhiteSpace(Settings.MergeCommentAuthor))
                return Settings.MergeCommentAuthor.Trim();

            if (_currentUser?.HasName == true) return _currentUser.UserName.Trim();

            try
            {
                var configured = Git.GetConfig("user.name");
                if (!string.IsNullOrWhiteSpace(configured)) return configured!.Trim();
            }
            catch (Exception)
            {
                // 설정을 못 읽는 건 치명적이지 않다 - 윈도우 계정으로 넘어간다.
            }

            return Environment.UserName;
        }

        /// <summary>fetch 가 실제로 성공한 시각을 기록한다. 동기화 표시가 언제 기준인지 알리기 위함.</summary>
        public void MarkFetched()
        {
            var now = DateTime.Now;
            OnUi(() => LastFetchText = $"마지막 fetch {now:HH:mm:ss}");
        }

        private static string GetRepositoryName(string workingDirectory)
        {
            if (string.IsNullOrWhiteSpace(workingDirectory)) return "-";
            var trimmed = workingDirectory.TrimEnd('\\', '/');
            var slash = trimmed.LastIndexOfAny(new[] { '\\', '/' });
            return slash >= 0 ? trimmed.Substring(slash + 1) : trimmed;
        }

        public void ApplyCredentials()
        {
            Git.Credentials = string.IsNullOrWhiteSpace(UserName)
                ? null
                : new GitCredentials(UserName, Password);
        }

        public void AppendLog(string message) =>
            Log += $"[{DateTime.Now:HH:mm:ss}] {message}{Environment.NewLine}";

        /// <summary>
        /// "이 두 파일을 줄 단위로 비교해 달라" - 폴더 비교 탭이 보내고 파일 비교 탭이 받는다.
        ///
        /// 두 화면이 서로를 직접 알지 않도록 이미 둘 다 들고 있는 이 싱글턴을 통로로 쓴다.
        /// </summary>
        public event Action<string, string>? PlainCompareRequested;

        /// <summary>아직 아무도 받지 않은 요청. 아래 설명 참고.</summary>
        private (string Left, string Right)? _pendingPlainCompare;

        public bool HasPendingPlainCompare => _pendingPlainCompare is not null;

        /// <summary>
        /// 요청을 남겨 두고 받을 사람이 있으면 바로 넘긴다.
        ///
        /// 남겨 두는 것이 핵심이다. 탭 내용은 <b>그 탭을 처음 열 때</b> 만들어지므로,
        /// 폴더 비교에서 파일을 처음 더블클릭하는 순간에는 파일 비교 화면이 아직 없어
        /// 이벤트를 받을 사람이 없다. 그냥 발생시키면 요청이 허공에 사라지고,
        /// 새로 만들어진 화면은 기본 파일을 연다 - "더블클릭이 안 먹는다"로 보이는 이유다.
        /// </summary>
        /// <param name="line">
        /// 열자마자 짚어 줄 줄 번호. 0 이면 여느 때처럼 첫 차이로 간다.
        /// 폴더 전체 검색에서 결과를 눌렀을 때, 파일만 열리고 맨 위에 서 있으면
        /// 찾은 줄을 눈으로 다시 찾아야 한다.
        /// </param>
        /// <param name="lineIsLeft">그 번호가 왼쪽 파일 기준인지. 아니면 오른쪽 기준이다.</param>
        public void RequestPlainCompare(string leftFile, string rightFile, int line = 0, bool lineIsLeft = true)
        {
            _pendingPlainCompare = (leftFile, rightFile);
            RequestedLine = line;
            RequestedLineIsLeft = lineIsLeft;
            OnUi(DeliverPendingPlainCompare);
        }

        // ================= 폴더 비교에서 훑는 중인 파일 목록 =================

        /// <summary>
        /// 폴더 비교가 넘긴 "지금 훑는 중인 파일들". 파일 비교 화면의 이전/다음 파일이 이걸 딛는다.
        ///
        /// <b>화면에 보이는 순서 그대로</b> 담는다 - 필터로 "코드가 다른 것만" 을 걸어 뒀으면
        /// 그 안에서만 움직여야 한다. 목록에 없는 파일로 넘어가면 왜 거기로 갔는지 알 수 없다.
        /// </summary>
        public IReadOnlyList<ComparePair> Queue { get; private set; } = Array.Empty<ComparePair>();

        /// <summary>지금 몇 번째를 보고 있는지. 목록이 없으면 -1.</summary>
        public int QueueIndex { get; set; } = -1;

        /// <summary>목록이나 자리가 바뀌었다.</summary>
        public event EventHandler? QueueChanged;

        public void SetQueue(IReadOnlyList<ComparePair> queue, int index)
        {
            Queue = queue ?? Array.Empty<ComparePair>();
            QueueIndex = index;
            OnUi(() => QueueChanged?.Invoke(this, EventArgs.Empty));
        }

        /// <summary>목록을 비운다. 폴더를 거치지 않고 연 파일은 딛고 갈 자리가 없다.</summary>
        public void ClearQueue() => SetQueue(Array.Empty<ComparePair>(), -1);

        public void RaiseQueueChanged() => OnUi(() => QueueChanged?.Invoke(this, EventArgs.Empty));

        /// <summary>넘긴 파일에서 짚어 줄 자리. 없으면 0.</summary>
        public int RequestedLine { get; private set; }

        /// <summary>그 번호가 왼쪽 파일 기준인지.</summary>
        public bool RequestedLineIsLeft { get; private set; }

        /// <summary>
        /// 짚어 줄 자리를 한 번 쓰고 지운다.
        /// 지우지 않으면 그 다음에 연 파일까지 같은 줄로 끌려간다.
        /// </summary>
        public (int Line, bool IsLeft) TakeRequestedLine()
        {
            var one = (RequestedLine, RequestedLineIsLeft);
            RequestedLine = 0;
            return one;
        }

        /// <summary>남아 있는 요청을 넘긴다. 화면이 새로 만들어지면 스스로 한 번 불러 준다.</summary>
        public void DeliverPendingPlainCompare()
        {
            if (_pendingPlainCompare is not { } pending) return;
            if (PlainCompareRequested is null) return;

            _pendingPlainCompare = null;
            PlainCompareRequested.Invoke(pending.Left, pending.Right);
        }

        // ================= 충돌 파일을 파일 비교 탭에서 열기 (6차 B-1) =================

        /// <summary>
        /// "이 충돌 파일을 3분할로 열어 달라" - Git 탭의 충돌 목록이 보내고 파일 비교 탭이 받는다.
        ///
        /// 예전에는 충돌 목록을 두 번 눌러도 아무 일이 없었다. 줄마다 고르려면 파일 비교 탭으로 가서
        /// [새로고침] 을 누르고 콤보에서 같은 파일을 다시 찾아야 했다.
        /// </summary>
        public event Action<string>? OpenConflictRequested;

        /// <summary>아직 아무도 받지 않은 요청. 파일 비교 화면은 탭을 처음 열 때 만들어지므로 남겨 둔다.</summary>
        private string? _pendingOpenConflict;

        public bool HasPendingOpenConflict => _pendingOpenConflict is not null;

        public void RequestOpenConflict(string path)
        {
            if (string.IsNullOrWhiteSpace(path)) return;

            _pendingOpenConflict = path;
            OnUi(DeliverPendingOpenConflict);
            ActivateWhenReady(MergeHub.ViewIds.Home);
        }

        /// <summary>남아 있는 요청을 넘긴다. 파일 비교 화면이 새로 만들어지면 스스로 한 번 불러 준다.</summary>
        public void DeliverPendingOpenConflict()
        {
            if (_pendingOpenConflict is not { } path) return;
            if (OpenConflictRequested is null) return;

            _pendingOpenConflict = null;
            OpenConflictRequested.Invoke(path);
        }

        // ================= mergetool 세 벌을 네 칸으로 열기 =================

        /// <summary>
        /// "`git mergetool` 이 넘긴 세 벌을 네 칸으로 열어 달라". 켤 때 넘어온 인자가 보내고 파일 비교 탭이 받는다.
        /// 파일 비교 화면은 탭을 처음 열 때 만들어지므로 다른 요청들처럼 남겨 둔다.
        /// </summary>
        public event Action<MergeToolRequest>? MergeToolRequested;

        private MergeToolRequest? _pendingMergeTool;

        public bool HasPendingMergeTool => _pendingMergeTool is not null;

        public void RequestMergeTool(MergeToolRequest request)
        {
            _pendingMergeTool = request;
            OnUi(DeliverPendingMergeTool);
        }

        /// <summary>남아 있는 요청을 넘긴다. 파일 비교 화면이 새로 만들어지면 스스로 한 번 불러 준다.</summary>
        public void DeliverPendingMergeTool()
        {
            if (_pendingMergeTool is not { } request) return;
            if (MergeToolRequested is null) return;

            _pendingMergeTool = null;
            MergeToolRequested.Invoke(request);
        }

        // ================= 켤 때 넘어온 인자 =================

        /// <summary>폴더 비교 화면이 아직 없을 때 남겨 두는 요청. 파일 비교 쪽과 같은 방식이다.</summary>
        private (string Left, string Right)? _pendingFolderCompare;

        public void RequestFolderCompare(string left, string right)
        {
            _pendingFolderCompare = (left, right);
            OnUi(DeliverPendingFolderCompare);
        }

        public void DeliverPendingFolderCompare()
        {
            if (_pendingFolderCompare is not { } pending) return;
            if (FolderCompareRequested is null) return;

            _pendingFolderCompare = null;
            FolderCompareRequested.Invoke(pending.Left, pending.Right);
        }

        public event Action<string, string>? FolderCompareRequested;

        /// <summary>
        /// `git mergetool` · `git difftool` · 탐색기 우클릭이 넘긴 것을 화면으로 보낸다.
        ///
        /// 창이 다 만들어진 뒤에 탭을 옮겨야 한다 - 그 전에는 옮길 곳이 아직 없어 요청이 사라진다.
        /// 요청 자체는 남겨 두므로(pending) 늦게 만들어진 화면도 스스로 집어 간다.
        /// </summary>
        private void RouteStartupArgs()
        {
            var args = StartupArgs.Current;

            if (args.WantsFolder)
            {
                RequestFolderCompare(args.LeftFolder, args.RightFolder);
                ActivateWhenReady(MergeHub.ViewIds.Folder);
                AppendLog($"탐색기에서 폴더 비교 요청: {args.LeftFolder}");
                return;
            }

            // mergetool 이 세 벌을 넘겼으면 네 칸으로 연다(6차 B-4 확인 중 발견 - 예전에는 BASE · MERGED 두 칸이었다).
            if (args.ThreeWayMerge is { } merge)
            {
                RequestMergeTool(merge);
                ActivateWhenReady(MergeHub.ViewIds.Home);
                AppendLog($"mergetool 로 호출됨(네 칸): {merge.Merged}");
                return;
            }

            if (!args.WantsFiles) return;

            var (left, right) = args.DiffPair;
            RequestPlainCompare(left, right);
            ActivateWhenReady(MergeHub.ViewIds.Home);

            AppendLog(args.Mode == StartupMode.Merge
                ? $"mergetool 로 호출됨: {args.Merged}"
                : $"파일 비교 요청: {left} ↔ {right}");
        }

        /// <summary>
        /// 탐색기에서 끌어다 놓은 것을 화면으로 보낸다.
        ///
        /// 명령줄로 들어오는 길과 <b>같은 판단</b>을 쓴다 - 폴더면 폴더 비교, 파일이면 파일 비교.
        /// 두 길이 다르게 굴면 "우클릭으로 열 때랑 끌어다 놓을 때가 다르다"가 되어 설명할 수 없다.
        /// </summary>
        public void RouteDroppedPaths(IReadOnlyList<string> paths)
        {
            if (paths is null || paths.Count == 0) return;

            var args = StartupArgs.Parse(paths);

            if (args.WantsFolder)
            {
                RequestFolderCompare(args.LeftFolder, args.RightFolder);
                ActivateWhenReady(MergeHub.ViewIds.Folder);
                AppendLog($"끌어다 놓기 - 폴더 비교: {args.LeftFolder}");
                return;
            }

            if (!args.WantsFiles) return;

            var (left, right) = args.DiffPair;
            RequestPlainCompare(left, right);
            ActivateWhenReady(MergeHub.ViewIds.Home);
            AppendLog($"끌어다 놓기 - 파일 비교: {left} ↔ {right}");
        }

        private static void ActivateWhenReady(string viewId)
        {
            var app = System.Windows.Application.Current;
            if (app is null) return;

            app.Dispatcher.BeginInvoke(
                new Action(() => UbisamBase.Core.Modules.TabManager.Activate(viewId)),
                System.Windows.Threading.DispatcherPriority.ApplicationIdle);
        }

        /// <summary>ObservableCollection 변경은 UI 스레드에서만 허용된다.</summary>
        public void OnUi(Action action)
        {
            if (_uiContext is null || SynchronizationContext.Current == _uiContext)
            {
                action();
                return;
            }
            _uiContext.Send(_ => action(), null);
        }

        private static void Replace<T>(ObservableCollection<T> target, IEnumerable<T> items)
        {
            target.Clear();
            foreach (var item in items) target.Add(item);
        }
    }
}