#include "builtin.h"

#include "abspath.h"

#include "advice.h"

#include "checkout.h"

#include "config.h"

#include "copy.h"

#include "dir.h"

#include "environment.h"

#include "gettext.h"

#include "hex.h"

#include "object-file.h"

#include "object-name.h"

#include "parse-options.h"

#include "path.h"

#include "strvec.h"

#include "branch.h"

#include "read-cache-ll.h"

#include "refs.h"

#include "remote.h"

#include "repository.h"

#include "run-command.h"

#include "hook.h"

#include "sigchain.h"

#include "submodule.h"

#include "utf8.h"

#include "worktree.h"

#include "quote.h"

#define BUILTIN_WORKTREE_ADD_USAGE \

  N_("git worktree add [-f] [--detach] [--checkout] [--lock [--reason <string>]]\n" \

     "                 [--orphan] [(-b | -B) <new-branch>] <path> [<commit-ish>]")

#define BUILTIN_WORKTREE_LIST_USAGE \

  N_("git worktree list [-v | --porcelain [-z]]")

#define BUILTIN_WORKTREE_LOCK_USAGE \

  N_("git worktree lock [--reason <string>] <worktree>")

#define BUILTIN_WORKTREE_MOVE_USAGE \

  N_("git worktree move <worktree> <new-path>")

#define BUILTIN_WORKTREE_PRUNE_USAGE \

  N_("git worktree prune [-n] [-v] [--expire <expire>]")

#define BUILTIN_WORKTREE_REMOVE_USAGE \

  N_("git worktree remove [-f] <worktree>")

#define BUILTIN_WORKTREE_REPAIR_USAGE \

  N_("git worktree repair [<path>...]")

#define BUILTIN_WORKTREE_UNLOCK_USAGE \

  N_("git worktree unlock <worktree>")

#define WORKTREE_ADD_DWIM_ORPHAN_INFER_TEXT \

  _("No possible source branch, inferring '--orphan'")

#define WORKTREE_ADD_ORPHAN_WITH_DASH_B_HINT_TEXT \

  _("If you meant to create a worktree containing a new unborn branch\n" \

  "(branch with no commits) for this repository, you can do so\n" \

  "using the --orphan flag:\n" \

  "\n" \

  "    git worktree add --orphan -b %s %s\n")

#define WORKTREE_ADD_ORPHAN_NO_DASH_B_HINT_TEXT \

  _("If you meant to create a worktree containing a new unborn branch\n" \

  "(branch with no commits) for this repository, you can do so\n" \

  "using the --orphan flag:\n" \

  "\n" \

  "    git worktree add --orphan %s\n")

static const char * const git_worktree_usage[] = {

  BUILTIN_WORKTREE_ADD_USAGE,

  BUILTIN_WORKTREE_LIST_USAGE,

  BUILTIN_WORKTREE_LOCK_USAGE,

  BUILTIN_WORKTREE_MOVE_USAGE,

  BUILTIN_WORKTREE_PRUNE_USAGE,

  BUILTIN_WORKTREE_REMOVE_USAGE,

  BUILTIN_WORKTREE_REPAIR_USAGE,

  BUILTIN_WORKTREE_UNLOCK_USAGE,

  NULL

};

static const char * const git_worktree_add_usage[] = {

  BUILTIN_WORKTREE_ADD_USAGE,

  NULL,

};

static const char * const git_worktree_list_usage[] = {

  BUILTIN_WORKTREE_LIST_USAGE,

  NULL

};

static const char * const git_worktree_lock_usage[] = {

  BUILTIN_WORKTREE_LOCK_USAGE,

  NULL

};

static const char * const git_worktree_move_usage[] = {

  BUILTIN_WORKTREE_MOVE_USAGE,

  NULL

};

static const char * const git_worktree_prune_usage[] = {

  BUILTIN_WORKTREE_PRUNE_USAGE,

  NULL

};

