"""Provides widgets related to branches"""
from functools import partial

from qtpy import QtWidgets
from qtpy.QtCore import Qt
from qtpy.QtCore import Signal

from ..git import STDOUT
from ..i18n import N_
from ..interaction import Interaction
from ..models import main as main_mod
from ..widgets import completion
from ..widgets import defs
from ..widgets import standard
from ..qtutils import get
from .. import cmds
from .. import gitcmds
from .. import hotkeys
from .. import icons
from .. import qtutils
from . import log
from . import text


def defer_func(parent, title, func, *args, **kwargs):
    """Return a QAction bound against a partial func with arguments"""
    return qtutils.add_action(parent, title, partial(func, *args, **kwargs))


def add_branch_to_menu(menu, branch, remote_branch, remote, upstream, func):
    """Add a remote branch to the context menu"""
    branch_remote, _ = gitcmds.parse_remote_branch(remote_branch)
    if branch_remote != remote:
        menu.addSeparator()
    action = defer_func(menu, remote_branch, func, branch, remote_branch)
    if remote_branch == upstream:
        action.setIcon(icons.star())
    menu.addAction(action)
    return branch_remote


class AsyncGitActionTask(qtutils.Task):
    """Run git action asynchronously"""

    def __init__(self, git_helper, action, args, kwarg, update_refs, update_status):
        qtutils.Task.__init__(self)
        self.git_helper = git_helper
        self.action = action
        self.args = args
        self.kwarg = kwarg
        self.update_refs = update_refs
        self.update_status = update_status

    def task(self):
        """Runs action and captures the result"""
        git_action = getattr(self.git_helper, self.action)
        return git_action(*self.args, **self.kwarg)


class BranchesWidget(QtWidgets.QFrame):
    """A widget for displaying and performing operations on branches"""

    def __init__(self, context, parent):
        QtWidgets.QFrame.__init__(self, parent)
        self.model = model = context.model

        tooltip = N_('Toggle the branches filter')
        icon = icons.ellipsis()
        self.filter_button = qtutils.create_action_button(tooltip=tooltip, icon=icon)

        self.order_icons = (
            icons.alphabetical(),
            icons.reverse_chronological(),
        )
        tooltip_order = N_(
            'Set the sort order for branches and tags.\n'
            'Toggle between date-based and version-name-based sorting.'
        )
        icon = self.order_icon(model.ref_sort)
        self.sort_order_button = qtutils.create_action_button(
            tooltip=tooltip_order, icon=icon
        )

        self.tree = BranchesTreeWidget(context, parent=self)
        self.filter_widget = BranchesFilterWidget(self.tree)
        self.filter_widget.hide()

        self.setFocusProxy(self.tree)
        self.setToolTip(N_('Branches'))

        self.main_layout = qtutils.vbox(
            defs.no_margin, defs.spacing, self.filter_widget, self.tree
        )
        self.setLayout(self.main_layout)

        self.toggle_action = qtutils.add_action(
            self, tooltip, self.toggle_filter, hotkeys.FILTER
        )
        qtutils.connect_button(self.filter_button, self.toggle_filter)
        qtutils.connect_button(
            self.sort_order_button, cmds.run(cmds.CycleReferenceSort, context)
        )

        model.refs_updated.connect(self.refresh, Qt.QueuedConnection)

    def toggle_filter(self):
        shown = not self.filter_widget.isVisible()
        self.filter_widget.setVisible(shown)
        if shown:
            self.filter_widget.setFocus()
        else:
            self.tree.setFocus()

    def order_icon(self, idx):
        return self.order_icons[idx % len(self.order_icons)]

    def refresh(self):
        icon = self.order_icon(self.model.ref_sort)
        self.sort_order_button.setIcon(icon)

    # Qt overrides
    def setFont(self, font):
        """Forward setFont() to child widgets"""
        super().setFont(font)
        self.tree.setFont(font)


