#include "builtin.h"

#include "config.h"

#include "gettext.h"

#include "repository.h"

#include "revision.h"

#include "reachable.h"

#include "wildmatch.h"

#include "worktree.h"

#include "reflog.h"

#include "refs.h"

#include "parse-options.h"

#define BUILTIN_REFLOG_SHOW_USAGE \

  N_("git reflog [show] [<log-options>] [<ref>]")

#define BUILTIN_REFLOG_LIST_USAGE \

  N_("git reflog list")

#define BUILTIN_REFLOG_EXPIRE_USAGE \

  N_("git reflog expire [--expire=<time>] [--expire-unreachable=<time>]\n" \

     "                  [--rewrite] [--updateref] [--stale-fix]\n" \

     "                  [--dry-run | -n] [--verbose] [--all [--single-worktree] | <refs>...]")

#define BUILTIN_REFLOG_DELETE_USAGE \

  N_("git reflog delete [--rewrite] [--updateref]\n" \

     "                  [--dry-run | -n] [--verbose] <ref>@{<specifier>}...")

#define BUILTIN_REFLOG_EXISTS_USAGE \

  N_("git reflog exists <ref>")

static const char *const reflog_show_usage[] = {

  BUILTIN_REFLOG_SHOW_USAGE,

  NULL,

};

static const char *const reflog_list_usage[] = {

  BUILTIN_REFLOG_LIST_USAGE,

  NULL,

};

static const char *const reflog_expire_usage[] = {

  BUILTIN_REFLOG_EXPIRE_USAGE,

  NULL

};

static const char *const reflog_delete_usage[] = {

  BUILTIN_REFLOG_DELETE_USAGE,

  NULL

};

static const char *const reflog_exists_usage[] = {

  BUILTIN_REFLOG_EXISTS_USAGE,

  NULL,

};

static const char *const reflog_usage[] = {

  BUILTIN_REFLOG_SHOW_USAGE,

  BUILTIN_REFLOG_LIST_USAGE,

  BUILTIN_REFLOG_EXPIRE_USAGE,

  BUILTIN_REFLOG_DELETE_USAGE,

  BUILTIN_REFLOG_EXISTS_USAGE,

  NULL

};

static timestamp_t default_reflog_expire;

static timestamp_t default_reflog_expire_unreachable;

struct worktree_reflogs {

  struct worktree *worktree;

  struct string_list reflogs;

};

static int collect_reflog(const char *ref, void *cb_data)

{

  struct worktree_reflogs *cb = cb_data;

  struct worktree *worktree = cb->worktree;

  struct strbuf newref = STRBUF_INIT;

  /*

   * Avoid collecting the same shared ref multiple times because

   * they are available via all worktrees.

   */

  if (!worktree->is_current &&

      parse_worktree_ref(ref, NULL, NULL, NULL) == REF_WORKTREE_SHARED)

    return 0;

  strbuf_worktree_ref(worktree, &newref, ref);

  string_list_append_nodup(&cb->reflogs, strbuf_detach(&newref, NULL));

  return 0;

}

static struct reflog_expire_cfg {

  struct reflog_expire_cfg *next;

  timestamp_t expire_total;

  timestamp_t expire_unreachable;

  char pattern[FLEX_ARRAY];

} *reflog_expire_cfg, **reflog_expire_cfg_tail;

static struct reflog_expire_cfg *find_cfg_ent(const char *pattern, size_t len)

{

  struct reflog_expire_cfg *ent;

  if (!reflog_expire_cfg_tail)

    reflog_expire_cfg_tail = &reflog_expire_cfg;

  for (ent = reflog_expire_cfg; ent; ent = ent->next)

    if (!xstrncmpz(ent->pattern, pattern, len))

      return ent;

  FLEX_ALLOC_MEM(ent, pattern, pattern, len);

  *reflog_expire_cfg_tail = ent;

  reflog_expire_cfg_tail = &(ent->next);

  return ent;

}

/* expiry timer slot */

#define EXPIRE_TOTAL   01

#define EXPIRE_UNREACH 02

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

        const struct config_context *ctx, void *cb)