static const char * const git_worktree_remove_usage[] = {

  BUILTIN_WORKTREE_REMOVE_USAGE,

  NULL

};

static const char * const git_worktree_repair_usage[] = {

  BUILTIN_WORKTREE_REPAIR_USAGE,

  NULL

};

static const char * const git_worktree_unlock_usage[] = {

  BUILTIN_WORKTREE_UNLOCK_USAGE,

  NULL

};

struct add_opts {

  int force;

  int detach;

  int quiet;

  int checkout;

  int orphan;

  const char *keep_locked;

};

static int show_only;

static int verbose;

static int guess_remote;

static timestamp_t expire;

static int git_worktree_config(const char *var, const char *value,

             const struct config_context *ctx, void *cb)

{

  if (!strcmp(var, "worktree.guessremote")) {

    guess_remote = git_config_bool(var, value);

    return 0;

  }

  return git_default_config(var, value, ctx, cb);

}

static int delete_git_dir(const char *id)

{

  struct strbuf sb = STRBUF_INIT;

  int ret;

  strbuf_addstr(&sb, git_common_path("worktrees/%s", id));

  ret = remove_dir_recursively(&sb, 0);

  if (ret < 0 && errno == ENOTDIR)

    ret = unlink(sb.buf);

  if (ret)

    error_errno(_("failed to delete '%s'"), sb.buf);

  strbuf_release(&sb);

  return ret;

}

static void delete_worktrees_dir_if_empty(void)

{

  rmdir(git_path("worktrees")); /* ignore failed removal */

}

static void prune_worktree(const char *id, const char *reason)

{

  if (show_only || verbose)

    fprintf_ln(stderr, _("Removing %s/%s: %s"), "worktrees", id, reason);

  if (!show_only)

    delete_git_dir(id);

}

static int prune_cmp(const void *a, const void *b)

{

  const struct string_list_item *x = a;

  const struct string_list_item *y = b;

  int c;

  if ((c = fspathcmp(x->string, y->string)))

      return c;

  /*

   * paths same; prune_dupes() removes all but the first worktree entry

   * having the same path, so sort main worktree ('util' is NULL) above

   * linked worktrees ('util' not NULL) since main worktree can't be

   * removed

   */

  if (!x->util)

    return -1;

  if (!y->util)

    return 1;

  /* paths same; sort by .git/worktrees/<id> */

  return strcmp(x->util, y->util);

}

static void prune_dups(struct string_list *l)

{

  int i;

  QSORT(l->items, l->nr, prune_cmp);

  for (i = 1; i < l->nr; i++) {

    if (!fspathcmp(l->items[i].string, l->items[i - 1].string))

      prune_worktree(l->items[i].util, "duplicate entry");

  }

}

static void prune_worktrees(void)

{

  struct strbuf reason = STRBUF_INIT;

  struct strbuf main_path = STRBUF_INIT;

  struct string_list kept = STRING_LIST_INIT_DUP;

  DIR *dir = opendir(git_path("worktrees"));

  struct dirent *d;

  if (!dir)

    return;

  while ((d = readdir_skip_dot_and_dotdot(dir)) != NULL) {

    char *path;

    strbuf_reset(&reason);

    if (should_prune_worktree(d->d_name, &reason, &path, expire))

      prune_worktree(d->d_name, reason.buf);

    else if (path)

      string_list_append_nodup(&kept, path)->util = xstrdup(d->d_name);

  }

  closedir(dir);

  strbuf_add_absolute_path(&main_path, get_git_common_dir());

  /* massage main worktree absolute path to match 'gitdir' content */

  strbuf_strip_suffix(&main_path, "/.");

  string_list_append_nodup(&kept, strbuf_detach(&main_path, NULL));

  prune_dups(&kept);

  string_list_clear(&kept, 1);

  if (!show_only)

    delete_worktrees_dir_if_empty();

  strbuf_release(&reason);

}

static int prune(int ac, const char **av, const char *prefix)

