U-Boot

# SPDX-License-Identifier: GPL-2.0+
#
# Copyright 2025 Google LLC
#
"""Handles the 'series' subcommand
"""

import asyncio
from collections import OrderedDict, defaultdict

import pygit2

from u_boot_pylib import cros_subprocess
from u_boot_pylib import gitutil
from u_boot_pylib import terminal
from u_boot_pylib import tout

from patman import patchstream
from patman import cser_helper
from patman.cser_helper import AUTOLINK, oid
from patman import send
from patman import status


class Cseries(cser_helper.CseriesHelper):
    """Database with information about series

    This class handles database read/write as well as operations in a git
    directory to update series information.
    """
    def __init__(self, topdir=None, colour=terminal.COLOR_IF_TERMINAL):
        """Set up a new Cseries

        Args:
            topdir (str): Top-level directory of the repo
            colour (terminal.enum): Whether to enable ANSI colour or not
        """
        super().__init__(topdir, colour)

    def add(self, branch_name, desc=None, mark=False, allow_unmarked=False,
            end=None, force_version=False, dry_run=False):
        """Add a series (or new version of a series) to the database

        Args:
            branch_name (str): Name of branch to sync, or None for current one
            desc (str): Description to use, or None to use the series subject
            mark (str): True to mark each commit with a change ID
            allow_unmarked (str): True to not require each commit to be marked
            end (str): Add only commits up to but exclu
            force_version (bool): True if ignore a Series-version tag that
                doesn't match its branch name
            dry_run (bool): True to do a dry run
        """
        name, ser, version, msg = self.prep_series(branch_name, end)
        tout.info(f"Adding series '{ser.name}' v{version}: mark {mark} "
                  f'allow_unmarked {allow_unmarked}')
        if msg:
            tout.info(msg)
        if desc is None:
            if not ser.cover:
                raise ValueError(f"Branch '{name}' has no cover letter - "
                                 'please provide description')
            desc = ser['cover'][0]

        ser = self._handle_mark(name, ser, version, mark, allow_unmarked,
                                force_version, dry_run)
        link = ser.get_link_for_version(version)

        msg = 'Added'
        added = False
        series_id = self.db.series_find_by_name(ser.name)
        if not series_id:
            series_id = self.db.series_add(ser.name, desc)
            added = True
            msg += f" series '{ser.name}'"

        if version not in self._get_version_list(series_id):
            svid = self.db.ser_ver_add(series_id, version, link)
            msg += f" v{version}"
            if not added:
                msg += f" to existing series '{ser.name}'"
            added = True

            self._add_series_commits(ser, svid)
            count = len(ser.commits)
            msg += f" ({count} commit{'s' if count > 1 else ''})"
        if not added:
            tout.info(f"Series '{ser.name}' v{version} already exists")
            msg = None
        elif not dry_run:
            self.commit()
        else:
            self.rollback()
            series_id = None
        ser.desc = desc
        ser.idnum = series_id

        if msg:
            tout.info(msg)
        if dry_run:
            tout.info('Dry run completed')

    def decrement(self, series, dry_run=False):
        """Decrement a series to the previous version and delete the branch

        Args:
            series (str): Name of series to use, or None to use current branch
            dry_run (bool): True to do a dry run
        """
        ser = self._parse_series(series)
        if not ser.idnum:
            raise ValueError(f"Series '{ser.name}' not found in database")

        max_vers = self._series_max_version(ser.idnum)
        if max_vers < 2:
            raise ValueError(f"Series '{ser.name}' only has one version")

        tout.info(f"Removing series '{ser.name}' v{max_vers}")

        new_max = max_vers - 1

        repo = pygit2.init_repository(self.gitdir)
        if not dry_run:
            name = self._get_branch_name(ser.name, new_max)
            branch = repo.lookup_branch(name)
            try:
                repo.checkout(branch)
            except pygit2.errors.GitError:
                tout.warning(f"Failed to checkout branch {name}")
                raise

            del_name = f'{ser.name}{max_vers}'
            del_branch = repo.lookup_branch(del_name)
            branch_oid = del_branch.peel(pygit2.enums.ObjectType.COMMIT).oid
            del_branch.delete()
            print(f"Deleted branch '{del_name}' {oid(branch_oid)}")

        self.db.ser_ver_remove(ser.idnum, max_vers)
        if not dry_run:
            self.commit()
        else:
            self.rollback()

    def increment(self, series_name, dry_run=False):
        """Increment a series to the next version and create a new branch

        Args:
            series_name (str): Name of series to use, or None to use current
                branch
            dry_run (bool): True to do a dry run
        """
        ser = self._parse_series(series_name)
        if not ser.idnum:
            raise ValueError(f"Series '{ser.name}' not found in database")

        max_vers = self._series_max_version(ser.idnum)

        branch_name = self._get_branch_name(ser.name, max_vers)
        on_branch = gitutil.get_branch(self.gitdir) == branch_name
        svid = self.get_series_svid(ser.idnum, max_vers)
        pwc = self.get_pcommit_dict(svid)
        count = len(pwc.values())
        series = patchstream.get_metadata(branch_name, 0, count,
                                          git_dir=self.gitdir)
        tout.info(f"Increment '{ser.name}' v{max_vers}: {count} patches")

        # Create a new branch
        vers = max_vers + 1
        new_name = self._join_name_version(ser.name, vers)

        self.update_series(branch_name, series, max_vers, new_name, dry_run,
                            add_vers=vers, switch=on_branch)

        old_svid = self.get_series_svid(ser.idnum, max_vers)
        pcd = self.get_pcommit_dict(old_svid)

        svid = self.db.ser_ver_add(ser.idnum, vers)
        self.db.pcommit_add_list(svid, pcd.values())
        if not dry_run:
            self.commit()
        else:
            self.rollback()

        # repo.head.set_target(amended)
        tout.info(f'Added new branch {new_name}')
        if dry_run:
            tout.info('Dry run completed')

    def link_set(self, series_name, version, link, update_commit):
        """Add / update a series-links link for a series

        Args:
            series_name (str): Name of series to use, or None to use current
                branch
            version (int): Version number, or None to detect from name
            link (str): Patchwork link-string for the series
            update_commit (bool): True to update the current commit with the
                link
        """
        ser, version = self._parse_series_and_version(series_name, version)
        self._ensure_version(ser, version)

        self._set_link(ser.idnum, ser.name, version, link, update_commit)
        self.commit()
        tout.info(f"Setting link for series '{ser.name}' v{version} to {link}")

    def link_get(self, series, version):
        """Get the patchwork link for a version of a series

        Args:
            series (str): Name of series to use, or None to use current branch
            version (int): Version number or None for current

        Return:
            str: Patchwork link as a string, e.g. '12325'
        """
        ser, version = self._parse_series_and_version(series, version)
        self._ensure_version(ser, version)
        return self.db.ser_ver_get_link(ser.idnum, version)

    def link_search(self, pwork, series, version):
        """Search patch for the link for a series

        Returns either the single match, or None, in which case the second part
        of the tuple is filled in

        Args:
            pwork (Patchwork): Patchwork object to use
            series (str): Series name to search for, or None for current series
                that is checked out
            version (int): Version to search for, or None for current version
                detected from branch name

        Returns:
            tuple:
                int: ID of the series found, or None
                list of possible matches, or None, each a dict:
                    'id': series ID
                    'name': series name
                str: series name
                int: series version
                str: series description
        """
        _, ser, version, _, _, _, _, _ = self._get_patches(series, version)

        if not ser.desc:
            raise ValueError(f"Series '{ser.name}' has an empty description")

        pws, options = self.loop.run_until_complete(pwork.find_series(
            ser, version))
        return pws, options, ser.name, version, ser.desc

    def link_auto(self, pwork, series, version, update_commit, wait_s=0):
        """Automatically find a series link by looking in patchwork

        Args:
            pwork (Patchwork): Patchwork object to use
            series (str): Series name to search for, or None for current series
                that is checked out
            version (int): Version to search for, or None for current version
                detected from branch name
            update_commit (bool): True to update the current commit with the
                link
            wait_s (int): Number of seconds to wait for the autolink to succeed
        """
        start = self.get_time()
        stop = start + wait_s
        sleep_time = 5
        while True:
            pws, options, name, version, desc = self.link_search(
                pwork, series, version)
            if pws:
                if wait_s:
                    tout.info('Link completed after '
                              f'{self.get_time() - start} seconds')
                break

            print(f"Possible matches for '{name}' v{version} desc '{desc}':")
            print('  Link  Version  Description')
            for opt in options:
                print(f"{opt['id']:6}  {opt['version']:7}  {opt['name']}")
            if not wait_s or self.get_time() > stop:
                delay = f' after {wait_s} seconds' if wait_s else ''
                raise ValueError(f"Cannot find series '{desc}{delay}'")

            self.sleep(sleep_time)

        self.link_set(name, version, pws, update_commit)

    def link_auto_all(self, pwork, update_commit, link_all_versions,
                      replace_existing, dry_run, show_summary=True):
        """Automatically find a series link by looking in patchwork

        Args:
            pwork (Patchwork): Patchwork object to use
            update_commit (bool): True to update the current commit with the
                link
            link_all_versions (bool): True to sync all versions of a series,
                False to sync only the latest version
            replace_existing (bool): True to sync a series even if it already
                has a link
            dry_run (bool): True to do a dry run
            show_summary (bool): True to show a summary of how things went

        Return:
            OrderedDict of summary info:
                key (int): ser_ver ID
                value (AUTOLINK): result of autolinking on this ser_ver
        """
        sdict = self.db.series_get_dict_by_id()
        all_ser_vers = self._get_autolink_dict(sdict, link_all_versions)

        # Get rid of things without a description
        valid = {}
        state = {}
        no_desc = 0
        not_found = 0
        updated = 0
        failed = 0
        already = 0
        for svid, (ser_id, name, version, link, desc) in all_ser_vers.items():
            if link and not replace_existing:
                state[svid] = f'already:{link}'
                already += 1
            elif desc:
                valid[svid] = ser_id, version, link, desc
            else:
                no_desc += 1
                state[svid] = 'missing description'

        results, requests = self.loop.run_until_complete(
            pwork.find_series_list(valid))

        for svid, ser_id, link, _ in results:
            if link:
                version = all_ser_vers[svid][2]
                if self._set_link(ser_id, sdict[ser_id].name, version,
                                  link, update_commit, dry_run=dry_run):
                    updated += 1
                    state[svid] = f'linked:{link}'
                else:
                    failed += 1
                    state[svid] = 'failed'
            else:
                not_found += 1
                state[svid] = 'not found'

        # Create a summary sorted by name and version
        summary = OrderedDict()
        for svid in sorted(all_ser_vers, key=lambda k: all_ser_vers[k][1:2]):
            _, name, version, link, ser = all_ser_vers[svid]
            summary[svid] = AUTOLINK(name, version, link, ser.desc,
                                     state[svid])

        if show_summary:
            msg = f'{updated} series linked'
            if already:
                msg += f', {already} already linked'
            if not_found:
                msg += f', {not_found} not found'
            if no_desc:
                msg += f', {no_desc} missing description'
            if failed:
                msg += f', {failed} updated failed'
            tout.info(msg + f' ({requests} requests)')

            tout.info('')
            tout.info(f"{'Name':15}  Version  {'Description':40}  Result")
            border = f"{'-' * 15}  -------  {'-' * 40}  {'-' * 15}"
            tout.info(border)
            for name, version, link, desc, state in summary.values():
                bright = True
                if state.startswith('already'):
                    col = self.col.GREEN
                    bright = False
                elif state.startswith('linked'):
                    col = self.col.MAGENTA
                else:
                    col = self.col.RED
                col_state = self.col.build(col, state, bright)
                tout.info(f"{name:16.16} {version:7}  {desc or '':40.40}  "
                          f'{col_state}')
            tout.info(border)
        if dry_run:
            tout.info('Dry run completed')

        return summary

    def series_list(self):
        """List all series

        Lines all series along with their description, number of patches
        accepted and  the available versions
        """
        sdict = self.db.series_get_dict()
        print(f"{'Name':15}  {'Description':40}  Accepted  Versions")
        border = f"{'-' * 15}  {'-' * 40}  --------  {'-' * 15}"
        print(border)
        for name in sorted(sdict):
            ser = sdict[name]
            versions = self._get_version_list(ser.idnum)
            stat = self._series_get_version_stats(
                ser.idnum, self._series_max_version(ser.idnum))[0]

            vlist = ' '.join([str(ver) for ver in sorted(versions)])

            print(f'{name:16.16} {ser.desc:41.41} {stat.rjust(8)}  {vlist}')
        print(border)

    def list_patches(self, series, version, show_commit=False,
                     show_patch=False):
        """List patches in a series

        Args:
            series (str): Name of series to use, or None to use current branch
            version (int): Version number, or None to detect from name
            show_commit (bool): True to show the commit and diffstate
            show_patch (bool): True to show the patch
        """
        branch, series, version, pwc, name, _, cover_id, num_comments = (
            self._get_patches(series, version))
        with terminal.pager():
            state_totals = defaultdict(int)
            self._list_patches(branch, pwc, series, name, cover_id,
                               num_comments, show_commit, show_patch, True,
                               state_totals)

    def mark(self, in_name, allow_marked=False, dry_run=False):
        """Add Change-Id tags to a series

        Args:
            in_name (str): Name of the series to unmark
            allow_marked (bool): Allow commits to be (already) marked
            dry_run (bool): True to do a dry run, restoring the original tree
                afterwards

        Return:
            pygit.oid: oid of the new branch
        """
        name, ser, _, _ = self.prep_series(in_name)
        tout.info(f"Marking series '{name}': allow_marked {allow_marked}")

        if not allow_marked:
            bad = []
            for cmt in ser.commits:
                if cmt.change_id:
                    bad.append(cmt)
            if bad:
                print(f'{len(bad)} commit(s) already have marks')
                for cmt in bad:
                    print(f' - {oid(cmt.hash)} {cmt.subject}')
                raise ValueError(
                    f'Marked commits {len(bad)}/{len(ser.commits)}')
        new_oid = self._mark_series(in_name, ser, dry_run=dry_run)

        if dry_run:
            tout.info('Dry run completed')
        return new_oid

    def unmark(self, name, allow_unmarked=False, dry_run=False):
        """Remove Change-Id tags from a series

        Args:
            name (str): Name of the series to unmark
            allow_unmarked (bool): Allow commits to be (already) unmarked
            dry_run (bool): True to do a dry run, restoring the original tree
                afterwards

        Return:
            pygit.oid: oid of the new branch
        """
        name, ser, _, _ = self.prep_series(name)
        tout.info(
            f"Unmarking series '{name}': allow_unmarked {allow_unmarked}")

        if not allow_unmarked:
            bad = []
            for cmt in ser.commits:
                if not cmt.change_id:
                    bad.append(cmt)
            if bad:
                print(f'{len(bad)} commit(s) are missing marks')
                for cmt in bad:
                    print(f' - {oid(cmt.hash)} {cmt.subject}')
                raise ValueError(
                    f'Unmarked commits {len(bad)}/{len(ser.commits)}')
        vals = None
        for vals in self.process_series(name, ser, dry_run=dry_run):
            if cser_helper.CHANGE_ID_TAG in vals.msg:
                lines = vals.msg.splitlines()
                updated = [line for line in lines
                           if not line.startswith(cser_helper.CHANGE_ID_TAG)]
                vals.msg = '\n'.join(updated)

                tout.detail("   - removing mark")
                vals.info = 'unmarked'
            else:
                vals.info = 'no mark'

        if dry_run:
            tout.info('Dry run completed')
        return vals.oid

    def open(self, pwork, name, version):
        """Open the patchwork page for a series

        Args:
            pwork (Patchwork): Patchwork object to use
            name (str): Name of series to open
            version (str): Version number to open
        """
        ser, version = self._parse_series_and_version(name, version)
        link = self.link_get(ser.name, version)
        pwork.url = 'https://patchwork.ozlabs.org'
        url = self.loop.run_until_complete(pwork.get_series_url(link))
        print(f'Opening {url}')

        # With Firefox, GTK produces lots of warnings, so suppress them
        # Gtk-Message: 06:48:20.692: Failed to load module "xapp-gtk3-module"
        # Gtk-Message: 06:48:20.692: Not loading module "atk-bridge": The
        # functionality is provided by GTK natively. Please try to not load it.
        # Gtk-Message: 06:48:20.692: Failed to load module "appmenu-gtk-module"
        # Gtk-Message: 06:48:20.692: Failed to load module "appmenu-gtk-module"
        # [262145, Main Thread] WARNING: GTK+ module /snap/firefox/5987/
        #  gnome-platform/usr/lib/gtk-2.0/modules/libcanberra-gtk-module.so
        #  cannot be loaded.
        # GTK+ 2.x symbols detected. Using GTK+ 2.x and GTK+ 3 in the same
        #  process #  is not supported.: 'glib warning', file /build/firefox/
        #  parts/firefox/build/toolkit/xre/nsSigHandlers.cpp:201
        #
        # (firefox_firefox:262145): Gtk-WARNING **: 06:48:20.728: GTK+ module
        #  /snap/firefox/5987/gnome-platform/usr/lib/gtk-2.0/modules/
        #  libcanberra-gtk-module.so cannot be loaded.
        # GTK+ 2.x symbols detected. Using GTK+ 2.x and GTK+ 3 in the same
        #  process is not supported.
        # Gtk-Message: 06:48:20.728: Failed to load module
        #  "canberra-gtk-module"
        # [262145, Main Thread] WARNING: GTK+ module /snap/firefox/5987/
        #  gnome-platform/usr/lib/gtk-2.0/modules/libcanberra-gtk-module.so
        #  cannot be loaded.
        # GTK+ 2.x symbols detected. Using GTK+ 2.x and GTK+ 3 in the same
        #  process is not supported.: 'glib warning', file /build/firefox/
        #  parts/firefox/build/toolkit/xre/nsSigHandlers.cpp:201
        #
        # (firefox_firefox:262145): Gtk-WARNING **: 06:48:20.729: GTK+ module
        #   /snap/firefox/5987/gnome-platform/usr/lib/gtk-2.0/modules/
        #   libcanberra-gtk-module.so cannot be loaded.
        # GTK+ 2.x symbols detected. Using GTK+ 2.x and GTK+ 3 in the same
        #  process is not supported.
        # Gtk-Message: 06:48:20.729: Failed to load module
        #  "canberra-gtk-module"
        # ATTENTION: default value of option mesa_glthread overridden by
        # environment.
        cros_subprocess.Popen(['xdg-open', url])

    def progress(self, series, show_all_versions, list_patches):
        """Show progress information for all versions in a series

        Args:
            series (str): Name of series to use, or None to show progress for
                all series
            show_all_versions (bool): True to show all versions of a series,
                False to show only the final version
            list_patches (bool): True to list all patches for each series,
                False to just show the series summary on a single line
        """
        with terminal.pager():
            state_totals = defaultdict(int)
            if series is not None:
                _, _, need_scan = self._progress_one(
                    self._parse_series(series), show_all_versions,
                    list_patches, state_totals)
                if need_scan:
                    tout.warning(
                        'Inconsistent commit-subject: Please use '
                        "'patman series -s <branch> scan' to resolve this")
                return

            total_patches = 0
            total_series = 0
            sdict = self.db.series_get_dict()
            border = None
            total_need_scan = 0
            if not list_patches:
                print(self.col.build(
                    self.col.MAGENTA,
                    f"{'Name':16} {'Description':41} Count  {'Status'}"))
                border = f"{'-' * 15}  {'-' * 40}  -----  {'-' * 15}"
                print(border)
            for name in sorted(sdict):
                ser = sdict[name]
                num_series, num_patches, need_scan = self._progress_one(
                    ser, show_all_versions, list_patches, state_totals)
                total_need_scan += need_scan
                if list_patches:
                    print()
                total_series += num_series
                total_patches += num_patches
            if not list_patches:
                print(border)
                total = f'{total_series} series'
                out = ''
                for state, freq in state_totals.items():
                    out += ' ' + self._build_col(state, f'{freq}:')[0]
                if total_need_scan:
                    out = '*' + out[1:]

                print(f"{total:15}  {'':40}  {total_patches:5} {out}")
                if total_need_scan:
                    tout.info(
                        f'Series marked * ({total_need_scan}) have commit '
                        'subjects which mismatch their patches and need to be '
                        'scanned')

    def project_set(self, pwork, name, quiet=False):
        """Set the name of the project

        Args:
            pwork (Patchwork): Patchwork object to use
            name (str): Name of the project to use in patchwork
            quiet (bool): True to skip writing the message
        """
        res = self.loop.run_until_complete(pwork.get_projects())
        proj_id = None
        link_name = None
        for proj in res:
            if proj['name'] == name:
                proj_id = proj['id']
                link_name = proj['link_name']
        if not proj_id:
            raise ValueError(f"Unknown project name '{name}'")
        self.db.settings_update(name, proj_id, link_name)
        self.commit()
        if not quiet:
            tout.info(f"Project '{name}' patchwork-ID {proj_id} "
                      f'link-name {link_name}')

    def project_get(self):
        """Get the details of the project

        Returns:
            tuple or None if there are no settings:
                name (str): Project name, e.g. 'U-Boot'
                proj_id (int): Patchworks project ID for this project
                link_name (str): Patchwork's link-name for the project
        """
        return self.db.settings_get()

    def remove(self, name, dry_run=False):
        """Remove a series from the database

        Args:
            name (str): Name of series to remove, or None to use current one
            dry_run (bool): True to do a dry run
        """
        ser = self._parse_series(name)
        name = ser.name
        if not ser.idnum:
            raise ValueError(f"No such series '{name}'")

        self.db.ser_ver_remove(ser.idnum, None)
        if not dry_run:
            self.commit()
        else:
            self.rollback()

        self.commit()
        tout.info(f"Removed series '{name}'")
        if dry_run:
            tout.info('Dry run completed')

    def rename(self, series, name, dry_run=False):
        """Rename a series

        Renames a series and changes the name of any branches which match
        versions present in the database

        Args:
            series (str): Name of series to use, or None to use current branch
            name (str): new name to use (must not include version number)
            dry_run (bool): True to do a dry run
        """
        old_ser, _ = self._parse_series_and_version(series, None)
        if not old_ser.idnum:
            raise ValueError(f"Series '{old_ser.name}' not found in database")
        if old_ser.name != series:
            raise ValueError(f"Invalid series name '{series}': "
                             'did you use the branch name?')
        chk, _ = cser_helper.split_name_version(name)
        if chk != name:
            raise ValueError(
                f"Invalid series name '{name}': did you use the branch name?")
        if chk == old_ser.name:
            raise ValueError(
                f"Cannot rename series '{old_ser.name}' to itself")
        if self.get_series_by_name(name):
            raise ValueError(f"Cannot rename: series '{name}' already exists")

        versions = self._get_version_list(old_ser.idnum)
        missing = []
        exists = []
        todo = {}
        for ver in versions:
            ok = True
            old_branch = self._get_branch_name(old_ser.name, ver)
            if not gitutil.check_branch(old_branch, self.gitdir):
                missing.append(old_branch)
                ok = False

            branch = self._get_branch_name(name, ver)
            if gitutil.check_branch(branch, self.gitdir):
                exists.append(branch)
                ok = False

            if ok:
                todo[ver] = [old_branch, branch]

        if missing or exists:
            msg = 'Cannot rename'
            if missing:
                msg += f": branches missing: {', '.join(missing)}"
            if exists:
                msg += f": branches exist: {', '.join(exists)}"
            raise ValueError(msg)

        for old_branch, branch in todo.values():
            tout.info(f"Renaming branch '{old_branch}' to '{branch}'")
            if not dry_run:
                gitutil.rename_branch(old_branch, branch, self.gitdir)

        # Change the series name; nothing needs to change in ser_ver
        self.db.series_set_name(old_ser.idnum, name)

        if not dry_run:
            self.commit()
        else:
            self.rollback()

        tout.info(f"Renamed series '{series}' to '{name}'")
        if dry_run:
            tout.info('Dry run completed')

    def scan(self, branch_name, mark=False, allow_unmarked=False, end=None,
             dry_run=False):
        """Scan a branch and make updates to the database if it has changed

        Args:
            branch_name (str): Name of branch to sync, or None for current one
            mark (str): True to mark each commit with a change ID
            allow_unmarked (str): True to not require each commit to be marked
            end (str): Add only commits up to but exclu
            dry_run (bool): True to do a dry run
        """
        def _show_item(oper, seq, subject):
            col = None
            if oper == '+':
                col = self.col.GREEN
            elif oper == '-':
                col = self.col.RED
            out = self.col.build(col, subject) if col else subject
            tout.info(f'{oper} {seq:3} {out}')

        name, ser, version, msg = self.prep_series(branch_name, end)
        svid = self.get_ser_ver(ser.idnum, version).idnum
        pcdict = self.get_pcommit_dict(svid)

        tout.info(
            f"Syncing series '{name}' v{version}: mark {mark} "
            f'allow_unmarked {allow_unmarked}')
        if msg:
            tout.info(msg)

        ser = self._handle_mark(name, ser, version, mark, allow_unmarked,
                                False, dry_run)

        # First check for new patches that are not in the database
        to_add = dict(enumerate(ser.commits))
        for pcm in pcdict.values():
            tout.debug(f'pcm {pcm.subject}')
            i = self._find_matched_commit(to_add, pcm)
            if i is not None:
                del to_add[i]

        # Now check for patches in the database that are not in the branch
        to_remove = dict(enumerate(pcdict.values()))
        for cmt in ser.commits:
            tout.debug(f'cmt {cmt.subject}')
            i = self._find_matched_patch(to_remove, cmt)
            if i is not None:
                del to_remove[i]

        for seq, cmt in enumerate(ser.commits):
            if seq in to_remove:
                _show_item('-', seq, to_remove[seq].subject)
                del to_remove[seq]
            if seq in to_add:
                _show_item('+', seq, to_add[seq].subject)
                del to_add[seq]
            else:
                _show_item(' ', seq, cmt.subject)
        seq = len(ser.commits)
        for cmt in to_add.items():
            _show_item('+', seq, cmt.subject)
            seq += 1
        for seq, pcm in to_remove.items():
            _show_item('+', seq, pcm.subject)

        self.db.pcommit_delete(svid)
        self._add_series_commits(ser, svid)
        if not dry_run:
            self.commit()
        else:
            self.rollback()
            tout.info('Dry run completed')

    def send(self, pwork, name, autolink, autolink_wait, args):
        """Send out a series

        Args:
            pwork (Patchwork): Patchwork object to use
            name (str): Series name to search for, or None for current series
                that is checked out
            autolink (bool): True to auto-link the series after sending
            args (argparse.Namespace): 'send' arguments provided
            autolink_wait (int): Number of seconds to wait for the autolink to
                succeed
        """
        ser, version = self._parse_series_and_version(name, None)
        if not ser.idnum:
            raise ValueError(f"Series '{ser.name}' not found in database")

        args.branch = self._get_branch_name(ser.name, version)
        likely_sent = send.send(args, git_dir=self.gitdir, cwd=self.topdir)

        if likely_sent and autolink:
            print(f'Autolinking with Patchwork ({autolink_wait} seconds)')
            self.link_auto(pwork, name, version, True, wait_s=autolink_wait)

    def archive(self, series):
        """Archive a series

        Args:
            series (str): Name of series to use, or None to use current branch
        """
        ser = self._parse_series(series, include_archived=True)
        if not ser.idnum:
            raise ValueError(f"Series '{ser.name}' not found in database")

        svlist = self.db.ser_ver_get_for_series(ser.idnum)

        # Figure out the tags we will create
        tag_info = {}
        now = self.get_now()
        now_str = now.strftime('%d%b%y').lower()
        for svi in svlist:
            name = self._get_branch_name(ser.name, svi.version)
            if not gitutil.check_branch(name, git_dir=self.gitdir):
                raise ValueError(f"No branch named '{name}'")
            tag_info[svi.version] = [svi.idnum, name, f'{name}-{now_str}']

        # Create the tags
        repo = pygit2.init_repository(self.gitdir)
        for _, (idnum, name, tag_name) in tag_info.items():
            commit = repo.revparse_single(name)
            repo.create_tag(tag_name, commit.hex,
                            pygit2.enums.ObjectType.COMMIT,
                            commit.author, commit.message)

        # Update the database
        for idnum, name, tag_name in tag_info.values():
            self.db.ser_ver_set_archive_tag(idnum, tag_name)

        # Delete the branches
        for idnum, name, tag_name in tag_info.values():
            # Detach HEAD from the branch if pointing to this branch
            commit = repo.revparse_single(name)
            if repo.head.target == commit.oid:
                repo.set_head(commit.oid)

            repo.branches.delete(name)

        self.db.series_set_archived(ser.idnum, True)
        self.commit()

    def unarchive(self, series):
        """Unarchive a series

        Args:
            series (str): Name of series to use, or None to use current branch
        """
        ser = self._parse_series(series, include_archived=True)
        if not ser.idnum:
            raise ValueError(f"Series '{ser.name}' not found in database")
        self.db.series_set_archived(ser.idnum, False)

        svlist = self.db.ser_ver_get_for_series(ser.idnum)

        # Collect the tags
        repo = pygit2.init_repository(self.gitdir)
        tag_info = {}
        for svi in svlist:
            name = self._get_branch_name(ser.name, svi.version)
            target = repo.revparse_single(svi.archive_tag)
            tag_info[svi.idnum] = name, svi.archive_tag, target

        # Make sure the branches don't exist
        for name, tag_name, tag in tag_info.values():
            if name in repo.branches:
                raise ValueError(
                    f"Cannot restore branch '{name}': already exists")

        # Recreate the branches
        for name, tag_name, tag in tag_info.values():
            target = repo.get(tag.target)
            repo.branches.create(name, target)

        # Delete the tags
        for name, tag_name, tag in tag_info.values():
            repo.references.delete(f'refs/tags/{tag_name}')

        # Update the database
        for idnum, (name, tag_name, tag) in tag_info.items():
            self.db.ser_ver_set_archive_tag(idnum, None)

        self.commit()

    def status(self, pwork, series, version, show_comments,
               show_cover_comments=False):
        """Show the series status from patchwork

        Args:
            pwork (Patchwork): Patchwork object to use
            series (str): Name of series to use, or None to use current branch
            version (int): Version number, or None to detect from name
            show_comments (bool): Show all comments on each patch
            show_cover_comments (bool): Show all comments on the cover letter
        """
        branch, series, version, _, _, link, _, _ = self._get_patches(
            series, version)
        if not link:
            raise ValueError(
                f"Series '{series.name}' v{version} has no patchwork link: "
                f"Try 'patman series -s {branch} autolink'")
        status.check_and_show_status(
            series, link, branch, None, False, show_comments,
            show_cover_comments, pwork, self.gitdir)

    def summary(self, series):
        """Show summary information for all series

        Args:
            series (str): Name of series to use
        """
        print(f"{'Name':17}  Status  Description")
        print(f"{'-' * 17}  {'-' * 6}  {'-' * 30}")
        if series is not None:
            self._summary_one(self._parse_series(series))
            return

        sdict = self.db.series_get_dict()
        for ser in sdict.values():
            self._summary_one(ser)

    def gather(self, pwork, series, version, show_comments,
               show_cover_comments, gather_tags, dry_run=False):
        """Gather any new tags from Patchwork, optionally showing comments

        Args:
            pwork (Patchwork): Patchwork object to use
            series (str): Name of series to use, or None to use current branch
            version (int): Version number, or None to detect from name
            show_comments (bool): True to show the comments on each patch
            show_cover_comments (bool): True to show the comments on the cover
                letter
            gather_tags (bool): True to gather review/test tags
            dry_run (bool): True to do a dry run (database is not updated)
        """
        ser, version = self._parse_series_and_version(series, version)
        self._ensure_version(ser, version)
        svid, link = self._get_series_svid_link(ser.idnum, version)
        if not link:
            raise ValueError(
                "No patchwork link is available: use 'patman series autolink'")
        tout.info(
            f"Updating series '{ser.name}' version {version} "
            f"from link '{link}'")

        loop = asyncio.get_event_loop()
        with pwork.collect_stats() as stats:
            cover, patches = loop.run_until_complete(self._gather(
                pwork, link, show_cover_comments))

        with terminal.pager():
            updated, updated_cover = self._sync_one(
                svid, ser.name, version, show_comments, show_cover_comments,
                gather_tags, cover, patches, dry_run)
            tout.info(f"{updated} patch{'es' if updated != 1 else ''}"
                      f"{' and cover letter' if updated_cover else ''} "
                      f'updated ({stats.request_count} requests)')

            if not dry_run:
                self.commit()
            else:
                self.rollback()
                tout.info('Dry run completed')

    def gather_all(self, pwork, show_comments, show_cover_comments,
                   sync_all_versions, gather_tags, dry_run=False):
        to_fetch, missing = self._get_fetch_dict(sync_all_versions)

        loop = asyncio.get_event_loop()
        result, requests = loop.run_until_complete(self._do_series_sync_all(
                pwork, to_fetch))

        with terminal.pager():
            tot_updated = 0
            tot_cover = 0
            add_newline = False
            for (svid, sync), (cover, patches) in zip(to_fetch.items(),
                                                      result):
                if add_newline:
                    tout.info('')
                tout.info(f"Syncing '{sync.series_name}' v{sync.version}")
                updated, updated_cover = self._sync_one(
                    svid, sync.series_name, sync.version, show_comments,
                    show_cover_comments, gather_tags, cover, patches, dry_run)
                tot_updated += updated
                tot_cover += updated_cover
                add_newline = gather_tags

            tout.info('')
            tout.info(
                f"{tot_updated} patch{'es' if tot_updated != 1 else ''} and "
                f"{tot_cover} cover letter{'s' if tot_cover != 1 else ''} "
                f'updated, {missing} missing '
                f"link{'s' if missing != 1 else ''} ({requests} requests)")
            if not dry_run:
                self.commit()
            else:
                self.rollback()
                tout.info('Dry run completed')

    def upstream_add(self, name, url):
        """Add a new upstream tree

        Args:
            name (str): Name of the tree
            url (str): URL for the tree
        """
        self.db.upstream_add(name, url)
        self.commit()

    def upstream_list(self):
        """List the upstream repos

        Shows a list of the repos, obtained from the database
        """
        udict = self.get_upstream_dict()

        for name, items in udict.items():
            url, is_default = items
            default = 'default' if is_default else ''
            print(f'{name:15.15} {default:8} {url}')

    def upstream_set_default(self, name):
        """Set the default upstream target

        Args:
            name (str): Name of the upstream remote to set as default, or None
                for none
        """
        self.db.upstream_set_default(name)
        self.commit()

    def upstream_get_default(self):
        """Get the default upstream target

        Return:
            str: Name of the upstream remote to set as default, or None if none
        """
        return self.db.upstream_get_default()

    def upstream_delete(self, name):
        """Delete an upstream target

        Args:
            name (str): Name of the upstream remote to delete
        """
        self.db.upstream_delete(name)
        self.commit()

    def version_remove(self, name, version, dry_run=False):
        """Remove a version of a series from the database

        Args:
            name (str): Name of series to remove, or None to use current one
            version (int): Version number to remove
            dry_run (bool): True to do a dry run
        """
        ser, version = self._parse_series_and_version(name, version)
        name = ser.name

        versions = self._ensure_version(ser, version)

        if versions == [version]:
            raise ValueError(
                f"Series '{ser.name}' only has one version: remove the series")

        self.db.ser_ver_remove(ser.idnum, version)
        if not dry_run:
            self.commit()
        else:
            self.rollback()

        tout.info(f"Removed version {version} from series '{name}'")
        if dry_run:
            tout.info('Dry run completed')

    def version_change(self, name, version, new_version, dry_run=False):
        """Change a version of a series to be a different version

        Args:
            name (str): Name of series to remove, or None to use current one
            version (int): Version number to change
            new_version (int): New version
            dry_run (bool): True to do a dry run
        """
        ser, version = self._parse_series_and_version(name, version)
        name = ser.name

        versions = self._ensure_version(ser, version)
        vstr = list(map(str, versions))
        if version not in versions:
            raise ValueError(
                f"Series '{ser.name}' does not have v{version}: "
                f"{' '.join(vstr)}")

        if not new_version:
            raise ValueError('Please provide a new version number')

        if new_version in versions:
            raise ValueError(
                f"Series '{ser.name}' already has a v{new_version}: "
                f"{' '.join(vstr)}")

        new_name = self._join_name_version(ser.name, new_version)

        svid = self.get_series_svid(ser.idnum, version)
        pwc = self.get_pcommit_dict(svid)
        count = len(pwc.values())
        series = patchstream.get_metadata(name, 0, count, git_dir=self.gitdir)

        self.update_series(name, series, version, new_name, dry_run,
                            add_vers=new_version, switch=True)
        self.db.ser_ver_set_version(svid, new_version)

        if not dry_run:
            self.commit()
        else:
            self.rollback()

        tout.info(f"Changed version {version} in series '{ser.name}' "
                  f"to {new_version} named '{new_name}'")
        if dry_run:
            tout.info('Dry run completed')