class BranchesTreeWidget(standard.TreeWidget):
    """A tree widget for displaying branches"""

    updated = Signal()

    def __init__(self, context, parent=None):
        standard.TreeWidget.__init__(self, parent)

        self.context = context

        self.setSelectionMode(QtWidgets.QAbstractItemView.SingleSelection)
        self.setHeaderHidden(True)
        self.setAlternatingRowColors(False)
        self.setColumnCount(1)
        self.setExpandsOnDoubleClick(False)

        self.current_branch = None
        self.tree_helper = BranchesTreeHelper(self)
        self.git_helper = GitHelper(context)
        self.runtask = qtutils.RunTask(parent=self)

        self._visible = False
        self._needs_refresh = False
        self._branch_details_in_progress = False
        self._tree_states = None
        self._name_filter = ''

        self.updated.connect(self.refresh, type=Qt.QueuedConnection)
        context.model.updated.connect(self.updated)

        # Expand items when they are clicked
        self.clicked.connect(self._toggle_expanded)

        # Checkout branch when double clicked
        self.doubleClicked.connect(self.checkout_action)

    def set_name_filter(self, value):
        """Update the name filter and rebuild the tree to include only matching refs"""
        self._name_filter = value
        self.refresh()

    def refresh(self):
        """Refresh the UI widgets to match the current state"""
        self._needs_refresh = True
        self._refresh()

    def _refresh(self):
        """Refresh the UI to match the updated state"""
        # There is no need to refresh the UI when this widget is inactive.
        if not self._visible:
            return
        model = self.context.model
        self.current_branch = model.currentbranch

        self._tree_states = self._save_tree_state()
        ellipsis = icons.ellipsis()

        local_tree = create_tree_entries(model.local_branches, self._name_filter)
        local_tree.basename = N_('Local')
        local = create_toplevel_item(local_tree, icon=icons.branch(), ellipsis=ellipsis)

        remote_tree = create_tree_entries(model.remote_branches, self._name_filter)
        remote_tree.basename = N_('Remote')
        remote = create_toplevel_item(
            remote_tree, icon=icons.branch(), ellipsis=ellipsis
        )

        tags_tree = create_tree_entries(model.tags, self._name_filter)
        tags_tree.basename = N_('Tags')
        tags = create_toplevel_item(tags_tree, icon=icons.tag(), ellipsis=ellipsis)

        self.clear()
        self.addTopLevelItems([local, remote, tags])

        if self._tree_states:
            self._load_tree_state(self._tree_states)
            self._tree_states = None

        self._update_branches()

    def showEvent(self, event):
        """Defer updating widgets until the widget is visible"""
        if not self._visible:
            self._visible = True
            if self._needs_refresh:
                self.refresh()
        return super().showEvent(event)

    def _toggle_expanded(self, index):
        """Toggle expanded/collapsed state when items are clicked"""
        item = self.itemFromIndex(index)
        if item and item.childCount():
            self.setExpanded(index, not self.isExpanded(index))

    def contextMenuEvent(self, event):
        """Build and execute the context menu"""
        context = self.context
        selected = self.selected_item()
        if not selected:
            return
        # Only allow actions on leaf nodes that have a valid refname.
        if not selected.refname:
            return

        root = get_toplevel_item(selected)
        full_name = selected.refname
        menu = qtutils.create_menu(N_('Actions'), self)

        visualize_action = qtutils.add_action(
            menu, N_('Visualize'), self.visualize_branch_action
        )
        visualize_action.setIcon(icons.visualize())
        menu.addAction(visualize_action)
        menu.addSeparator()

        # all branches except current the current branch
        if full_name != self.current_branch:
            menu.addAction(
                qtutils.add_action(menu, N_('Checkout'), self.checkout_action)
            )
            # remote branch
            if root.name == N_('Remote'):
                label = N_('Checkout as new branch')
                action = self.checkout_new_branch_action
                menu.addAction(qtutils.add_action(menu, label, action))

            merge_menu_action = qtutils.add_action(
                menu, N_('Merge into current branch'), self.merge_action
            )
            merge_menu_action.setIcon(icons.merge())
            menu.addAction(merge_menu_action)

        # local and remote branch
        if root.name != N_('Tags'):
            # local branch
            if root.name == N_('Local'):
                remote = gitcmds.tracked_branch(context, full_name)
                if remote is not None:
                    menu.addSeparator()

                    pull_menu_action = qtutils.add_action(
                        menu, N_('Pull'), self.pull_action
                    )
                    pull_menu_action.setIcon(icons.pull())
                    menu.addAction(pull_menu_action)

                    push_menu_action = qtutils.add_action(
                        menu, N_('Push'), self.push_action
                    )
                    push_menu_action.setIcon(icons.push())
                    menu.addAction(push_menu_action)

                rename_menu_action = qtutils.add_action(
                    menu, N_('Rename Branch'), self.rename_action
                )
                rename_menu_action.setIcon(icons.edit())

                menu.addSeparator()
                menu.addAction(rename_menu_action)

            # not current branch
            if full_name != self.current_branch:
                delete_label = N_('Delete Branch')
                if root.name == N_('Remote'):
                    delete_label = N_('Delete Remote Branch')

                delete_menu_action = qtutils.add_action(
                    menu, delete_label, self.delete_action
                )
                delete_menu_action.setIcon(icons.discard())

                menu.addSeparator()
                menu.addAction(delete_menu_action)

        # manage upstream branches for local branches
        if root.name == N_('Local'):
            selected_branch = self.selected_refname()
            if selected_branch:
                upstream_branch = gitcmds.tracked_branch(
                    context, branch=selected_branch
                )
            else:
                upstream_branch = ''
            set_upstream_branch_action = defer_func(
                menu,
                N_('Set Upstream Branch'),
                _set_upstream_branch,
                self.context,
                selected_branch,
                upstream_branch,
                self,
            )
            menu.addAction(set_upstream_branch_action)

        menu.exec_(self.mapToGlobal(event.pos()))

    def _save_tree_state(self):
        """Save the tree state into a dictionary"""
        states = {}
        for item in self.items():
            states.update(self.tree_helper.save_state(item))
        return states

    def _load_tree_state(self, states):
        """Restore expanded items after rebuilding UI widgets"""
        # Disable animations to eliminate redraw flicker.
        animated = self.isAnimated()
        self.setAnimated(False)

        for item in self.items():
            self.tree_helper.load_state(item, states.get(item.name, {}))
        self.tree_helper.set_current_item()

        self.setAnimated(animated)

    def _update_branches(self):
        """Query branch details using a background task"""
        context = self.context
        current_branch = self.current_branch
        top_item = self.topLevelItem(0)
        item = find_by_refname(top_item, current_branch)

        if item is not None:
            expand_item_parents(item)
            item.setIcon(0, icons.star())
            if self._branch_details_in_progress:
                return
            self._branch_details_in_progress = True
            branch_details_task = BranchDetailsTask(
                context, current_branch, self.git_helper
            )
            self.runtask.start(
                branch_details_task, finish=self._update_branches_finished
            )

    def _update_branches_finished(self, task):
        """Update the UI with the branch details once the background task completes"""
        current_branch, tracked_branch, ahead, behind = task.result
        top_item = self.topLevelItem(0)
        item = find_by_refname(top_item, current_branch)
        if current_branch and tracked_branch and item is not None:
            status_str = ''
            if ahead > 0:
                status_str += f'{chr(0x2191)}{ahead}'

            if behind > 0:
                status_str += f'  {chr(0x2193)}{behind}'

            if status_str:
                item.setText(0, f'{item.text(0)}\t{status_str}')
        self._branch_details_in_progress = False

    def git_action_async(
        self,
        action,
        args,
        kwarg=None,
        update_refs=False,
        update_status=False,
        remote_messages=False,
    ):
        """Execute a git action in a background task"""
        if kwarg is None:
            kwarg = {}
        task = AsyncGitActionTask(
            self.git_helper, action, args, kwarg, update_refs, update_status
        )
        progress = standard.progress(
            N_('Executing action %s') % action, N_('Updating'), self
        )
        if remote_messages:
            result_handler = log.show_remote_messages(self, self.context)
        else:
            result_handler = None

        self.runtask.start(
            task,
            progress=progress,
            finish=self.git_action_completed,
            result=result_handler,
        )

    def git_action_completed(self, task):
        """Update the with the results of an async git action"""
        status, out, err = task.result
        self.git_helper.show_result(task.action, status, out, err)
        if task.update_refs:
            self.context.model.update_refs()
        if task.update_status:
            self.context.model.update_status()

    def push_action(self):
        """Push the selected branch to its upstream remote"""
        context = self.context
        branch = self.selected_refname()
        remote_branch = gitcmds.tracked_branch(context, branch)
        context.settings.load()
        push_settings = context.settings.get('push')
        remote_messages = push_settings.get('remote_messages', False)
        if remote_branch:
            remote, branch_name = gitcmds.parse_remote_branch(remote_branch)
            kwarg = {}
            main_mod.autodetect_proxy(context, kwarg)
            main_mod.no_color(kwarg)
            if remote and branch_name:
                # we assume that user wants to "Push" the selected local
                # branch to a remote with same name
                self.git_action_async(
                    'push',
                    [remote, branch_name],
                    update_refs=True,
                    remote_messages=remote_messages,
                    kwarg=kwarg,
                )

    def rename_action(self):
        """Rename the selected branch"""
        branch = self.selected_refname()
        new_branch, ok = qtutils.prompt(
            N_('Enter New Branch Name'), title=N_('Rename branch'), text=branch
        )
        if ok and new_branch:
            self.git_action_async('rename', [branch, new_branch], update_refs=True)

    def pull_action(self):
        """Pull the selected branch into the current branch"""
        context = self.context
        branch = self.selected_refname()
        if not branch:
            return
        remote_branch = gitcmds.tracked_branch(context, branch)
        context.settings.load()
        pull_settings = context.settings.get('pull')
        remote_messages = pull_settings.get('remote_messages', False)
        if remote_branch:
            remote, branch_name = gitcmds.parse_remote_branch(remote_branch)
            if remote and branch_name:
                kwarg = {}
                main_mod.autodetect_proxy(context, kwarg)
                main_mod.no_color(kwarg)
                self.git_action_async(
                    'pull',
                    [remote, branch_name],
                    update_refs=True,
                    remote_messages=remote_messages,
                    kwarg=kwarg,
                )

    def delete_action(self):
        """Delete the selected branch"""
        branch = self.selected_refname()
        if not branch or branch == self.current_branch:
            return

        remote = False
        root = get_toplevel_item(self.selected_item())
        if not root:
            return
        if root.name == N_('Remote'):
            remote = True

        if remote:
            remote, branch = gitcmds.parse_remote_branch(branch)
            if remote and branch:
                cmds.do(cmds.DeleteRemoteBranch, self.context, remote, branch)
        else:
            cmds.do(cmds.DeleteBranch, self.context, branch)

    def merge_action(self):
        """Merge the selected branch into the current branch"""
        branch = self.selected_refname()
        if branch and branch != self.current_branch:
            self.context.runtask.run(cmds.run(cmds.MergeBranch, self.context, branch))

    def checkout_action(self):
        """Checkout the selected branch"""
        branch = self.selected_refname()
        if branch and branch != self.current_branch:
            self.git_action_async('checkout', [branch], update_refs=True)

    def checkout_new_branch_action(self):
        """Checkout a new branch"""
        branch = self.selected_refname()
        if branch and branch != self.current_branch:
            _, new_branch = gitcmds.parse_remote_branch(branch)
            self.git_action_async(
                'checkout', ['-b', new_branch, branch], update_refs=True
            )

    def visualize_branch_action(self):
        """Visualize the selected branch"""
        branch = self.selected_refname()
        if branch:
            cmds.do(cmds.VisualizeRevision, self.context, branch)

    def selected_refname(self):
        return getattr(self.selected_item(), 'refname', None)