{

  struct option options[] = {

    OPT__DRY_RUN(&show_only, N_("do not remove, show only")),

    OPT__VERBOSE(&verbose, N_("report pruned working trees")),

    OPT_EXPIRY_DATE(0, "expire", &expire,

        N_("expire working trees older than <time>")),

    OPT_END()

  };

  expire = TIME_MAX;

  ac = parse_options(ac, av, prefix, options, git_worktree_prune_usage,

         0);

  if (ac)

    usage_with_options(git_worktree_prune_usage, options);

  prune_worktrees();

  return 0;

}

static char *junk_work_tree;

static char *junk_git_dir;

static int is_junk;

static pid_t junk_pid;

static void remove_junk(void)

{

  struct strbuf sb = STRBUF_INIT;

  if (!is_junk || getpid() != junk_pid)

    return;

  if (junk_git_dir) {

    strbuf_addstr(&sb, junk_git_dir);

    remove_dir_recursively(&sb, 0);

    strbuf_reset(&sb);

  }

  if (junk_work_tree) {

    strbuf_addstr(&sb, junk_work_tree);

    remove_dir_recursively(&sb, 0);

  }

  strbuf_release(&sb);

}

static void remove_junk_on_signal(int signo)

{

  remove_junk();

  sigchain_pop(signo);

  raise(signo);

}

static const char *worktree_basename(const char *path, int *olen)

{

  const char *name;

  int len;

  len = strlen(path);

  while (len && is_dir_sep(path[len - 1]))

    len--;

  for (name = path + len - 1; name > path; name--)

    if (is_dir_sep(*name)) {

      name++;

      break;

    }

  *olen = len;

  return name;

}

/* check that path is viable location for worktree */

static void check_candidate_path(const char *path,

         int force,

         struct worktree **worktrees,

         const char *cmd)

{

  struct worktree *wt;

  int locked;

  if (file_exists(path) && !is_empty_dir(path))

    die(_("'%s' already exists"), path);

  wt = find_worktree_by_path(worktrees, path);

  if (!wt)

    return;

  locked = !!worktree_lock_reason(wt);

  if ((!locked && force) || (locked && force > 1)) {

    if (delete_git_dir(wt->id))

        die(_("unusable worktree destination '%s'"), path);

    return;

  }

  if (locked)

    die(_("'%s' is a missing but locked worktree;\nuse '%s -f -f' to override, or 'unlock' and 'prune' or 'remove' to clear"), path, cmd);

  else

    die(_("'%s' is a missing but already registered worktree;\nuse '%s -f' to override, or 'prune' or 'remove' to clear"), path, cmd);

}

static void copy_sparse_checkout(const char *worktree_git_dir)

{

  char *from_file = git_pathdup("info/sparse-checkout");

  char *to_file = xstrfmt("%s/info/sparse-checkout", worktree_git_dir);

  if (file_exists(from_file)) {

    if (safe_create_leading_directories(to_file) ||

      copy_file(to_file, from_file, 0666))

      error(_("failed to copy '%s' to '%s'; sparse-checkout may not work correctly"),

        from_file, to_file);

  }

  free(from_file);

  free(to_file);

}

static void copy_filtered_worktree_config(const char *worktree_git_dir)

{

  char *from_file = git_pathdup("config.worktree");

  char *to_file = xstrfmt("%s/config.worktree", worktree_git_dir);

  if (file_exists(from_file)) {

    struct config_set cs = { { 0 } };

    int bare;

    if (safe_create_leading_directories(to_file) ||

      copy_file(to_file, from_file, 0666)) {

      error(_("failed to copy worktree config from '%s' to '%s'"),

        from_file, to_file);

      goto worktree_copy_cleanup;

    }

    git_configset_init(&cs);

    git_configset_add_file(&cs, from_file);

    if (!git_configset_get_bool(&cs, "core.bare", &bare) &&

      bare &&

      git_config_set_multivar_in_file_gently(

        to_file, "core.bare", NULL, "true", NULL, 0))

      error(_("failed to unset '%s' in '%s'"),

        "core.bare", to_file);

    if (!git_configset_get(&cs, "core.worktree") &&

      git_config_set_in_file_gently(to_file,

              "core.worktree", NULL, NULL))

      error(_("failed to unset '%s' in '%s'"),

        "core.worktree", to_file);

    git_configset_clear(&cs);

  }

worktree_copy_cleanup:

  free(from_file);

  free(to_file);

}

