using System;
using System.Collections.Generic;

using UnityEditor;
using UnityEngine;

using Codice.Client.BaseCommands;
using Codice.Client.BaseCommands.Merge;
using Codice.Client.Commands;
using Codice.Client.Common;
using Codice.Client.Common.FsNodeReaders;
using Codice.CM.Common;
using Codice.CM.Common.Merge;
using Codice.CM.Common.Mount;
using PlasticGui;
using PlasticGui.WorkspaceWindow;
using PlasticGui.WorkspaceWindow.BranchExplorer;
using PlasticGui.WorkspaceWindow.Topbar;
using PlasticGui.WorkspaceWindow.Diff;
using PlasticGui.WorkspaceWindow.Merge;
using Unity.PlasticSCM.Editor.AssetsOverlays.Cache;
using Unity.PlasticSCM.Editor.AssetUtils;
using Unity.PlasticSCM.Editor.Settings;
using Unity.PlasticSCM.Editor.StatusBar;
using Unity.PlasticSCM.Editor.Tool;
using Unity.PlasticSCM.Editor.UI;
using Unity.PlasticSCM.Editor.UI.Progress;
using Unity.PlasticSCM.Editor.UI.Tree;
using Unity.PlasticSCM.Editor.Views.Merge.Developer.DirectoryConflicts;
using UnityEditor.IMGUI.Controls;

using ObjectInfo = Codice.CM.Common.ObjectInfo;