class BranchDetailsTask(qtutils.Task):
    """Lookup branch details in a background task"""

    def __init__(self, context, current_branch, git_helper):
        super().__init__()
        self.context = context
        self.current_branch = current_branch
        self.git_helper = git_helper

    def task(self):
        """Query git for branch details"""
        tracked_branch = gitcmds.tracked_branch(self.context, self.current_branch)
        ahead = 0
        behind = 0

        if self.current_branch and tracked_branch:
            origin = tracked_branch + '..' + self.current_branch
            our_commits = self.git_helper.log(origin)[STDOUT]
            ahead = our_commits.count('\n')
            if our_commits:
                ahead += 1

            origin = self.current_branch + '..' + tracked_branch
            their_commits = self.git_helper.log(origin)[STDOUT]
            behind = their_commits.count('\n')
            if their_commits:
                behind += 1

        return self.current_branch, tracked_branch, ahead, behind


class BranchTreeWidgetItem(QtWidgets.QTreeWidgetItem):
    def __init__(self, name, refname=None, icon=None):
        QtWidgets.QTreeWidgetItem.__init__(self)
        self.name = name
        self.refname = refname
        self.setText(0, name)
        self.setToolTip(0, name)
        if icon is not None:
            self.setIcon(0, icon)
        self.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)