static int checkout_worktree(const struct add_opts *opts,

           struct strvec *child_env)

{

  struct child_process cp = CHILD_PROCESS_INIT;

  cp.git_cmd = 1;

  strvec_pushl(&cp.args, "reset", "--hard", "--no-recurse-submodules", NULL);

  if (opts->quiet)

    strvec_push(&cp.args, "--quiet");

  strvec_pushv(&cp.env, child_env->v);

  return run_command(&cp);

}

static int make_worktree_orphan(const char * ref, const struct add_opts *opts,

        struct strvec *child_env)

{

  struct strbuf symref = STRBUF_INIT;

  struct child_process cp = CHILD_PROCESS_INIT;

  validate_new_branchname(ref, &symref, 0);

  strvec_pushl(&cp.args, "symbolic-ref", "HEAD", symref.buf, NULL);

  if (opts->quiet)

    strvec_push(&cp.args, "--quiet");

  strvec_pushv(&cp.env, child_env->v);

  strbuf_release(&symref);

  cp.git_cmd = 1;

  return run_command(&cp);

}

static int add_worktree(const char *path, const char *refname,

      const struct add_opts *opts)

{

  struct strbuf sb_git = STRBUF_INIT, sb_repo = STRBUF_INIT;

  struct strbuf sb = STRBUF_INIT, realpath = STRBUF_INIT;

  const char *name;

  struct strvec child_env = STRVEC_INIT;

  unsigned int counter = 0;

  int len, ret;

  struct strbuf symref = STRBUF_INIT;

  struct commit *commit = NULL;

  int is_branch = 0;

  struct strbuf sb_name = STRBUF_INIT;

  struct worktree **worktrees, *wt = NULL;

  struct ref_store *wt_refs;

  worktrees = get_worktrees();

  check_candidate_path(path, opts->force, worktrees, "add");

  free_worktrees(worktrees);

  worktrees = NULL;

  /* is 'refname' a branch or commit? */

  if (!opts->detach && !strbuf_check_branch_ref(&symref, refname) &&

      refs_ref_exists(get_main_ref_store(the_repository), symref.buf)) {

    is_branch = 1;

    if (!opts->force)

      die_if_checked_out(symref.buf, 0);

  }

  commit = lookup_commit_reference_by_name(refname);

  if (!commit && !opts->orphan)

    die(_("invalid reference: %s"), refname);

  name = worktree_basename(path, &len);

  strbuf_add(&sb, name, path + len - name);

  sanitize_refname_component(sb.buf, &sb_name);

  if (!sb_name.len)

    BUG("How come '%s' becomes empty after sanitization?", sb.buf);

  strbuf_reset(&sb);

  name = sb_name.buf;

  git_path_buf(&sb_repo, "worktrees/%s", name);

  len = sb_repo.len;

  if (safe_create_leading_directories_const(sb_repo.buf))

    die_errno(_("could not create leading directories of '%s'"),

        sb_repo.buf);

  while (mkdir(sb_repo.buf, 0777)) {

    counter++;

    if ((errno != EEXIST) || !counter /* overflow */)

      die_errno(_("could not create directory of '%s'"),

          sb_repo.buf);

    strbuf_setlen(&sb_repo, len);

    strbuf_addf(&sb_repo, "%d", counter);

  }

  name = strrchr(sb_repo.buf, '/') + 1;

  junk_pid = getpid();

  atexit(remove_junk);

  sigchain_push_common(remove_junk_on_signal);

  junk_git_dir = xstrdup(sb_repo.buf);

  is_junk = 1;

  /*

   * lock the incomplete repo so prune won't delete it, unlock

   * after the preparation is over.

   */

  strbuf_addf(&sb, "%s/locked", sb_repo.buf);

  if (opts->keep_locked)

    write_file(sb.buf, "%s", opts->keep_locked);

  else

    write_file(sb.buf, _("initializing"));

  strbuf_addf(&sb_git, "%s/.git", path);

  if (safe_create_leading_directories_const(sb_git.buf))

    die_errno(_("could not create leading directories of '%s'"),

        sb_git.buf);

  junk_work_tree = xstrdup(path);

  strbuf_reset(&sb);

  strbuf_addf(&sb, "%s/gitdir", sb_repo.buf);

  strbuf_realpath(&realpath, sb_git.buf, 1);

  write_file(sb.buf, "%s", realpath.buf);

  strbuf_realpath(&realpath, get_git_common_dir(), 1);

  write_file(sb_git.buf, "gitdir: %s/worktrees/%s",

       realpath.buf, name);

  strbuf_reset(&sb);

  strbuf_addf(&sb, "%s/commondir", sb_repo.buf);

  write_file(sb.buf, "../..");

  /*

   * Set up the ref store of the worktree and create the HEAD reference.

   */

  wt = get_linked_worktree(name, 1);

  if (!wt) {

    ret = error(_("could not find created worktree '%s'"), name);

    goto done;

  }

  wt_refs = get_worktree_ref_store(wt);

  ret = ref_store_create_on_disk(wt_refs, REF_STORE_CREATE_ON_DISK_IS_WORKTREE, &sb);

  if (ret)

    goto done;

  if (!is_branch && commit)

    ret = refs_update_ref(wt_refs, NULL, "HEAD", &commit->object.oid,

              NULL, 0, UPDATE_REFS_MSG_ON_ERR);

  else

    ret = refs_update_symref(wt_refs, "HEAD", symref.buf, NULL);

  if (ret)

    goto done;

  /*

   * If the current worktree has sparse-checkout enabled, then copy

   * the sparse-checkout patterns from the current worktree.

   */

  if (core_apply_sparse_checkout)

    copy_sparse_checkout(sb_repo.buf);

  /*

   * If we are using worktree config, then copy all current config

   * values from the current worktree into the new one, that way the

   * new worktree behaves the same as this one.

   */

  if (the_repository->repository_format_worktree_config)

    copy_filtered_worktree_config(sb_repo.buf);

  strvec_pushf(&child_env, "%s=%s", GIT_DIR_ENVIRONMENT, sb_git.buf);

  strvec_pushf(&child_env, "%s=%s", GIT_WORK_TREE_ENVIRONMENT, path);

  if (opts->orphan &&

      (ret = make_worktree_orphan(refname, opts, &child_env)))

    goto done;

  if (opts->checkout &&

      (ret = checkout_worktree(opts, &child_env)))

    goto done;

  is_junk = 0;

  FREE_AND_NULL(junk_work_tree);

  FREE_AND_NULL(junk_git_dir);

done:

  if (ret || !opts->keep_locked) {

    strbuf_reset(&sb);

    strbuf_addf(&sb, "%s/locked", sb_repo.buf);

    unlink_or_warn(sb.buf);

  }

  /*

   * Hook failure does not warrant worktree deletion, so run hook after

   * is_junk is cleared, but do return appropriate code when hook fails.

   */

  if (!ret && opts->checkout && !opts->orphan) {

    struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT;

    strvec_pushl(&opt.env, "GIT_DIR", "GIT_WORK_TREE", NULL);

    strvec_pushl(&opt.args,

           oid_to_hex(null_oid()),

           oid_to_hex(&commit->object.oid),

           "1",

           NULL);

    opt.dir = path;

    ret = run_hooks_opt(the_repository, "post-checkout", &opt);

  }

  strvec_clear(&child_env);

  strbuf_release(&sb);

  strbuf_release(&symref);

  strbuf_release(&sb_repo);

  strbuf_release(&sb_git);

  strbuf_release(&sb_name);

  strbuf_release(&realpath);

  free_worktree(wt);

  return ret;

}

