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;
            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; }

        /// <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;
        [ObservableProperty] private bool _isRebaseInProgress;
        [ObservableProperty] private string _pendingOperationText = string.Empty;
        [ObservableProperty] private CommitInfo? _selectedCommit;
        [ObservableProperty] private BranchInfo? _selectedBranch;
        [ObservableProperty] private string _log = string.Empty;

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

        /// <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>작업 하나를 실행하고 성공하면 저장소 상태를 다시 읽는다.</summary>
        public async Task<bool> RunAndRefreshAsync(string operation, Action action)
        {
            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;

            var info = Git.GetRepositoryInfo();
            var branches = Git.GetBranches();
            var commits = Git.GetCommits(maxCount: Settings.CommitPageSize <= 0 ? 200 : Settings.CommitPageSize);
            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 remote = remotes.FirstOrDefault(r => r.Name == RemoteName) ?? remotes.FirstOrDefault();
            var head = branches.FirstOrDefault(b => b.IsCurrentHead);
            var author = ResolveAuthorName();

            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;
                PendingOperationText =
                    rebase.IsInProgress ? $"rebase {rebase.CurrentStep}/{rebase.TotalSteps}" :
                    mergeInProgress ? "병합 진행 중" : string.Empty;

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

                Replace(Branches, branches);
                Replace(Commits, commits);
                Replace(CommitNodes, nodes);
                Replace(StatusFiles, status.Files);
                Replace(Conflicts, conflicts);
                Replace(Tags, tags);
                Replace(Submodules, submodules);
                Replace(Stashes, stashes);

                if (SelectedCommit is null && Commits.Count > 0) SelectedCommit = Commits[0];
            });
        }

        /// <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);
        }

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

        /// <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;
            }

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