class TreeEntry:
    """Tree representation for the branches widget

    The branch widget UI displays the basename.  For intermediate names, e.g.
    "xxx" in the "xxx/abc" and "xxx/def" branches, the 'refname' will be None.
    'children' contains a list of TreeEntry, and is empty when refname is
    defined.

    """

    def __init__(self, basename, refname, children):
        self.basename = basename
        self.refname = refname
        self.children = children


def create_tree_entries(names, name_filter):
    """Create a nested tree structure with a single root TreeEntry.

    When names == ['xxx/abc', 'xxx/def'] the result will be::

        TreeEntry(
            basename=None,
            refname=None,
            children=[
                TreeEntry(
                    basename='xxx',
                    refname=None,
                    children=[
                        TreeEntry(
                            basename='abc',
                            refname='xxx/abc',
                            children=[]
                        ),
                        TreeEntry(
                            basename='def',
                            refname='xxx/def',
                            children=[]
                        )
                    ]
                )
            ]
        )

    """
    # Phase 1: build a nested dictionary representing the intermediate
    # names in the branches, e.g. {'xxx': {'abc': {}, 'def': {}}}
    filtered_names = [name for name in names if name_filter in name]
    tree_names = create_name_dict(filtered_names)

    # Loop over the names again, this time we'll create tree entries
    entries = {}
    root = TreeEntry(None, None, [])
    for item in filtered_names:
        cur_names = tree_names
        cur_entries = entries
        tree = root
        children = root.children
        for part in item.split('/'):
            if cur_names[part]:
                # This has children
                try:
                    tree, _ = cur_entries[part]
                except KeyError:
                    # New entry
                    tree = TreeEntry(part, None, [])
                    cur_entries[part] = (tree, {})
                    # Append onto the parent children list only once
                    children.append(tree)
            else:
                # This is the actual branch
                tree = TreeEntry(part, item, [])
                children.append(tree)
                cur_entries[part] = (tree, {})

            # Advance into the nested child list
            children = tree.children
            # Advance into the inner dict
            cur_names = cur_names[part]
            _, cur_entries = cur_entries[part]

    return root