static void print_preparing_worktree_line(int detach,

            const char *branch,

            const char *new_branch,

            int force_new_branch)

{

  if (force_new_branch) {

    struct commit *commit = lookup_commit_reference_by_name(new_branch);

    if (!commit)

      fprintf_ln(stderr, _("Preparing worktree (new branch '%s')"), new_branch);

    else

      fprintf_ln(stderr, _("Preparing worktree (resetting branch '%s'; was at %s)"),

          new_branch,

          repo_find_unique_abbrev(the_repository, &commit->object.oid, DEFAULT_ABBREV));

  } else if (new_branch) {

    fprintf_ln(stderr, _("Preparing worktree (new branch '%s')"), new_branch);

  } else {

    struct strbuf s = STRBUF_INIT;

    if (!detach && !strbuf_check_branch_ref(&s, branch) &&

        refs_ref_exists(get_main_ref_store(the_repository), s.buf))

      fprintf_ln(stderr, _("Preparing worktree (checking out '%s')"),

          branch);

    else {

      struct commit *commit = lookup_commit_reference_by_name(branch);

      if (!commit)

        BUG(_("unreachable: invalid reference: %s"), branch);

      fprintf_ln(stderr, _("Preparing worktree (detached HEAD %s)"),

          repo_find_unique_abbrev(the_repository, &commit->object.oid, DEFAULT_ABBREV));

    }

    strbuf_release(&s);

  }

}