{

  const char *pattern, *key;

  size_t pattern_len;

  timestamp_t expire;

  int slot;

  struct reflog_expire_cfg *ent;

  if (parse_config_key(var, "gc", &pattern, &pattern_len, &key) < 0)

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

  if (!strcmp(key, "reflogexpire")) {

    slot = EXPIRE_TOTAL;

    if (git_config_expiry_date(&expire, var, value))

      return -1;

  } else if (!strcmp(key, "reflogexpireunreachable")) {

    slot = EXPIRE_UNREACH;

    if (git_config_expiry_date(&expire, var, value))

      return -1;

  } else

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

  if (!pattern) {

    switch (slot) {

    case EXPIRE_TOTAL:

      default_reflog_expire = expire;

      break;

    case EXPIRE_UNREACH:

      default_reflog_expire_unreachable = expire;

      break;

    }

    return 0;

  }

  ent = find_cfg_ent(pattern, pattern_len);

  if (!ent)

    return -1;

  switch (slot) {

  case EXPIRE_TOTAL:

    ent->expire_total = expire;

    break;

  case EXPIRE_UNREACH:

    ent->expire_unreachable = expire;

    break;

  }

  return 0;

}

static void set_reflog_expiry_param(struct cmd_reflog_expire_cb *cb, const char *ref)

{

  struct reflog_expire_cfg *ent;

  if (cb->explicit_expiry == (EXPIRE_TOTAL|EXPIRE_UNREACH))

    return; /* both given explicitly -- nothing to tweak */

  for (ent = reflog_expire_cfg; ent; ent = ent->next) {

    if (!wildmatch(ent->pattern, ref, 0)) {

      if (!(cb->explicit_expiry & EXPIRE_TOTAL))

        cb->expire_total = ent->expire_total;

      if (!(cb->explicit_expiry & EXPIRE_UNREACH))

        cb->expire_unreachable = ent->expire_unreachable;

      return;

    }

  }

  /*

   * If unconfigured, make stash never expire

   */

  if (!strcmp(ref, "refs/stash")) {

    if (!(cb->explicit_expiry & EXPIRE_TOTAL))

      cb->expire_total = 0;

    if (!(cb->explicit_expiry & EXPIRE_UNREACH))

      cb->expire_unreachable = 0;

    return;

  }

  /* Nothing matched -- use the default value */

  if (!(cb->explicit_expiry & EXPIRE_TOTAL))

    cb->expire_total = default_reflog_expire;

  if (!(cb->explicit_expiry & EXPIRE_UNREACH))

    cb->expire_unreachable = default_reflog_expire_unreachable;

}

static int expire_unreachable_callback(const struct option *opt,

         const char *arg,

         int unset)

{

  struct cmd_reflog_expire_cb *cmd = opt->value;

  BUG_ON_OPT_NEG(unset);

  if (parse_expiry_date(arg, &cmd->expire_unreachable))

    die(_("invalid timestamp '%s' given to '--%s'"),

        arg, opt->long_name);

  cmd->explicit_expiry |= EXPIRE_UNREACH;

  return 0;

}

static int expire_total_callback(const struct option *opt,

         const char *arg,

         int unset)

{

  struct cmd_reflog_expire_cb *cmd = opt->value;

  BUG_ON_OPT_NEG(unset);

  if (parse_expiry_date(arg, &cmd->expire_total))

    die(_("invalid timestamp '%s' given to '--%s'"),

        arg, opt->long_name);

  cmd->explicit_expiry |= EXPIRE_TOTAL;

  return 0;

}

static int cmd_reflog_show(int argc, const char **argv, const char *prefix)

{

  struct option options[] = {

    OPT_END()

  };

  parse_options(argc, argv, prefix, options, reflog_show_usage,

          PARSE_OPT_KEEP_DASHDASH | PARSE_OPT_KEEP_ARGV0 |

          PARSE_OPT_KEEP_UNKNOWN_OPT);

  return cmd_log_reflog(argc, argv, prefix);

}