namespace Unity.PlasticSCM.Editor.Views.Merge.Developer
{
    internal class MergeTab :
        IIncomingChangesTab,
        IRefreshableView,
        IMergeView,
        IMergeViewMenuOperations,
        MergeViewFileConflictMenu.IMetaMenuOperations
    {

        internal MergeTreeView Table { get { return mMergeTreeView; } }
        internal string EmptyStateMessage { get { return mEmptyStatePanel.Text; } }
        internal ConflictResolutionState ConflictResolutionState { get { return mConflictResolutionState; } }
        internal int DirectoryConflictCount { get { return mDirectoryConflictCount; } }
        internal bool IsProcessingMerge { get { return mMergeViewLogic.IsProcessingMerge; } }
        internal GUIContent ValidationLabel { get { return mValidationLabel; } }

        internal static MergeTab Build(
            WorkspaceInfo wkInfo,
            RepositorySpec repSpec,
            ObjectInfo objectInfo,
            ObjectInfo ancestorChangesetInfo,
            EnumMergeType mergeType,
            ShowIncomingChangesFrom from,
            IWorkspaceWindow workspaceWindow,
            IViewSwitcher switcher,
            IHistoryViewLauncher historyViewLauncher,
            MergeViewLogic.IMergeController mergeController,
            MergeViewLogic.IGetWorkingBranch getWorkingBranch,
            CheckShelvedChanges.IUpdateShelvedChangesNotification updateShelvedChangesNotification,
            IRefreshView refreshView,
            IAssetStatusCache assetStatusCache,
            LaunchTool.IShowDownloadPlasticExeWindow showDownloadPlasticExeWindow,
            IPendingChangesUpdater pendingChangesUpdater,
            IncomingChangesUpdater incomingChangesUpdater,
            IShelvedChangesUpdater shelvedChangesUpdater,
            PlasticNotifier plasticNotifier,
            WindowStatusBar windowStatusBar,
            EditorWindow parentWindow,
            bool isIncomingMerge,
            bool isMergeFinished,
            bool showDiscardChangesButton)
        {
            MergeTab mergeTab = new MergeTab(
                wkInfo,
                repSpec,
                objectInfo,
                ancestorChangesetInfo,
                mergeType,
                from,
                workspaceWindow,
                switcher,
                historyViewLauncher,
                mergeController,
                getWorkingBranch,
                updateShelvedChangesNotification,
                refreshView,
                assetStatusCache,
                showDownloadPlasticExeWindow,
                pendingChangesUpdater,
                incomingChangesUpdater,
                shelvedChangesUpdater,
                plasticNotifier,
                windowStatusBar,
                parentWindow,
                isIncomingMerge,
                isMergeFinished,
                showDiscardChangesButton);

            if (!isMergeFinished)
                ((IRefreshableView)mergeTab).Refresh();

            return mergeTab;
        }

        internal static MergeTab BuildFromCalculatedMerge(
            WorkspaceInfo wkInfo,
            RepositorySpec repSpec,
            ObjectInfo objectInfo,
            ObjectInfo ancestorChangesetInfo,
            EnumMergeType mergeType,
            ShowIncomingChangesFrom from,
            IWorkspaceWindow workspaceWindow,
            IViewSwitcher switcher,
            IHistoryViewLauncher historyViewLauncher,
            MergeViewLogic.IMergeController mergeController,
            MergeViewLogic.IGetWorkingBranch getWorkingBranch,
            CheckShelvedChanges.IUpdateShelvedChangesNotification updateShelvedChangesNotification,
            IRefreshView refreshView,
            IAssetStatusCache assetStatusCache,
            LaunchTool.IShowDownloadPlasticExeWindow showDownloadPlasticExeWindow,
            IPendingChangesUpdater pendingChangesUpdater,
            IncomingChangesUpdater incomingChangesUpdater,
            IShelvedChangesUpdater shelvedChangesUpdater,
            PlasticNotifier plasticNotifier,
            WindowStatusBar windowStatusBar,
            EditorWindow parentWindow,
            CalculatedMergeResult calculatedMergeResult,
            bool isIncomingMerge,
            bool isMergeFinished,
            bool showDiscardChangesButton)
        {
            MergeTab mergeTab = new MergeTab(
                wkInfo,
                repSpec,
                objectInfo,
                ancestorChangesetInfo,
                mergeType,
                from,
                workspaceWindow,
                switcher,
                historyViewLauncher,
                mergeController,
                getWorkingBranch,
                updateShelvedChangesNotification,
                refreshView,
                assetStatusCache,
                showDownloadPlasticExeWindow,
                pendingChangesUpdater,
                incomingChangesUpdater,
                shelvedChangesUpdater,
                plasticNotifier,
                windowStatusBar,
                parentWindow,
                isIncomingMerge,
                isMergeFinished,
                showDiscardChangesButton);

            mergeTab.mMergeViewLogic.CalculateMergeFromMergeResult(calculatedMergeResult);

            mergeTab.ProcessAllMerges();

            return mergeTab;
        }

        MergeTab(
            WorkspaceInfo wkInfo,
            RepositorySpec repSpec,
            ObjectInfo objectInfo,
            ObjectInfo ancestorChangesetInfo,
            EnumMergeType mergeType,
            ShowIncomingChangesFrom from,
            IWorkspaceWindow workspaceWindow,
            IViewSwitcher switcher,
            IHistoryViewLauncher historyViewLauncher,
            MergeViewLogic.IMergeController mergeController,
            MergeViewLogic.IGetWorkingBranch getWorkingBranch,
            CheckShelvedChanges.IUpdateShelvedChangesNotification updateShelvedChangesNotification,
            IRefreshView refreshView,
            IAssetStatusCache assetStatusCache,
            LaunchTool.IShowDownloadPlasticExeWindow showDownloadPlasticExeWindow,
            IPendingChangesUpdater pendingChangesUpdater,
            IncomingChangesUpdater incomingChangesUpdater,
            IShelvedChangesUpdater shelvedChangesUpdater,
            PlasticNotifier plasticNotifier,
            WindowStatusBar windowStatusBar,
            EditorWindow parentWindow,
            bool isIncomingMerge,
            bool isMergeFinished,
            bool showDiscardChangesButton)
        {
            mWkInfo = wkInfo;
            mRepSpec = repSpec;
            mObjectInfo = objectInfo;
            mAncestorObjectInfo = ancestorChangesetInfo;
            mMergeType = mergeType;
            mFrom = from;
            mWorkspaceWindow = workspaceWindow;
            mSwitcher = switcher;
            mHistoryViewLauncher = historyViewLauncher;
            mMergeController = mergeController;
            mUpdateShelvedChangesNotification = updateShelvedChangesNotification;
            mShelvedChangesUpdater = shelvedChangesUpdater;
            mRefreshView = refreshView;
            mAssetStatusCache = assetStatusCache;
            mShowDownloadPlasticExeWindow = showDownloadPlasticExeWindow;
            mIncomingChangesUpdater = incomingChangesUpdater;
            mWindowStatusBar = windowStatusBar;
            mParentWindow = parentWindow;
            mIsIncomingMerge = isIncomingMerge;
            mIsMergeFinished = isMergeFinished;
            mShowDiscardChangesButton = showDiscardChangesButton;

            mGuiMessage = new UnityPlasticGuiMessage();

            mEmptyStatePanel = new EmptyStatePanel(parentWindow.Repaint);

            mIsMergeTo = MergeTypeClassifier.IsMergeTo(mergeType);

            mTitleText = MergeViewTitle.Get(objectInfo, ancestorChangesetInfo, mergeType);

            BuildComponents(
                mWkInfo,
                mIsIncomingMerge,
                mIsMergeTo,
                mMergeController.IsShelvesetMerge());

            mMergeDialogParameters = PlasticGui.WorkspaceWindow.Merge.MergeSourceBuilder.
                BuildMergeDialogParameters(mergeType, mRepSpec);

            mMergeController.SetMergeDialogParameters(mMergeDialogParameters);

            mProgressControls = new ProgressControlsForViews();

            mDelayedClearUpdateSuccessAction = new DelayedActionBySecondsRunner(
                DelayedClearUpdateSuccess,
                UnityConstants.NOTIFICATION_CLEAR_INTERVAL);

            mMergeViewLogic = new MergeViewLogic(
                mWkInfo,
                mRepSpec,
                mergeType,
                mIsIncomingMerge,
                mMergeController,
                getWorkingBranch,
                plasticNotifier,
                from,
                null,
                pendingChangesUpdater,
                incomingChangesUpdater,
                shelvedChangesUpdater,
                null,
                this,
                NewChangesInWk.Build(mWkInfo, new BuildWorkspacekIsRelevantNewChange()),
                mProgressControls,
                null,
                new ApplyShelveReport(parentWindow));
        }

        internal void OnEnable()
        {
            mSearchField.downOrUpArrowKeyPressed +=
                SearchField_OnDownOrUpArrowKeyPressed;
        }

        internal void OnDisable()
        {
            mSearchField.downOrUpArrowKeyPressed -=
                SearchField_OnDownOrUpArrowKeyPressed;

            TreeHeaderSettings.Save(
                mMergeTreeView.multiColumnHeader.state,
                mIsIncomingMerge
                    ? UnityConstants.DEVELOPER_INCOMING_CHANGES_TABLE_SETTINGS_NAME
                    : UnityConstants.DEVELOPER_MERGE_TABLE_SETTINGS_NAME);
        }

        internal SerializableMergeTabState GetSerializableState()
        {
            return new SerializableMergeTabState(
                mRepSpec,
                mObjectInfo,
                mAncestorObjectInfo,
                mMergeType,
                mFrom,
                mIsIncomingMerge,
                mIsMergeFinished);
        }

        internal void Update()
        {
            mProgressControls.UpdateProgress(mParentWindow);
        }

        internal void OnGUI(Action closeMergeViewAction)
        {
            if (Event.current.type == EventType.Layout)
            {
                mHasPendingDirectoryConflicts = mMergeChangesTree != null &&
                    MergeChangesTreeParser.GetUnsolvedDirectoryConflictsCount(mMergeChangesTree) > 0;
                mIsOperationRunning = mProgressControls.IsOperationRunning();
            }

            DoTitle(
                mTitleText,
                mParentWindow,
                mMergeDialogParameters,
                mMergeViewLogic,
                mSearchField,
                mMergeTreeView,
                this,
                closeMergeViewAction);

            Rect viewRect = OverlayProgress.CaptureViewRectangle();

            DoConflictsTree(
                mMergeTreeView,
                mEmptyStatePanel,
                mDelayedClearUpdateSuccessAction,
                mIsOperationRunning,
                mIsUpdateSuccessful);

            List<MergeChangeInfo> selectedMergeChanges =
                mMergeTreeView.GetSelectedMergeChanges();

            if (MergeSelection.GetSelectedGroupInfo(
                    mMergeTreeView, mIsIncomingMerge).IsDirectoryConflictsSelection &&
                !Mouse.IsRightMouseButtonPressed(Event.current))
            {
                DoDirectoryConflictResolutionPanel(
                    selectedMergeChanges,
                    new Action<MergeChangeInfo>(ResolveDirectoryConflict),
                    mConflictResolutionStates,
                    mValidationLabel,
                    mMergeDialogParameters.CherryPicking,
                    mIsDirectoryResolutionPanelEnabled,
                    ref mConflictResolutionState);
            }

            DrawActionToolbar.Begin();

            DoActionToolbarMessage(
                mIsMessageLabelVisible,
                mMessageLabelText,
                mIsMergeFinished,
                mIsErrorMessageLabelVisible,
                mErrorMessageLabelText,
                mDirectoryConflictCount,
                mFileConflictCount,
                mChangesSummary,
                mSwitcher);

            if (mIsProcessMergesButtonVisible && !mIsMergeFinished)
            {
                DoProcessMergesButton(
                    mIsProcessMergesButtonEnabled && !mHasPendingDirectoryConflicts,
                    mProcessMergesButtonText,
                    mSwitcher,
                    mShowDownloadPlasticExeWindow,
                    mWorkspaceWindow,
                    mGuiMessage,
                    mMergeViewLogic,
                    mMergeDialogParameters.Options.Contributor,
                    mWkInfo,
                    AfterProcessMerges,
                    MergeSuccessfullyFinished);

                if (mShowDiscardChangesButton)
                {
                    DoDiscardChangesButton(
                        mWkInfo,
                        (ChangesetInfo)mObjectInfo,
                        mUpdateShelvedChangesNotification,
                        mShelvedChangesUpdater,
                        mRefreshView,
                        mSwitcher);
                }
            }

            if (mIsCancelMergesButtonVisible)
            {
                mIsCancelMergesButtonEnabled = DoCancelMergesButton(
                    mIsCancelMergesButtonEnabled,
                    mMergeViewLogic);
            }

            if (mHasPendingDirectoryConflicts)
            {
                GUILayout.Space(5);
                DoWarningMessage();
            }

            DrawActionToolbar.End();

            if (mProgressControls.HasNotification())
            {
                DrawProgressForViews.ForNotificationArea(
                    mProgressControls.ProgressData);
            }

            if (mIsOperationRunning)
            {
                OverlayProgress.DoOverlayProgress(
                    viewRect,
                    mProgressControls.ProgressData.ProgressPercent,
                    mProgressControls.ProgressData.ProgressMessage);
            }
        }

        internal void AutoRefresh()
        {
            mMergeViewLogic.AutoRefresh();
        }

        internal void ProcessMergeForTesting()
        {
            ProcessMerges(
                new List<string>(),
                null,
                mMergeDialogParameters.Options.Contributor);
        }

        internal void ResolveDirectoryConflict(MergeChangeInfo conflict)
        {
            ConflictResolutionState state;

            if (!mConflictResolutionStates.TryGetValue(conflict.DirectoryConflict, out state))
                return;

            List<DirectoryConflictResolutionData> conflictResolutions =
                new List<DirectoryConflictResolutionData>();

            AddConflictResolution(
                conflict,
                state.ResolveAction,
                state.RenameValue,
                conflictResolutions);

            MergeChangeInfo metaConflict =
                mMergeTreeView.GetMetaChange(conflict);

            if (metaConflict != null)
            {
                AddConflictResolution(
                    metaConflict,
                    state.ResolveAction,
                    MetaPath.GetMetaPath(state.RenameValue),
                    conflictResolutions);
            }

            if (state.IsApplyActionsForNextConflictsChecked)
            {
                foreach (MergeChangeInfo otherConflict in mMergeTreeView.GetSelectedMergeChanges())
                {
                    AddConflictResolution(
                        otherConflict,
                        state.ResolveAction,
                        state.RenameValue,
                        conflictResolutions);
                }
            }

            mMergeViewLogic.ResolveDirectoryConflicts(conflictResolutions);
        }

        bool IIncomingChangesTab.IsVisible{ get; set; }

        void IIncomingChangesTab.OnEnable()
        {
            OnEnable();
        }

        void IIncomingChangesTab.OnDisable()
        {
            OnDisable();
        }

        void IIncomingChangesTab.Update()
        {
            Update();
        }

        void IIncomingChangesTab.AutoRefresh()
        {
            AutoRefresh();
        }

        void IRefreshableView.Refresh()
        {
            mMergeViewLogic.Refresh();
        }

        void IMergeView.UpdateTitle(string title)
        {
            mTitleText = title;
        }

        void IIncomingChangesTab.OnGUI()
        {
            OnGUI(null);
        }

        void IMergeView.UpdateData(
            MergeChangesTree mergeChangesTree,
            ExplainMergeData explainMergeData,
            MergeSolvedFileConflicts solvedFileConflicts,
            bool isIncomingMerge,
            bool isMergeTo,
            bool mergeHasFinished)
        {
            HideMessage();

            ShowProcessMergesButton(
                MergeViewTexts.GetProcessMergesButtonText(
                    MergeChangesTreeParser.HasFileConflicts(mergeChangesTree),
                    mIsIncomingMerge,
                    mIsMergeTo));

            mMergeChangesTree = mergeChangesTree;

            mConflictResolutionStates.Clear();

            UpdateFileConflictsTree(
                mergeChangesTree,
                mMergeTreeView);

            UpdateOverview(mergeChangesTree, solvedFileConflicts);
        }

        void IMergeView.UpdateSolvedDirectoryConflicts()
        {
            if (mMergeChangesTree == null)
                return;

            mDirectoryConflictCount = MergeChangesTreeParser.GetUnsolvedDirectoryConflictsCount(
                mMergeChangesTree);
        }

        void IMergeView.UpdateSolvedFileConflicts(
            MergeSolvedFileConflicts solvedFileConflicts)
        {
            mMergeTreeView.UpdateSolvedFileConflicts(
                solvedFileConflicts);
        }

        void IMergeView.ShowMessage(
            string title,
            string message,
            bool isErrorMessage)
        {
            if (isErrorMessage)
            {
                mErrorMessageLabelText = message;
                mIsErrorMessageLabelVisible = true;
                return;
            }

            mMessageLabelText = message;
            mIsMessageLabelVisible = true;
            mIsMergeFinished = MergeViewTexts.IsMergeAlreadyProcessedMessage(message);
        }

        string IMergeView.GetComments(out bool bCancel)
        {
            bCancel = false;
            return string.Empty;
        }

        ObjectInfo IMergeView.GetObjectInfo()
        {
            return mObjectInfo;
        }

        void IMergeView.DisableProcessMergesButton()
        {
            mIsProcessMergesButtonEnabled = false;
        }

        void IMergeView.EnableResolveDirectoryConflictsControls()
        {
            mIsDirectoryResolutionPanelEnabled = true;
        }

        void IMergeView.DisableResolveDirectoryConflictsControls()
        {
            mIsDirectoryResolutionPanelEnabled = false;
        }

        void IMergeView.ShowCancelButton()
        {
            mIsCancelMergesButtonEnabled = true;
            mIsCancelMergesButtonVisible = true;
        }

        void IMergeView.HideCancelButton()
        {
            mIsCancelMergesButtonEnabled = false;
            mIsCancelMergesButtonVisible = false;
        }

        void IMergeViewMenuOperations.MergeContributors()
        {
            ProcessMerges(
                MergeSelection.GetPathsFromSelectedFileConflictsIncludingMeta(mMergeTreeView),
                PlasticExeLauncher.BuildForMergeSelectedFiles(mWkInfo, false, mShowDownloadPlasticExeWindow),
                MergeContributorType.MergeContributors);
        }

        void IMergeViewMenuOperations.MergeKeepingSourceChanges()
        {
            ProcessMerges(
                MergeSelection.GetPathsFromSelectedFileConflictsIncludingMeta(mMergeTreeView),
                null,
                MergeContributorType.KeepSource);
        }

        void IMergeViewMenuOperations.MergeKeepingWorkspaceChanges()
        {
            ProcessMerges(
                MergeSelection.GetPathsFromSelectedFileConflictsIncludingMeta(mMergeTreeView),
                null,
                MergeContributorType.KeepDestination);
        }

        SelectedMergeChangesGroupInfo IMergeViewMenuOperations.GetSelectedMergeChangesGroupInfo()
        {
            return GetSelectedMergeChangesGroupInfo.For(
                mMergeTreeView.GetSelectedMergeChanges(), mIsIncomingMerge);
        }

        void IMergeViewMenuOperations.DiffSourceWithDestination()
        {
            MergeChangeInfo mergeChange = MergeSelection.
                GetSingleSelectedMergeChange(mMergeTreeView);

            if (mergeChange == null)
                return;

            if (mergeChange.DirectoryConflict != null)
            {
                DiffSourceWithDestinationForDirectoryConflict(
                    mShowDownloadPlasticExeWindow,
                    mergeChange,
                    mWkInfo,
                    mIsIncomingMerge);
                return;
            }

            DiffSourceWithDestinationForFileConflict(
                mShowDownloadPlasticExeWindow,
                mergeChange,
                mWkInfo,
                mIsIncomingMerge);
        }

        void IMergeViewMenuOperations.DiffDestinationWithAncestor()
        {
            MergeChangeInfo mergeChange = MergeSelection.
                GetSingleSelectedMergeChange(mMergeTreeView);

            if (mergeChange == null)
                return;

            if (mergeChange.DirectoryConflict != null)
            {
                DiffDestinationWithAncestorForDirectoryConflict(
                    mShowDownloadPlasticExeWindow,
                    mergeChange,
                    mWkInfo,
                    mIsIncomingMerge);
                return;
            }

            DiffDestinationWithAncestorForFileConflict(
                mShowDownloadPlasticExeWindow,
                mergeChange,
                mWkInfo);
        }

        void IMergeViewMenuOperations.DiffSourceWithAncestor()
        {
            MergeChangeInfo mergeChange = MergeSelection.
                GetSingleSelectedMergeChange(mMergeTreeView);

            if (mergeChange == null)
                return;

            if (mergeChange.DirectoryConflict != null)
            {
                DiffSourceWithAncestorForDirectoryConflict(
                    mShowDownloadPlasticExeWindow,
                    mergeChange,
                    mWkInfo,
                    mIsIncomingMerge);
                return;
            }

            DiffSourceWithAncestorForFileConflict(
                mShowDownloadPlasticExeWindow,
                mergeChange,
                mWkInfo);
        }

        void IMergeViewMenuOperations.OpenSrcRevision()
        {
            MergeChangeInfo mergeChange = MergeSelection.
                GetSingleSelectedMergeChange(mMergeTreeView);

            if (mergeChange == null)
                return;

            OpenRevision.ForDifference(mRepSpec, mergeChange.DirectoryConflict.SrcDiff);
        }

        void IMergeViewMenuOperations.OpenDstRevision()
        {
            MergeChangeInfo mergeChange = MergeSelection.
                GetSingleSelectedMergeChange(mMergeTreeView);

            if (mergeChange == null)
                return;

            OpenRevision.ForDifference(mRepSpec, mergeChange.DirectoryConflict.DstDiff);
        }

        void IMergeViewMenuOperations.CopyFilePath(bool relativePath)
        {
            EditorGUIUtility.systemCopyBuffer = GetFilePathList.FromMergeChangeInfos(
                mMergeTreeView.GetSelectedMergeChanges(),
                relativePath,
                mWkInfo.ClientPath);
        }

        void MergeViewFileConflictMenu.IMetaMenuOperations.ShowHistory()
        {
            MergeChangeInfo mergeChangeInfo = MergeSelection.GetSingleSelectedMergeChange(mMergeTreeView);
            MergeChangeInfo metaChangeInfo = mMergeTreeView.GetMetaChange(mergeChangeInfo);
            RevisionInfo revInfo = mergeChangeInfo.GetRevision();

            mHistoryViewLauncher.ShowHistoryView(
                metaChangeInfo.GetMount().RepSpec,
                revInfo.ItemId,
                metaChangeInfo.GetPath(),
                revInfo.Type == EnumRevisionType.enDirectory);
        }

        void MergeViewFileConflictMenu.IMetaMenuOperations.DiffDestinationWithAncestor()
        {
            MergeChangeInfo mergeChange = MergeSelection.
                GetSingleSelectedMergeChange(mMergeTreeView);

            if (mergeChange == null)
                return;

            DiffDestinationWithAncestorForFileConflict(
                mShowDownloadPlasticExeWindow,
                mMergeTreeView.GetMetaChange(mergeChange),
                mWkInfo);
        }

        void IMergeViewMenuOperations.ShowHistory()
        {
            MergeChangeInfo mergeChangeInfo = MergeSelection.GetSingleSelectedMergeChange(mMergeTreeView);
            RevisionInfo revInfo = mergeChangeInfo.GetRevision();

            mHistoryViewLauncher.ShowHistoryView(
                mergeChangeInfo.GetMount().RepSpec,
                revInfo.ItemId,
                mergeChangeInfo.GetPath(),
                revInfo.Type == EnumRevisionType.enDirectory);
        }

        void MergeViewFileConflictMenu.IMetaMenuOperations.DiffSourceWithAncestor()
        {
            MergeChangeInfo mergeChange = MergeSelection.
                GetSingleSelectedMergeChange(mMergeTreeView);

            if (mergeChange == null)
                return;

            DiffSourceWithAncestorForFileConflict(
                mShowDownloadPlasticExeWindow,
                mMergeTreeView.GetMetaChange(mergeChange),
                mWkInfo);
        }

        void MergeViewFileConflictMenu.IMetaMenuOperations.DiffSourceWithDestination()
        {
            MergeChangeInfo mergeChange = MergeSelection.
                GetSingleSelectedMergeChange(mMergeTreeView);

            if (mergeChange == null)
                return;

            DiffSourceWithDestinationForFileConflict(
                mShowDownloadPlasticExeWindow,
                mMergeTreeView.GetMetaChange(mergeChange),
                mWkInfo,
                mIsIncomingMerge);
        }

        bool MergeViewFileConflictMenu.IMetaMenuOperations.SelectionHasMeta()
        {
            return mMergeTreeView.SelectionHasMeta();
        }

        void SearchField_OnDownOrUpArrowKeyPressed()
        {
            mMergeTreeView.SetFocusAndEnsureSelectedItem();
        }

        void UpdateOverview(
            MergeChangesTree mergeChangesTree,
            MergeSolvedFileConflicts solvedFileConflicts)
        {
            mChangesSummary = MergeChangesTreeParser.
                GetChangesToApplySummary(mergeChangesTree);

            mFileConflictCount = MergeChangesTreeParser.GetUnsolvedFileConflictsCount(
                mergeChangesTree, solvedFileConflicts);

            mDirectoryConflictCount = MergeChangesTreeParser.GetUnsolvedDirectoryConflictsCount(
                mergeChangesTree);
        }

        void HideMessage()
        {
            mMessageLabelText = string.Empty;
            mIsMessageLabelVisible = false;
            mIsMergeFinished = false;

            mErrorMessageLabelText = string.Empty;
            mIsErrorMessageLabelVisible = false;
        }

        void DelayedClearUpdateSuccess()
        {
            mIsUpdateSuccessful = false;

            UpdateEmptyStateMessage();
        }

        void IMergeViewMenuOperations.ShowAnnotate()
        {
        }

        void AfterProcessMerges(UpdateProgress progress)
        {
            RefreshAsset.AfterLongAssetOperation(
                mAssetStatusCache,
                ProjectPackages.ShouldBeResolvedFromUpdateProgress(mWkInfo, progress));
        }

        void ShowProcessMergesButton(string processMergesButtonText)
        {
            mProcessMergesButtonText = processMergesButtonText;
            mIsProcessMergesButtonEnabled = true;
            mIsProcessMergesButtonVisible = true;
        }

        void ProcessMerges(
            List<string> selectedPaths,
            IToolLauncher toolLauncher,
            MergeContributorType contributorType)
        {
            ProcessMerges(
                mMergeViewLogic,
                contributorType,
                mWorkspaceWindow,
                mSwitcher,
                toolLauncher,
                mGuiMessage,
                selectedPaths,
                AfterProcessMerges,
                MergeSuccessfullyFinished);
        }

        void MergeSuccessfullyFinished()
        {
            mIsUpdateSuccessful = true;
            UpdateEmptyStateMessage();
        }

        void ProcessAllMerges()
        {
            ProcessMerges(
                new List<string>(),
                PlasticExeLauncher.BuildForMergeSelectedFiles(mWkInfo, false, mShowDownloadPlasticExeWindow),
                mMergeDialogParameters.Options.Contributor);
        }

        void DoConflictsTree(
            MergeTreeView mergeTreeView,
            EmptyStatePanel emptyStatePanel,
            DelayedActionBySecondsRunner delayedClearUpdateSuccessAction,
            bool isOperationRunning,
            bool isUpdateSuccessful)
        {
            using (new EditorGUI.DisabledScope(isOperationRunning))
            {
                Rect rect = GUILayoutUtility.GetRect(0, 100000, 0, 100000);

                mergeTreeView.OnGUI(rect);

                if (isOperationRunning)
                    return;

                if (mergeTreeView.GetTotalItemCount() == 0)
                {
                    DrawEmptyState(
                        rect,
                        emptyStatePanel,
                        delayedClearUpdateSuccessAction,
                        isUpdateSuccessful);
                    return;
                }

                if (isUpdateSuccessful)
                    NotifySuccessInStatusBar();
            }
        }

        void NotifySuccessInStatusBar()
        {
            mWindowStatusBar.Notify(
                new GUIContentNotification(
                    PlasticLocalization.Name.WorkspaceUpdateCompleted.GetString()),
                UnityEditor.MessageType.None,
                Images.GetStepOkIcon());
            mIsUpdateSuccessful = false;
        }

        static void DiffSourceWithDestinationForDirectoryConflict(
            LaunchTool.IShowDownloadPlasticExeWindow showDownloadPlasticExeWindow,
            MergeChangeInfo mergeChange,
            WorkspaceInfo wkInfo,
            bool isIncomingMerge)
        {
            DirectoryConflict conflict = mergeChange.DirectoryConflict;
            MountPointWithPath mountPoint = mergeChange.GetMount();

            DiffOperation.DiffRevisions(
                wkInfo,
                mountPoint.RepSpec,
                conflict.SrcDiff.RevInfo,
                conflict.DstDiff.RevInfo,
                mountPoint.GetFullCmPath(conflict.SrcDiff.Path),
                mountPoint.GetFullCmPath(conflict.DstDiff.Path),
                isIncomingMerge,
                PlasticExeLauncher.BuildForDiffContributors(wkInfo, false, showDownloadPlasticExeWindow),
                imageDiffLauncher: null);
        }

        static void DiffDestinationWithAncestorForDirectoryConflict(
            LaunchTool.IShowDownloadPlasticExeWindow showDownloadPlasticExeWindow,
            MergeChangeInfo mergeChange,
            WorkspaceInfo wkInfo,
            bool isIncomingMerge)
        {
            DirectoryConflict conflict = mergeChange.DirectoryConflict;
            MountPointWithPath mountPoint = mergeChange.GetMount();

            DiffOperation.DiffRevisions(
                wkInfo,
                mountPoint.RepSpec,
                conflict.DstDiff.Base,
                conflict.DstDiff.RevInfo,
                mountPoint.GetFullCmPath(conflict.DstDiff.Path),
                mountPoint.GetFullCmPath(conflict.DstDiff.Path),
                isIncomingMerge,
                PlasticExeLauncher.BuildForDiffContributors(wkInfo, false, showDownloadPlasticExeWindow),
                imageDiffLauncher: null);
        }

        static void DiffSourceWithAncestorForDirectoryConflict(
            LaunchTool.IShowDownloadPlasticExeWindow showDownloadPlasticExeWindow,
            MergeChangeInfo mergeChange,
            WorkspaceInfo wkInfo,
            bool isIncomingMerge)
        {
            DirectoryConflict conflict = mergeChange.DirectoryConflict;
            MountPointWithPath mountPoint = mergeChange.GetMount();

            DiffOperation.DiffRevisions(
                wkInfo,
                mountPoint.RepSpec,
                conflict.SrcDiff.Base,
                conflict.SrcDiff.RevInfo,
                mountPoint.GetFullCmPath(conflict.SrcDiff.Path),
                mountPoint.GetFullCmPath(conflict.SrcDiff.Path),
                isIncomingMerge,
                PlasticExeLauncher.BuildForDiffContributors(wkInfo, false, showDownloadPlasticExeWindow),
                imageDiffLauncher: null);
        }

        static void DiffDestinationWithAncestorForFileConflict(
            LaunchTool.IShowDownloadPlasticExeWindow showDownloadPlasticExeWindow,
            MergeChangeInfo mergeChange,
            WorkspaceInfo wkInfo)
        {
            FileConflict conflict = mergeChange.FileConflict;
            MountPointWithPath mountPoint = mergeChange.GetMount();

            string path = mountPoint.GetFullCmPath(mergeChange.GetPath());

            DiffOperation.DiffRevisions(
                wkInfo,
                mountPoint.RepSpec,
                conflict.Base,
                conflict.DstDiff.RevInfo,
                path,
                path,
                false,
                PlasticExeLauncher.BuildForDiffContributors(wkInfo, false, showDownloadPlasticExeWindow),
                imageDiffLauncher: null);
        }

        static void DiffSourceWithDestinationForFileConflict(
            LaunchTool.IShowDownloadPlasticExeWindow showDownloadPlasticExeWindow,
            MergeChangeInfo mergeChange,
            WorkspaceInfo wkInfo,
            bool isIncomingMerge)
        {
            PlasticExeLauncher plasticExeLauncher =
                PlasticExeLauncher.BuildForDiffContributors(wkInfo, false, showDownloadPlasticExeWindow);

            if (isIncomingMerge)
            {
                DiffOperation.DiffYoursWithIncoming(
                    wkInfo,
                    mergeChange.GetMount(),
                    mergeChange.GetRevision(),
                    mergeChange.GetPath(),
                    plasticExeLauncher,
                    imageDiffLauncher: null);
                return;
            }

            FileConflict conflict = mergeChange.FileConflict;
            MountPointWithPath mountPoint = mergeChange.GetMount();

            string path = mountPoint.GetFullCmPath(mergeChange.GetPath());

            DiffOperation.DiffRevisions(
                wkInfo,
                mountPoint.RepSpec,
                conflict.SrcDiff.RevInfo,
                conflict.DstDiff.RevInfo,
                path,
                path,
                false,
                plasticExeLauncher,
                imageDiffLauncher: null);
        }

        static void UpdateFileConflictsTree(
            MergeChangesTree mergeChangesTree,
            MergeTreeView mergeTreeView)
        {
            UnityMergeTree unityMergeTree = UnityMergeTree.BuildMergeCategories(mergeChangesTree);

            mergeTreeView.BuildModel(unityMergeTree);
            mergeTreeView.Refilter();
            mergeTreeView.Sort();
            mergeTreeView.Reload();

            mergeTreeView.SelectFirstUnsolvedDirectoryConflict();
        }

        static void DiffSourceWithAncestorForFileConflict(
            LaunchTool.IShowDownloadPlasticExeWindow showDownloadPlasticExeWindow,
            MergeChangeInfo mergeChange,
            WorkspaceInfo wkInfo)
        {
            FileConflict conflict = mergeChange.FileConflict;
            MountPointWithPath mountPoint = mergeChange.GetMount();

            string path = mountPoint.GetFullCmPath(mergeChange.GetPath());

            DiffOperation.DiffRevisions(
                wkInfo,
                mountPoint.RepSpec,
                conflict.Base,
                conflict.SrcDiff.RevInfo,
                path,
                path,
                false,
                PlasticExeLauncher.BuildForDiffContributors(wkInfo, false, showDownloadPlasticExeWindow),
                imageDiffLauncher: null);
        }

        static void ProcessMerges(
            MergeViewLogic mergeViewLogic,
            MergeContributorType contributorType,
            IWorkspaceWindow workspaceWindow,
            IViewSwitcher switcher,
            IToolLauncher toolLauncher,
            GuiMessage.IGuiMessage guiMessage,
            List<string> selectedPaths,
            EndOperationDelegateForUpdateProgress afterProcessMergesAction,
            Action successOperationDelegate)
        {
            mergeViewLogic.ProcessMerges(
                workspaceWindow,
                switcher,
                guiMessage,
                selectedPaths,
                null,
                contributorType,
                toolLauncher,
                false,
                RefreshAsset.BeforeLongAssetOperation,
                afterProcessMergesAction,
                successOperationDelegate);
        }

        static void AddConflictResolution(
            MergeChangeInfo conflict,
            DirectoryConflictResolveActions resolveAction,
            string renameValue,
            List<DirectoryConflictResolutionData> conflictResolutions)
        {
            conflictResolutions.Add(new DirectoryConflictResolutionData(
                conflict.DirectoryConflict,
                conflict.Xlink,
                conflict.GetMount().Mount,
                resolveAction,
                renameValue));
        }

        static void DoTitle(
            string title,
            EditorWindow parentWindow,
            MergeDialogParameters mergeDialogParameters,
            MergeViewLogic mergeViewLogic,
            SearchField searchField,
            MergeTreeView mergeTreeView,
            IRefreshableView view,
            Action closeMergeViewAction)
        {
            EditorGUILayout.BeginHorizontal(EditorStyles.toolbar);

            if (GUILayout.Button(
                    new GUIContent(Images.GetRefreshIcon(),
                        PlasticLocalization.Name.RefreshButton.GetString()),
                    UnityStyles.ToolbarButtonLeft,
                    GUILayout.Width(UnityConstants.TOOLBAR_ICON_BUTTON_WIDTH)))
            {
                view.Refresh();
            }

            GUILayout.Label(title, UnityStyles.MergeTab.TitleLabel);

            GUILayout.FlexibleSpace();

            if (GUILayout.Button(
                    PlasticLocalization.Name.MergeOptionsButton.GetString(),
                    EditorStyles.toolbarButton))
            {
                ShowMergeOptions(parentWindow, mergeDialogParameters, mergeViewLogic);
                EditorGUIUtility.ExitGUI();
            }

            GUILayout.Space(2);

            DrawSearchField.For(
                searchField,
                mergeTreeView,
                UnityConstants.SEARCH_FIELD_WIDTH);

            if (closeMergeViewAction != null &&
                GUILayout.Button(Images.GetCloseIcon(), UnityStyles.CloseViewIconButtonStyle))
            {
                closeMergeViewAction();
            }

            EditorGUILayout.EndHorizontal();
        }

        static void DrawEmptyState(
            Rect rect,
            EmptyStatePanel emptyStatePanel,
            DelayedActionBySecondsRunner delayedClearUpdateSuccessAction,
            bool isUpdateSuccessful)
        {
            if (isUpdateSuccessful && !delayedClearUpdateSuccessAction.IsRunning)
                delayedClearUpdateSuccessAction.Run();

            emptyStatePanel.OnGUI(rect);
        }

        static void DoDirectoryConflictResolutionPanel(
            List<MergeChangeInfo> selectedChangeInfos,
            Action<MergeChangeInfo> resolveDirectoryConflictAction,
            Dictionary<DirectoryConflict, ConflictResolutionState> conflictResolutionStates,
            GUIContent validationLabel,
            bool isCherrypickMerge,
            bool isDirectoryResolutionPanelEnabled,
            ref ConflictResolutionState conflictResolutionState)
        {
            MergeChangeInfo selectedDirectoryConflict = selectedChangeInfos[0];

            if (selectedDirectoryConflict.DirectoryConflict.IsResolved())
                return;

            DirectoryConflictUserInfo conflictUserInfo;
            DirectoryConflictAction[] conflictActions;

            DirectoryConflictResolutionInfo.FromDirectoryConflict(
                selectedDirectoryConflict.GetMount(),
                selectedDirectoryConflict.DirectoryConflict,
                isCherrypickMerge,
                out conflictUserInfo,
                out conflictActions);

            conflictResolutionState = GetConflictResolutionState(
                selectedDirectoryConflict.DirectoryConflict,
                conflictActions,
                conflictResolutionStates);

            int pendingSelectedConflictsCount = GetPendingConflictsCount(
                selectedChangeInfos);

            DrawDirectoryResolutionPanel.ForConflict(
                selectedDirectoryConflict,
                (pendingSelectedConflictsCount <= 1) ? 0 : pendingSelectedConflictsCount - 1,
                conflictUserInfo,
                conflictActions,
                resolveDirectoryConflictAction,
                validationLabel,
                isDirectoryResolutionPanelEnabled,
                ref conflictResolutionState);
        }

        static void DoActionToolbarMessage(
            bool isMessageLabelVisible,
            string messageLabelText,
            bool isMergeFinished,
            bool isErrorMessageLabelVisible,
            string errorMessageLabelText,
            int directoryConflictCount,
            int fileConflictCount,
            MergeViewTexts.ChangesToApplySummary changesSummary,
            IViewSwitcher viewSwitcher)
        {
            if (isMergeFinished)
            {
                DoMergeAlreadyProcessedArea(viewSwitcher);
                return;
            }

            if (isMessageLabelVisible)
                DoInfoMessage(messageLabelText);

            if (isErrorMessageLabelVisible)
            {
                DoErrorMessage(errorMessageLabelText);
            }

            if (!isMessageLabelVisible && !isErrorMessageLabelVisible)
            {
                DrawMergeOverview.For(
                    directoryConflictCount,
                    fileConflictCount,
                    changesSummary);
            }
        }

        static void ShowMergeOptions(
            EditorWindow parentWindow,
            MergeDialogParameters mergeDialogParameters,
            MergeViewLogic mergeViewLogic)
        {
            bool previousMergeTrackingValue =
                mergeDialogParameters.Options.IgnoreMergeTracking;

            ChangesetSpec previousAncestor = mergeDialogParameters.AncestorSpec;
            bool bIsPrevManualStrategy = mergeDialogParameters.Strategy == MergeStrategy.Manual;

            if (!MergeOptionsDialog.MergeOptions(parentWindow, mergeDialogParameters))
                return;

            if (!MergeDialogParameters.AreParametersChanged(
                    previousMergeTrackingValue,
                    previousAncestor,
                    bIsPrevManualStrategy,
                    mergeDialogParameters))
                return;

            mergeViewLogic.Refresh();
        }

        static void DoProcessMergesButton(
            bool isEnabled,
            string processMergesButtonText,
            IViewSwitcher switcher,
            LaunchTool.IShowDownloadPlasticExeWindow showDownloadPlasticExeWindow,
            IWorkspaceWindow workspaceWindow,
            GuiMessage.IGuiMessage guiMessage,
            MergeViewLogic mergeViewLogic,
            MergeContributorType contributorType,
            WorkspaceInfo wkInfo,
            EndOperationDelegateForUpdateProgress afterProcessMergesAction,
            Action successOperationDelegate)
        {
            GUI.enabled = isEnabled;

            if (DrawActionButton.For(processMergesButtonText))
            {
                ProcessMerges(
                    mergeViewLogic,
                    contributorType,
                    workspaceWindow,
                    switcher,
                    PlasticExeLauncher.BuildForResolveConflicts(wkInfo, false, showDownloadPlasticExeWindow),
                    guiMessage,
                    new List<string>(),
                    afterProcessMergesAction,
                    successOperationDelegate);
            }

            GUI.enabled = true;
        }

        static void DoDiscardChangesButton(
            WorkspaceInfo wkInfo,
            ChangesetInfo automaticShelvesetToDiscard,
            CheckShelvedChanges.IUpdateShelvedChangesNotification updateShelvedChangesNotification,
            IShelvedChangesUpdater shelvedChangesUpdater,
            IRefreshView refreshView,
            IViewSwitcher viewSwitcher)
        {
            GUILayout.Space(3);

            if (DrawActionButton.For(PlasticLocalization.Name.DiscardChangesButton.GetString()))
            {
                ShelvedChangesNotificationPanelOperations.DiscardShelvedChanges(
                    wkInfo,
                    automaticShelvesetToDiscard,
                    updateShelvedChangesNotification,
                    shelvedChangesUpdater,
                    viewSwitcher,
                    refreshView);
            }
        }

        static bool DoCancelMergesButton(
            bool isEnabled,
            MergeViewLogic mergeViewLogic)
        {
            bool shouldCancelMergesButtonEnabled = true;

            GUI.enabled = isEnabled;

            GUILayout.Space(3);

            if (DrawActionButton.For(PlasticLocalization.GetString(
                    PlasticLocalization.Name.CancelButton)))
            {
                mergeViewLogic.Cancel();

                shouldCancelMergesButtonEnabled = false;
            }

            GUI.enabled = true;

            return shouldCancelMergesButtonEnabled;
        }

        static void DoWarningMessage()
        {
            string label = PlasticLocalization.GetString(PlasticLocalization.Name.SolveConflictsInLable);

            GUILayout.Label(
                new GUIContent(label, Images.GetWarnIcon()),
                UnityStyles.HeaderWarningLabel);
        }

        static void DoInfoMessage(string message)
        {
            EditorGUILayout.BeginHorizontal();

            GUILayout.Label(message, UnityStyles.MergeTab.InfoLabel);

            EditorGUILayout.EndHorizontal();
        }

        static void DoMergeAlreadyProcessedArea(IViewSwitcher viewSwitcher)
        {
            EditorGUILayout.BeginHorizontal();

            GUILayout.Label(
                PlasticLocalization.Name.MergeAlreadyProcessedOpenPendingChangesText.GetString(),
                UnityStyles.MergeTab.InfoLabel);

            if (GUILayout.Button(
                    PlasticLocalization.Name.MergeAlreadyProcessedOpenPendingChangesLinkText.GetString(),
                    UnityStyles.MergeTab.LinkLabel))
            {
                viewSwitcher.ShowPendingChanges();
                viewSwitcher.DisableMergeView();
            }

            EditorGUIUtility.AddCursorRect(
                GUILayoutUtility.GetLastRect(), MouseCursor.Link);

            GUILayout.Label(
                PlasticLocalization.Name.MergeAlreadyProcessedOpenPreferencesText.GetString(),
                UnityStyles.MergeTab.InfoLabel);

            if (GUILayout.Button(
                    PlasticLocalization.Name.MergeAlreadyProcessedOpenPreferencesLinkText.GetString(),
                    UnityStyles.MergeTab.LinkLabel))
            {
                OpenUVCSProjectSettings.InDiffAndMergeFoldout();
            }

            EditorGUIUtility.AddCursorRect(
                GUILayoutUtility.GetLastRect(), MouseCursor.Link);

            EditorGUILayout.EndHorizontal();
        }

        static void DoErrorMessage(string message)
        {
            EditorGUILayout.BeginHorizontal();

            GUILayout.Label(message, UnityStyles.MergeTab.RedPendingConflictsOfTotalLabel);

            EditorGUILayout.EndHorizontal();
        }

        static string GetEmptyStateMessage(
            bool isUpdateSuccessful,
            bool isIncomingMerge,
            string searchString)
        {
            if (isUpdateSuccessful)
                return PlasticLocalization.Name.WorkspaceUpdateCompleted.GetString();

            if (isIncomingMerge)
            {
                if (!string.IsNullOrEmpty(searchString))
                    return PlasticLocalization.Name.NoIncomingChangesMatchingFilters.GetString();

                return PlasticLocalization.Name.NoIncomingChangesFound.GetString();
            }

            if (!string.IsNullOrEmpty(searchString))
                return PlasticLocalization.Name.NoMergeChangesMatchingFilters.GetString();

            return PlasticLocalization.Name.NoMergeChanges.GetString();
        }

        void BuildComponents(
            WorkspaceInfo wkInfo,
            bool isIncomingMerge,
            bool isMergeTo,
            bool isShelvesetMerge)
        {
            mSearchField = new SearchField();
            mSearchField.downOrUpArrowKeyPressed +=
                SearchField_OnDownOrUpArrowKeyPressed;

            MergeTreeHeaderState mergeHeaderState =
                MergeTreeHeaderState.GetDefault();

            TreeHeaderSettings.Load(mergeHeaderState,
                isIncomingMerge ?
                    UnityConstants.DEVELOPER_INCOMING_CHANGES_TABLE_SETTINGS_NAME :
                    UnityConstants.DEVELOPER_MERGE_TABLE_SETTINGS_NAME,
                (int)MergeTreeColumn.Path, true);

            mMenu = new MergeViewMenu(this, this, isIncomingMerge, isMergeTo, isShelvesetMerge);
            mMergeTreeView = new MergeTreeView(
                wkInfo, mergeHeaderState,
                MergeTreeHeaderState.GetColumnNames(),
                mMenu,
                UpdateEmptyStateMessage);

            mMergeTreeView.Reload();

            UpdateEmptyStateMessage();
        }

        void UpdateEmptyStateMessage()
        {
            string searchString = mMergeTreeView.searchString;
            string message = GetEmptyStateMessage(mIsUpdateSuccessful, mIsIncomingMerge, searchString);
            mEmptyStatePanel.UpdateContent(message, bDrawOkIcon: mIsUpdateSuccessful);
        }

        static ConflictResolutionState GetConflictResolutionState(
            DirectoryConflict directoryConflict,
            DirectoryConflictAction[] conflictActions,
            Dictionary<DirectoryConflict, ConflictResolutionState> conflictResoltionStates)
        {
            ConflictResolutionState result;

            if (conflictResoltionStates.TryGetValue(directoryConflict, out result))
                return result;

            result = ConflictResolutionState.Build(directoryConflict, conflictActions);

            conflictResoltionStates.Add(directoryConflict, result);
            return result;
        }

        static int GetPendingConflictsCount(
            List<MergeChangeInfo> selectedChangeInfos)
        {
            int result = 0;
            foreach (MergeChangeInfo changeInfo in selectedChangeInfos)
            {
                if (changeInfo.DirectoryConflict.IsResolved())
                    continue;

                result++;
            }

            return result;
        }

        bool mIsProcessMergesButtonVisible;
        bool mIsCancelMergesButtonVisible;
        bool mIsMessageLabelVisible;
        bool mIsErrorMessageLabelVisible;
        bool mIsMergeFinished;
        bool mIsProcessMergesButtonEnabled;
        bool mIsCancelMergesButtonEnabled;
        bool mIsDirectoryResolutionPanelEnabled = true;
        bool mHasPendingDirectoryConflicts;
        bool mIsOperationRunning;
        bool mIsUpdateSuccessful;
        string mTitleText;
        string mMessageLabelText;
        string mErrorMessageLabelText;
        string mProcessMergesButtonText;

        int mDirectoryConflictCount;
        int mFileConflictCount;
        MergeViewTexts.ChangesToApplySummary mChangesSummary;
        Dictionary<DirectoryConflict, ConflictResolutionState> mConflictResolutionStates =
            new Dictionary<DirectoryConflict, ConflictResolutionState>();
        ConflictResolutionState mConflictResolutionState;

        SearchField mSearchField;
        MergeTreeView mMergeTreeView;
        MergeChangesTree mMergeChangesTree;
        MergeViewMenu mMenu;
        MergeDialogParameters mMergeDialogParameters;

        readonly GUIContent mValidationLabel = new GUIContent(string.Empty, Images.GetWarnIcon());
        readonly MergeViewLogic mMergeViewLogic;
        readonly DelayedActionBySecondsRunner mDelayedClearUpdateSuccessAction;
        readonly ProgressControlsForViews mProgressControls;
        readonly EmptyStatePanel mEmptyStatePanel;
        readonly GuiMessage.IGuiMessage mGuiMessage;
        readonly bool mIsMergeTo;
        readonly bool mShowDiscardChangesButton;
        readonly bool mIsIncomingMerge;
        readonly EditorWindow mParentWindow;
        readonly WindowStatusBar mWindowStatusBar;
        readonly IncomingChangesUpdater mIncomingChangesUpdater;
        readonly LaunchTool.IShowDownloadPlasticExeWindow mShowDownloadPlasticExeWindow;
        readonly IAssetStatusCache mAssetStatusCache;
        readonly IRefreshView mRefreshView;
        readonly IShelvedChangesUpdater mShelvedChangesUpdater;
        readonly CheckShelvedChanges.IUpdateShelvedChangesNotification mUpdateShelvedChangesNotification;
        readonly MergeViewLogic.IMergeController mMergeController;
        readonly IHistoryViewLauncher mHistoryViewLauncher;
        readonly IViewSwitcher mSwitcher;
        readonly IWorkspaceWindow mWorkspaceWindow;
        readonly ShowIncomingChangesFrom mFrom;
        readonly EnumMergeType mMergeType;
        readonly ObjectInfo mAncestorObjectInfo;
        readonly ObjectInfo mObjectInfo;
        readonly RepositorySpec mRepSpec;
        readonly WorkspaceInfo mWkInfo;
    }
}