def create_name_dict(names):
    # Phase 1: build a nested dictionary representing the intermediate
    # names in the branches, e.g. {'xxx': {'abc': {}, 'def': {}}}
    tree_names = {}
    for item in names:
        part_names = tree_names
        for part in item.split('/'):
            # Descend into the inner names dict.
            part_names = part_names.setdefault(part, {})
    return tree_names


def create_toplevel_item(tree, icon=None, ellipsis=None):
    """Create a top-level BranchTreeWidgetItem and its children"""

    item = BranchTreeWidgetItem(tree.basename, icon=ellipsis)
    children = create_tree_items(tree.children, icon=icon, ellipsis=ellipsis)
    if children:
        item.addChildren(children)
    return item


def create_tree_items(entries, icon=None, ellipsis=None):
    """Create children items for a tree item"""
    result = []
    for tree in entries:
        item = BranchTreeWidgetItem(tree.basename, refname=tree.refname, icon=icon)
        children = create_tree_items(tree.children, icon=icon, ellipsis=ellipsis)
        if children:
            item.addChildren(children)
            if ellipsis is not None:
                item.setIcon(0, ellipsis)
        result.append(item)

    return result


def expand_item_parents(item):
    """Expand tree parents from item"""
    parent = item.parent()
    while parent is not None:
        if not parent.isExpanded():
            parent.setExpanded(True)
        parent = parent.parent()


def find_by_refname(item, refname):
    """Find child by full name recursive"""
    result = None

    for i in range(item.childCount()):
        child = item.child(i)
        if child.refname and child.refname == refname:
            return child

        result = find_by_refname(child, refname)
        if result is not None:
            return result

    return result


def get_toplevel_item(item):
    """Returns top-most item found by traversing up the specified item"""
    parents = [item]
    parent = item.parent()

    while parent is not None:
        parents.append(parent)
        parent = parent.parent()

    return parents[-1]