static int show_reflog(const char *refname, void *cb_data UNUSED)

{

  printf("%s\n", refname);

  return 0;

}

static int cmd_reflog_list(int argc, const char **argv, const char *prefix)

{

  struct option options[] = {

    OPT_END()

  };

  struct ref_store *ref_store;

  argc = parse_options(argc, argv, prefix, options, reflog_list_usage, 0);

  if (argc)

    return error(_("%s does not accept arguments: '%s'"),

           "list", argv[0]);

  ref_store = get_main_ref_store(the_repository);

  return refs_for_each_reflog(ref_store, show_reflog, NULL);

}

static int cmd_reflog_expire(int argc, const char **argv, const char *prefix)

{

  struct cmd_reflog_expire_cb cmd = { 0 };

  timestamp_t now = time(NULL);

  int i, status, do_all, single_worktree = 0;

  unsigned int flags = 0;

  int verbose = 0;

  reflog_expiry_should_prune_fn *should_prune_fn = should_expire_reflog_ent;

  const struct option options[] = {

    OPT_BIT('n', "dry-run", &flags, N_("do not actually prune any entries"),

      EXPIRE_REFLOGS_DRY_RUN),

    OPT_BIT(0, "rewrite", &flags,

      N_("rewrite the old SHA1 with the new SHA1 of the entry that now precedes it"),

      EXPIRE_REFLOGS_REWRITE),

    OPT_BIT(0, "updateref", &flags,

      N_("update the reference to the value of the top reflog entry"),

      EXPIRE_REFLOGS_UPDATE_REF),

    OPT_BOOL(0, "verbose", &verbose, N_("print extra information on screen")),

    OPT_CALLBACK_F(0, "expire", &cmd, N_("timestamp"),

             N_("prune entries older than the specified time"),

             PARSE_OPT_NONEG,

             expire_total_callback),

    OPT_CALLBACK_F(0, "expire-unreachable", &cmd, N_("timestamp"),

             N_("prune entries older than <time> that are not reachable from the current tip of the branch"),

             PARSE_OPT_NONEG,

             expire_unreachable_callback),

    OPT_BOOL(0, "stale-fix", &cmd.stalefix,

       N_("prune any reflog entries that point to broken commits")),

    OPT_BOOL(0, "all", &do_all, N_("process the reflogs of all references")),

    OPT_BOOL(0, "single-worktree", &single_worktree,

       N_("limits processing to reflogs from the current worktree only")),

    OPT_END()

  };

  default_reflog_expire_unreachable = now - 30 * 24 * 3600;

  default_reflog_expire = now - 90 * 24 * 3600;

  git_config(reflog_expire_config, NULL);

  save_commit_buffer = 0;

  do_all = status = 0;

  cmd.explicit_expiry = 0;

  cmd.expire_total = default_reflog_expire;

  cmd.expire_unreachable = default_reflog_expire_unreachable;

  argc = parse_options(argc, argv, prefix, options, reflog_expire_usage, 0);

  if (verbose)

    should_prune_fn = should_expire_reflog_ent_verbose;

  /*

   * We can trust the commits and objects reachable from refs

   * even in older repository.  We cannot trust what's reachable

   * from reflog if the repository was pruned with older git.

   */

  if (cmd.stalefix) {

    struct rev_info revs;

    repo_init_revisions(the_repository, &revs, prefix);

    revs.do_not_die_on_missing_objects = 1;

    revs.ignore_missing = 1;

    revs.ignore_missing_links = 1;

    if (verbose)

      printf(_("Marking reachable objects..."));

    mark_reachable_objects(&revs, 0, 0, NULL);

    release_revisions(&revs);

    if (verbose)

      putchar('\n');

  }

  if (do_all) {

    struct worktree_reflogs collected = {

      .reflogs = STRING_LIST_INIT_DUP,

    };

    struct string_list_item *item;

    struct worktree **worktrees, **p;

    worktrees = get_worktrees();

    for (p = worktrees; *p; p++) {

      if (single_worktree && !(*p)->is_current)

        continue;

      collected.worktree = *p;

      refs_for_each_reflog(get_worktree_ref_store(*p),

               collect_reflog, &collected);

    }

    free_worktrees(worktrees);

    for_each_string_list_item(item, &collected.reflogs) {

      struct expire_reflog_policy_cb cb = {

        .cmd = cmd,

        .dry_run = !!(flags & EXPIRE_REFLOGS_DRY_RUN),

      };

      set_reflog_expiry_param(&cb.cmd,  item->string);

      status |= refs_reflog_expire(get_main_ref_store(the_repository),

                 item->string, flags,

                 reflog_expiry_prepare,

                 should_prune_fn,

                 reflog_expiry_cleanup,

                 &cb);

    }

    string_list_clear(&collected.reflogs, 0);

  }

  for (i = 0; i < argc; i++) {

    char *ref;

    struct expire_reflog_policy_cb cb = { .cmd = cmd };

    if (!repo_dwim_log(the_repository, argv[i], strlen(argv[i]), NULL, &ref)) {

      status |= error(_("%s points nowhere!"), argv[i]);

      continue;

    }

    set_reflog_expiry_param(&cb.cmd, ref);

    status |= refs_reflog_expire(get_main_ref_store(the_repository),

               ref, flags,

               reflog_expiry_prepare,

               should_prune_fn,

               reflog_expiry_cleanup,

               &cb);

    free(ref);

  }

  return status;

}