/**

 * Callback to short circuit iteration over refs on the first reference

 * corresponding to a valid oid.

 *

 * Returns 0 on failure and non-zero on success.

 */

static int first_valid_ref(const char *refname UNUSED,

         const char *referent UNUSED,

         const struct object_id *oid UNUSED,

         int flags UNUSED,

         void *cb_data UNUSED)

{

  return 1;

}

/**

 * Verifies HEAD and determines whether there exist any valid local references.

 *

 * - Checks whether HEAD points to a valid reference.

 *

 * - Checks whether any valid local branches exist.

 *

 * - Emits a warning if there exist any valid branches but HEAD does not point

 *   to a valid reference.

 *

 * Returns 1 if any of the previous checks are true, otherwise returns 0.

 */

static int can_use_local_refs(const struct add_opts *opts)

{

  if (refs_head_ref(get_main_ref_store(the_repository), first_valid_ref, NULL)) {

    return 1;

  } else if (refs_for_each_branch_ref(get_main_ref_store(the_repository), first_valid_ref, NULL)) {

    if (!opts->quiet) {

      struct strbuf path = STRBUF_INIT;

      struct strbuf contents = STRBUF_INIT;

      strbuf_add_real_path(&path, get_worktree_git_dir(NULL));

      strbuf_addstr(&path, "/HEAD");

      strbuf_read_file(&contents, path.buf, 64);

      strbuf_stripspace(&contents, NULL);

      strbuf_strip_suffix(&contents, "\n");

      warning(_("HEAD points to an invalid (or orphaned) reference.\n"

          "HEAD path: '%s'\n"

          "HEAD contents: '%s'"),

          path.buf, contents.buf);

      strbuf_release(&path);

      strbuf_release(&contents);

    }

    return 1;

  }

  return 0;

}

/**

 * Reports whether the necessary flags were set and whether the repository has

 * remote references to attempt DWIM tracking of upstream branches.

 *

 * 1. Checks that `--guess-remote` was used or `worktree.guessRemote = true`.

 *

 * 2. Checks whether any valid remote branches exist.

 *

 * 3. Checks that there exists at least one remote and emits a warning/error

 *    if both checks 1. and 2. are false (can be bypassed with `--force`).

 *

 * Returns 1 if checks 1. and 2. are true, otherwise 0.

 */