class BranchesTreeHelper:
    """Save and restore the tree state"""

    def __init__(self, tree):
        self.tree = tree
        self.current_item = None

    def set_current_item(self):
        """Reset the current item"""
        if self.current_item is not None:
            self.tree.setCurrentItem(self.current_item)
        self.current_item = None

    def load_state(self, item, state):
        """Load expanded items from a dict"""
        if not state:
            return
        if state.get('expanded', False) and not item.isExpanded():
            item.setExpanded(True)
        if state.get('selected', False) and not item.isSelected():
            item.setSelected(True)
            self.current_item = item

        children_state = state.get('children', {})
        if not children_state:
            return
        for i in range(item.childCount()):
            child = item.child(i)
            self.load_state(child, children_state.get(child.name, {}))

    def save_state(self, item):
        """Save the selected and expanded item state into a dict"""
        expanded = item.isExpanded()
        selected = item.isSelected()
        children = {}
        entry = {
            'children': children,
            'expanded': expanded,
            'selected': selected,
        }
        result = {item.name: entry}
        for i in range(item.childCount()):
            child = item.child(i)
            children.update(self.save_state(child))

        return result


class GitHelper:
    def __init__(self, context):
        self.context = context
        self.git = context.git

    def log(self, origin):
        return self.git.log(origin, abbrev=7, pretty='format:%h', _readonly=True)

    def push(self, remote, branch, **kwarg):
        return self.git.push(remote, branch, verbose=True, **kwarg)

    def pull(self, remote, branch, **kwarg):
        return self.git.pull(remote, branch, no_ff=True, verbose=True, **kwarg)

    def merge(self, branch):
        return self.git.merge(branch, no_commit=True)

    def rename(self, branch, new_branch):
        return self.git.branch(branch, new_branch, m=True)

    def checkout(self, *args, **options):
        return self.git.checkout(*args, **options)

    @staticmethod
    def show_result(command, status, out, err):
        Interaction.log_status(status, out, err)
        if status != 0:
            Interaction.command_error(N_('Error'), command, status, out, err)


class BranchesFilterWidget(QtWidgets.QWidget):
    def __init__(self, tree, parent=None):
        QtWidgets.QWidget.__init__(self, parent)
        self.tree = tree

        hint = N_('Filter branches...')
        self.text = text.LineEdit(parent=self, clear_button=True)
        self.text.setToolTip(hint)
        self.setFocusProxy(self.text)
        self._filter = ''

        self.main_layout = qtutils.hbox(defs.no_margin, defs.spacing, self.text)
        self.setLayout(self.main_layout)

        self.text.textChanged.connect(self.apply_filter)
        self.tree.updated.connect(self.apply_filter, type=Qt.QueuedConnection)

    def apply_filter(self):
        value = get(self.text)
        if value == self._filter:
            return
        self._filter = value
        self.tree.set_name_filter(value)


def _set_upstream_branch(context, branch, upstream_branch, parent):
    """Select a new upstream branch"""
    dialog = SelectRemoteBranch(
        context, upstream_branch, N_('Set Upstream Branch'), parent
    )
    if dialog.exec_() != QtWidgets.QDialog.Accepted:
        return
    new_upstream_branch = dialog.value()
    remote, remote_branch = gitcmds.parse_remote_branch(new_upstream_branch)
    if branch and remote and remote_branch:
        cmds.do(cmds.SetUpstreamBranch, context, branch, remote, remote_branch)