static int cmd_reflog_delete(int argc, const char **argv, const char *prefix)

{

  int i, status = 0;

  unsigned int flags = 0;

  int verbose = 0;

  const struct option options[] = {

    OPT_BIT('n', "dry-run", &flags, N_("do not actually prune any entries"),

      EXPIRE_REFLOGS_DRY_RUN),

    OPT_BIT(0, "rewrite", &flags,

      N_("rewrite the old SHA1 with the new SHA1 of the entry that now precedes it"),

      EXPIRE_REFLOGS_REWRITE),

    OPT_BIT(0, "updateref", &flags,

      N_("update the reference to the value of the top reflog entry"),

      EXPIRE_REFLOGS_UPDATE_REF),

    OPT_BOOL(0, "verbose", &verbose, N_("print extra information on screen")),

    OPT_END()

  };

  argc = parse_options(argc, argv, prefix, options, reflog_delete_usage, 0);

  if (argc < 1)

    return error(_("no reflog specified to delete"));

  for (i = 0; i < argc; i++)

    status |= reflog_delete(argv[i], flags, verbose);

  return status;

}

static int cmd_reflog_exists(int argc, const char **argv, const char *prefix)

{

  struct option options[] = {

    OPT_END()

  };

  const char *refname;

  argc = parse_options(argc, argv, prefix, options, reflog_exists_usage,

           0);

  if (!argc)

    usage_with_options(reflog_exists_usage, options);

  refname = argv[0];

  if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL))

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

  return !refs_reflog_exists(get_main_ref_store(the_repository),

           refname);

}

/*

 * main "reflog"

 */

int cmd_reflog(int argc, const char **argv, const char *prefix)

{

  parse_opt_subcommand_fn *fn = NULL;

  struct option options[] = {

    OPT_SUBCOMMAND("show", &fn, cmd_reflog_show),

    OPT_SUBCOMMAND("list", &fn, cmd_reflog_list),

    OPT_SUBCOMMAND("expire", &fn, cmd_reflog_expire),

    OPT_SUBCOMMAND("delete", &fn, cmd_reflog_delete),

    OPT_SUBCOMMAND("exists", &fn, cmd_reflog_exists),

    OPT_END()

  };

  argc = parse_options(argc, argv, prefix, options, reflog_usage,

           PARSE_OPT_SUBCOMMAND_OPTIONAL |

           PARSE_OPT_KEEP_DASHDASH | PARSE_OPT_KEEP_ARGV0 |

           PARSE_OPT_KEEP_UNKNOWN_OPT);

  if (fn)

    return fn(argc - 1, argv + 1, prefix);

  else

    return cmd_log_reflog(argc, argv, prefix);

}