static int can_use_remote_refs(const struct add_opts *opts)

{

  if (!guess_remote) {

    return 0;

  } else if (refs_for_each_remote_ref(get_main_ref_store(the_repository), first_valid_ref, NULL)) {

    return 1;

  } else if (!opts->force && remote_get(NULL)) {

    die(_("No local or remote refs exist despite at least one remote\n"

          "present, stopping; use 'add -f' to override or fetch a remote first"));

  }

  return 0;

}

/**

 * Determines whether `--orphan` should be inferred in the evaluation of

 * `worktree add path/` or `worktree add -b branch path/` and emits an error

 * if the supplied arguments would produce an illegal combination when the

 * `--orphan` flag is included.

 *

 * `opts` and `opt_track` contain the other options & flags supplied to the

 * command.

 *

 * remote determines whether to check `can_use_remote_refs()` or not. This

 * is primarily to differentiate between the basic `add` DWIM and `add -b`.

 *

 * Returns 1 when inferring `--orphan`, 0 otherwise, and emits an error when

 * `--orphan` is inferred but doing so produces an illegal combination of

 * options and flags. Additionally produces an error when remote refs are

 * checked and the repo is in a state that looks like the user added a remote

 * but forgot to fetch (and did not override the warning with -f).

 */

static int dwim_orphan(const struct add_opts *opts, int opt_track, int remote)

{

  if (can_use_local_refs(opts)) {

    return 0;

  } else if (remote && can_use_remote_refs(opts)) {

    return 0;

  } else if (!opts->quiet) {

    fprintf_ln(stderr, WORKTREE_ADD_DWIM_ORPHAN_INFER_TEXT);

  }

  if (opt_track) {

    die(_("options '%s' and '%s' cannot be used together"),

        "--orphan", "--track");

  } else if (!opts->checkout) {

    die(_("options '%s' and '%s' cannot be used together"),

        "--orphan", "--no-checkout");

  }

  return 1;

}

static char *dwim_branch(const char *path, char **new_branch)

{

  int n;

  int branch_exists;

  const char *s = worktree_basename(path, &n);

  char *branchname = xstrndup(s, n);

  struct strbuf ref = STRBUF_INIT;

  branch_exists = !strbuf_check_branch_ref(&ref, branchname) &&

      refs_ref_exists(get_main_ref_store(the_repository),

          ref.buf);

  strbuf_release(&ref);

  if (branch_exists)

    return branchname;

  *new_branch = branchname;

  if (guess_remote) {

    struct object_id oid;

    char *remote = unique_tracking_name(*new_branch, &oid, NULL);

    return remote;

  }

  return NULL;

}

static int add(int ac, const char **av, const char *prefix)