class SelectRemoteBranch(standard.Dialog):
    """Display a dialog for choosing a remote branch"""

    def __init__(self, context, upstream_branch, title, parent):
        super().__init__(parent)
        self._completion_was_active = False
        self.remote_branch = completion.GitRemoteBranchLineEdit(
            context, hint=N_('Remote Branch')
        )
        if upstream_branch:
            self.remote_branch.set_value(upstream_branch)
            _select_text_after_slash(self.remote_branch)

        self._branches_to_items = branches_to_items = {}
        self.remote_branches = standard.TreeWidget()
        self.remote_branches.setSelectionMode(
            QtWidgets.QAbstractItemView.SingleSelection
        )
        self.remote_branches.setHeaderHidden(True)
        self.remote_branches.setAlternatingRowColors(True)
        items = []
        selected_item = None
        for branch in context.model.remote_branches:
            item = QtWidgets.QTreeWidgetItem()
            item.setText(0, branch)
            item.setData(0, Qt.UserRole, branch)
            if branch == upstream_branch:
                selected_item = item
            items.append(item)
            branches_to_items[branch] = item

        self.remote_branches.addTopLevelItems(items)
        if selected_item:
            self.remote_branches.scrollToItem(selected_item)
            self.remote_branches.setCurrentItem(selected_item)
            selected_item.setSelected(True)

        self.close_button = qtutils.close_button()
        self.ok_button = qtutils.ok_button(title)

        button_layout = qtutils.hbox(
            defs.no_margin,
            defs.button_spacing,
            self.close_button,
            qtutils.STRETCH,
            self.ok_button,
        )
        layout = qtutils.vbox(
            defs.margin,
            defs.spacing,
            self.remote_branch,
            self.remote_branches,
            button_layout,
        )
        self.close_action = qtutils.add_close_action(self)
        qtutils.connect_button(self.close_button, self.close_action.trigger)
        qtutils.connect_button(self.ok_button, self.accept)
        self.remote_branch.textChanged.connect(self._remote_branch_changed)
        # The "pre" callback uses a direct connection so that it can observe
        # state before the completion popup has been closed. The "post" callback uses a
        # queued connection so that it can see the updated value after completions have
        # been accepted and applied.
        self.remote_branch.returnPressed.connect(self._remote_branch_chosen_pre)
        self.remote_branch.returnPressed.connect(
            self._remote_branch_chosen_post, type=Qt.QueuedConnection
        )

        self.setLayout(layout)
        self.setWindowTitle(title)
        self.setWindowModality(Qt.WindowModal)
        self.setMinimumWidth(512)

        self.remote_branches.itemSelectionChanged.connect(self._remote_branch_selected)
        self.remote_branches.itemDoubleClicked.connect(
            self._remote_branch_double_clicked
        )
        self._update_actions()

    def value(self):
        """Get the remote branch selected by the user"""
        return self.remote_branch.value()

    def _remote_branch_selected(self):
        """Update the Remote Branch text when an item is selected"""
        items = self.remote_branches.selectedItems()
        if not items:
            return
        item = items[0]
        self._update_remote_branch_from_item(item)

    def _update_remote_branch_from_item(self, item):
        """Update the remote branch text from a tree widget item"""
        branch = item.data(0, Qt.UserRole)
        with qtutils.BlockSignals(self.remote_branch):
            self.remote_branch.set_value(branch)
            self._update_actions()
        popup = self.remote_branch.popup()
        if popup:
            popup.close()

    def _remote_branch_double_clicked(self, item, column):
        """Accept the dialog when an item is double-clicked"""
        self._update_remote_branch_from_item(item)
        if self.value():
            self.accept()

    def _remote_branch_changed(self, text):
        """Select the branch in the tree widget when its name is entered"""
        self._update_actions()
        try:
            item = self._branches_to_items[text]
        except KeyError:
            return
        self.remote_branches.scrollToItem(item)
        self.remote_branches.setCurrentItem(item)
        item.setSelected(True)

    def _remote_branch_chosen_pre(self):
        """Record the current remote branch text"""
        self._completion_was_active = self.remote_branch.popup().isVisible()

    def _remote_branch_chosen_post(self):
        """Accept the dialog now that the remote branch has been chosen"""
        # Do not accept the dialog when Return is used to select a completion value.
        # We detect this in the "pre" callback, which runs before the text has been
        # updated and before the completion popup is closed.
        if self._completion_was_active:
            return
        self.accept()

    def _update_actions(self):
        """Enable actions as inputs change"""
        self.ok_button.setEnabled(self.value() in self._branches_to_items)


def _select_text_after_slash(line_edit):
    """Select "xxx" when the widget contains the "origin/xxx" remote branch name"""
    value = line_edit.value()
    try:
        index = value.index('/')
    except ValueError:
        line_edit.selectAll()
        return
    start_of_remainder = index + 1
    if start_of_remainder >= len(value):
        line_edit.selectAll()
        return
    remainder_len = len(value) - start_of_remainder
    if remainder_len <= 0:
        line_edit.selectAll()
        return
    end_position = len(value)
    line_edit.setCursorPosition(end_position)
    line_edit.cursorBackward(True, remainder_len)