{

  struct add_opts opts;

  const char *new_branch_force = NULL;

  char *path;

  const char *branch;

  char *branch_to_free = NULL;

  char *new_branch_to_free = NULL;

  const char *new_branch = NULL;

  char *opt_track = NULL;

  const char *lock_reason = NULL;

  int keep_locked = 0;

  int used_new_branch_options;

  struct option options[] = {

    OPT__FORCE(&opts.force,

         N_("checkout <branch> even if already checked out in other worktree"),

         PARSE_OPT_NOCOMPLETE),

    OPT_STRING('b', NULL, &new_branch, N_("branch"),

         N_("create a new branch")),

    OPT_STRING('B', NULL, &new_branch_force, N_("branch"),

         N_("create or reset a branch")),

    OPT_BOOL(0, "orphan", &opts.orphan, N_("create unborn branch")),

    OPT_BOOL('d', "detach", &opts.detach, N_("detach HEAD at named commit")),

    OPT_BOOL(0, "checkout", &opts.checkout, N_("populate the new working tree")),

    OPT_BOOL(0, "lock", &keep_locked, N_("keep the new working tree locked")),

    OPT_STRING(0, "reason", &lock_reason, N_("string"),

         N_("reason for locking")),

    OPT__QUIET(&opts.quiet, N_("suppress progress reporting")),

    OPT_PASSTHRU(0, "track", &opt_track, NULL,

           N_("set up tracking mode (see git-branch(1))"),

           PARSE_OPT_NOARG | PARSE_OPT_OPTARG),

    OPT_BOOL(0, "guess-remote", &guess_remote,

       N_("try to match the new branch name with a remote-tracking branch")),

    OPT_END()

  };

  int ret;

  memset(&opts, 0, sizeof(opts));

  opts.checkout = 1;

  ac = parse_options(ac, av, prefix, options, git_worktree_add_usage, 0);

  if (!!opts.detach + !!new_branch + !!new_branch_force > 1)

    die(_("options '%s', '%s', and '%s' cannot be used together"), "-b", "-B", "--detach");

  if (opts.detach && opts.orphan)

    die(_("options '%s' and '%s' cannot be used together"),

        "--orphan", "--detach");

  if (opts.orphan && opt_track)

    die(_("options '%s' and '%s' cannot be used together"),

        "--orphan", "--track");

  if (opts.orphan && !opts.checkout)

    die(_("options '%s' and '%s' cannot be used together"),

        "--orphan", "--no-checkout");

  if (opts.orphan && ac == 2)

    die(_("option '%s' and commit-ish cannot be used together"),

        "--orphan");

  if (lock_reason && !keep_locked)

    die(_("the option '%s' requires '%s'"), "--reason", "--lock");

  if (lock_reason)

    opts.keep_locked = lock_reason;

  else if (keep_locked)

    opts.keep_locked = _("added with --lock");

  if (ac < 1 || ac > 2)

    usage_with_options(git_worktree_add_usage, options);

  path = prefix_filename(prefix, av[0]);

  branch = ac < 2 ? "HEAD" : av[1];

  used_new_branch_options = new_branch || new_branch_force;

  if (!strcmp(branch, "-"))

    branch = "@{-1}";

  if (new_branch_force) {

    struct strbuf symref = STRBUF_INIT;

    new_branch = new_branch_force;

    if (!opts.force &&

        !strbuf_check_branch_ref(&symref, new_branch) &&

        refs_ref_exists(get_main_ref_store(the_repository), symref.buf))

      die_if_checked_out(symref.buf, 0);

    strbuf_release(&symref);

  }

  if (opts.orphan && !new_branch) {

    int n;

    const char *s = worktree_basename(path, &n);

    new_branch = new_branch_to_free = xstrndup(s, n);

  } else if (opts.orphan) {

    ; /* no-op */

  } else if (opts.detach) {

    /* Check HEAD */

    if (!strcmp(branch, "HEAD"))

      can_use_local_refs(&opts);

  } else if (ac < 2 && new_branch) {

    /* DWIM: Infer --orphan when repo has no refs. */

    opts.orphan = dwim_orphan(&opts, !!opt_track, 0);

  } else if (ac < 2) {

    /* DWIM: Guess branch name from path. */

    char *s = dwim_branch(path, &new_branch_to_free);

    if (s)

      branch = branch_to_free = s;

    new_branch = new_branch_to_free;

    /* DWIM: Infer --orphan when repo has no refs. */

    opts.orphan = (!s) && dwim_orphan(&opts, !!opt_track, 1);

  } else if (ac == 2) {

    struct object_id oid;

    struct commit *commit;

    char *remote;

    commit = lookup_commit_reference_by_name(branch);

    if (!commit) {

      remote = unique_tracking_name(branch, &oid, NULL);

      if (remote) {

        new_branch = branch;

        branch = new_branch_to_free = remote;

      }

    }

    if (!strcmp(branch, "HEAD"))

      can_use_local_refs(&opts);

  }