/*
 * shelf.c:  implementation of shelving
 *
 * ====================================================================
 *    Licensed to the Apache Software Foundation (ASF) under one
 *    or more contributor license agreements.  See the NOTICE file
 *    distributed with this work for additional information
 *    regarding copyright ownership.  The ASF licenses this file
 *    to you under the Apache License, Version 2.0 (the
 *    "License"); you may not use this file except in compliance
 *    with the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing,
 *    software distributed under the License is distributed on an
 *    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 *    KIND, either express or implied.  See the License for the
 *    specific language governing permissions and limitations
 *    under the License.
 * ====================================================================
 */

/* ==================================================================== */

/* We define this here to remove any further warnings about the usage of
   experimental functions in this file. */
#define SVN_EXPERIMENTAL

#include "svn_client.h"
#include "svn_wc.h"
#include "svn_pools.h"
#include "svn_dirent_uri.h"
#include "svn_path.h"
#include "svn_hash.h"
#include "svn_utf.h"
#include "svn_ctype.h"
#include "svn_props.h"

#include "client.h"
#include "private/svn_client_private.h"
#include "private/svn_wc_private.h"
#include "private/svn_sorts_private.h"
#include "svn_private_config.h"


static svn_error_t *
shelf_name_encode(char **encoded_name_p,
                  const char *name,
                  apr_pool_t *result_pool)
{
  char *encoded_name
    = apr_palloc(result_pool, strlen(name) * 2 + 1);
  char *out_pos = encoded_name;

  if (name[0] == '\0')
    return svn_error_create(SVN_ERR_BAD_CHANGELIST_NAME, NULL,
                            _("Shelf name cannot be the empty string"));

  while (*name)
    {
      apr_snprintf(out_pos, 3, "%02x", (unsigned char)(*name++));
      out_pos += 2;
    }
  *encoded_name_p = encoded_name;
  return SVN_NO_ERROR;
}

static svn_error_t *
shelf_name_decode(char **decoded_name_p,
                  const char *codename,
                  apr_pool_t *result_pool)
{
  svn_stringbuf_t *sb
    = svn_stringbuf_create_ensure(strlen(codename) / 2, result_pool);
  const char *input = codename;

  while (*input)
    {
      int c;
      int nchars;
      int nitems = sscanf(input, "%02x%n", &c, &nchars);

      if (nitems != 1 || nchars != 2)
        return svn_error_createf(SVN_ERR_BAD_CHANGELIST_NAME, NULL,
                                 _("Shelve: Bad encoded name '%s'"), codename);
      svn_stringbuf_appendbyte(sb, c);
      input += 2;
    }
  *decoded_name_p = sb->data;
  return SVN_NO_ERROR;
}

/* Set *NAME to the shelf name from FILENAME, if FILENAME names a '.current'
 * file, else to NULL. */
static svn_error_t *
shelf_name_from_filename(char **name,
                         const char *filename,
                         apr_pool_t *result_pool)
{
  size_t len = strlen(filename);
  static const char suffix[] = ".current";
  size_t suffix_len = sizeof(suffix) - 1;

  if (len > suffix_len && strcmp(filename + len - suffix_len, suffix) == 0)
    {
      char *codename = apr_pstrndup(result_pool, filename, len - suffix_len);
      SVN_ERR(shelf_name_decode(name, codename, result_pool));
    }
  else
    {
      *name = NULL;
    }
  return SVN_NO_ERROR;
}

/* Set *DIR to the shelf storage directory inside the WC's administrative
 * area. Ensure the directory exists. */
static svn_error_t *
get_shelves_dir(char **dir,
                svn_wc_context_t *wc_ctx,
                const char *local_abspath,
                apr_pool_t *result_pool,
                apr_pool_t *scratch_pool)
{
  char *experimental_abspath;

  SVN_ERR(svn_wc__get_experimental_dir(&experimental_abspath,
                                       wc_ctx, local_abspath,
                                       scratch_pool, scratch_pool));
  *dir = svn_dirent_join(experimental_abspath, "shelves/v3", result_pool);

  /* Ensure the directory exists. (Other versions of svn don't create it.) */
  SVN_ERR(svn_io_make_dir_recursively(*dir, scratch_pool));

  return SVN_NO_ERROR;
}

/* Set *ABSPATH to the abspath of the file storage dir for SHELF
 * version VERSION, no matter whether it exists.
 */
static svn_error_t *
shelf_version_files_dir_abspath(const char **abspath,
                                svn_client__shelf_t *shelf,
                                int version,
                                apr_pool_t *result_pool,
                                apr_pool_t *scratch_pool)
{
  char *codename;
  char *filename;

  SVN_ERR(shelf_name_encode(&codename, shelf->name, result_pool));
  filename = apr_psprintf(scratch_pool, "%s-%03d.wc", codename, version);
  *abspath = svn_dirent_join(shelf->shelves_dir, filename, result_pool);
  return SVN_NO_ERROR;
}

/* Create a shelf-version object for a version that may or may not already
 * exist on disk.
 */
static svn_error_t *
shelf_version_create(svn_client__shelf_version_t **new_version_p,
                     svn_client__shelf_t *shelf,
                     int version_number,
                     apr_pool_t *result_pool)
{
  svn_client__shelf_version_t *shelf_version
    = apr_pcalloc(result_pool, sizeof(*shelf_version));

  shelf_version->shelf = shelf;
  shelf_version->version_number = version_number;
  SVN_ERR(shelf_version_files_dir_abspath(&shelf_version->files_dir_abspath,
                                          shelf, version_number,
                                          result_pool, result_pool));
  *new_version_p = shelf_version;
  return SVN_NO_ERROR;
}

/* Delete the storage for SHELF:VERSION. */
static svn_error_t *
shelf_version_delete(svn_client__shelf_t *shelf,
                     int version,
                     apr_pool_t *scratch_pool)
{
  const char *files_dir_abspath;

  SVN_ERR(shelf_version_files_dir_abspath(&files_dir_abspath,
                                          shelf, version,
                                          scratch_pool, scratch_pool));
  SVN_ERR(svn_io_remove_dir2(files_dir_abspath, TRUE /*ignore_enoent*/,
                             NULL, NULL, /*cancel*/
                             scratch_pool));
  return SVN_NO_ERROR;
}

/*  */
static svn_error_t *
get_log_abspath(char **log_abspath,
                svn_client__shelf_t *shelf,
                apr_pool_t *result_pool,
                apr_pool_t *scratch_pool)
{
  char *codename;
  const char *filename;

  SVN_ERR(shelf_name_encode(&codename, shelf->name, result_pool));
  filename = apr_pstrcat(scratch_pool, codename, ".log", SVN_VA_NULL);
  *log_abspath = svn_dirent_join(shelf->shelves_dir, filename, result_pool);
  return SVN_NO_ERROR;
}

/* Set SHELF->revprops by reading from its storage (the '.log' file).
 * Set SHELF->revprops to empty if the storage file does not exist; this
 * is not an error.
 */
static svn_error_t *
shelf_read_revprops(svn_client__shelf_t *shelf,
                    apr_pool_t *scratch_pool)
{
  char *log_abspath;
  svn_error_t *err;
  svn_stream_t *stream;

  SVN_ERR(get_log_abspath(&log_abspath, shelf, scratch_pool, scratch_pool));

  shelf->revprops = apr_hash_make(shelf->pool);
  err = svn_stream_open_readonly(&stream, log_abspath,
                                 scratch_pool, scratch_pool);
  if (err && APR_STATUS_IS_ENOENT(err->apr_err))
    {
      svn_error_clear(err);
      return SVN_NO_ERROR;
    }
  else
    SVN_ERR(err);
  SVN_ERR(svn_hash_read2(shelf->revprops, stream, "PROPS-END", shelf->pool));
  SVN_ERR(svn_stream_close(stream));
  return SVN_NO_ERROR;
}

/* Write SHELF's revprops to its file storage.
 */
static svn_error_t *
shelf_write_revprops(svn_client__shelf_t *shelf,
                     apr_pool_t *scratch_pool)
{
  char *log_abspath;
  apr_file_t *file;
  svn_stream_t *stream;

  SVN_ERR(get_log_abspath(&log_abspath, shelf, scratch_pool, scratch_pool));

  SVN_ERR(svn_io_file_open(&file, log_abspath,
                           APR_FOPEN_WRITE | APR_FOPEN_CREATE | APR_FOPEN_TRUNCATE,
                           APR_FPROT_OS_DEFAULT, scratch_pool));
  stream = svn_stream_from_aprfile2(file, FALSE /*disown*/, scratch_pool);

  SVN_ERR(svn_hash_write2(shelf->revprops, stream, "PROPS-END", scratch_pool));
  SVN_ERR(svn_stream_close(stream));
  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf_revprop_set(svn_client__shelf_t *shelf,
                             const char *prop_name,
                             const svn_string_t *prop_val,
                             apr_pool_t *scratch_pool)
{
  svn_hash_sets(shelf->revprops, apr_pstrdup(shelf->pool, prop_name),
                svn_string_dup(prop_val, shelf->pool));
  SVN_ERR(shelf_write_revprops(shelf, scratch_pool));
  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf_revprop_set_all(svn_client__shelf_t *shelf,
                                 apr_hash_t *revprop_table,
                                 apr_pool_t *scratch_pool)
{
  if (revprop_table)
    shelf->revprops = svn_prop_hash_dup(revprop_table, shelf->pool);
  else
    shelf->revprops = apr_hash_make(shelf->pool);

  SVN_ERR(shelf_write_revprops(shelf, scratch_pool));
  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf_revprop_get(svn_string_t **prop_val,
                             svn_client__shelf_t *shelf,
                             const char *prop_name,
                             apr_pool_t *result_pool)
{
  *prop_val = svn_hash_gets(shelf->revprops, prop_name);
  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf_revprop_list(apr_hash_t **props,
                              svn_client__shelf_t *shelf,
                              apr_pool_t *result_pool)
{
  *props = shelf->revprops;
  return SVN_NO_ERROR;
}

/*  */
static svn_error_t *
get_current_abspath(char **current_abspath,
                    svn_client__shelf_t *shelf,
                    apr_pool_t *result_pool)
{
  char *codename;
  char *filename;

  SVN_ERR(shelf_name_encode(&codename, shelf->name, result_pool));
  filename = apr_psprintf(result_pool, "%s.current", codename);
  *current_abspath = svn_dirent_join(shelf->shelves_dir, filename, result_pool);
  return SVN_NO_ERROR;
}

/* Read SHELF->max_version from its storage (the '.current' file).
 * Set SHELF->max_version to -1 if that file does not exist.
 */
static svn_error_t *
shelf_read_current(svn_client__shelf_t *shelf,
                   apr_pool_t *scratch_pool)
{
  char *current_abspath;
  svn_error_t *err;

  SVN_ERR(get_current_abspath(&current_abspath, shelf, scratch_pool));
  err = svn_io_read_version_file(&shelf->max_version,
                                 current_abspath, scratch_pool);
  if (err)
    {
      shelf->max_version = -1;
      svn_error_clear(err);
      return SVN_NO_ERROR;
    }
  return SVN_NO_ERROR;
}

/*  */
static svn_error_t *
shelf_write_current(svn_client__shelf_t *shelf,
                    apr_pool_t *scratch_pool)
{
  char *current_abspath;

  SVN_ERR(get_current_abspath(&current_abspath, shelf, scratch_pool));
  SVN_ERR(svn_io_write_version_file(current_abspath, shelf->max_version,
                                    scratch_pool));
  return SVN_NO_ERROR;
}

/*-------------------------------------------------------------------------*/
/* Status Reporting */

/* Adjust a status STATUS_IN obtained from the shelf storage WC, to add
 * shelf-related metadata:
 *  - changelist: 'svn:shelf:SHELFNAME'
 */
static svn_error_t *
status_augment(svn_wc_status3_t **status_p,
               const svn_wc_status3_t *status_in,
               svn_client__shelf_version_t *shelf_version,
               apr_pool_t *result_pool)
{
  *status_p = svn_wc_dup_status3(status_in, result_pool);
  (*status_p)->changelist = apr_psprintf(result_pool, "svn:shelf:%s",
                                         shelf_version->shelf->name);
  return SVN_NO_ERROR;
}

/* Read status from shelf storage.
 */
static svn_error_t *
status_read(svn_wc_status3_t **status,
            svn_client__shelf_version_t *shelf_version,
            const char *relpath,
            apr_pool_t *result_pool,
            apr_pool_t *scratch_pool)
{
  svn_client_ctx_t *ctx = shelf_version->shelf->ctx;
  char *abspath
    = svn_dirent_join(shelf_version->files_dir_abspath, relpath,
                      scratch_pool);

  SVN_ERR(svn_wc_status3(status, ctx->wc_ctx, abspath,
                         result_pool, scratch_pool));
  SVN_ERR(status_augment(status, *status, shelf_version, result_pool));
  return SVN_NO_ERROR;
}

/* A visitor function type for use with shelf_status_walk().
 * The same as svn_wc_status_func4_t except relpath instead of abspath.
 */
typedef svn_error_t *(*shelf_status_visitor_t)(void *baton,
                                               const char *relpath,
                                               const svn_wc_status3_t *status,
                                               apr_pool_t *scratch_pool);

/* Baton for shelved_files_walk_visitor(). */
struct shelf_status_baton_t
{
  svn_client__shelf_version_t *shelf_version;
  shelf_status_visitor_t walk_func;
  void *walk_baton;
};

/* Convert a svn_wc_status_func4_t callback invocation to call a
 * shelf_status_visitor_t callback.
 *
 * Call BATON->walk_func(BATON->walk_baton, relpath, ...) for the shelved
 * storage path ABSPATH, converting ABSPATH to a WC-relative path, and
 * augmenting the STATUS.
 *
 * The opposite of wc_status_visitor().
 *
 * Implements svn_wc_status_func4_t. */
static svn_error_t *
shelf_status_visitor(void *baton,
                     const char *abspath,
                     const svn_wc_status3_t *status,
                     apr_pool_t *scratch_pool)
{
  struct shelf_status_baton_t *b = baton;
  const char *relpath;
  svn_wc_status3_t *new_status;

  relpath = svn_dirent_skip_ancestor(b->shelf_version->files_dir_abspath,
                                     abspath);
  SVN_ERR(status_augment(&new_status, status, b->shelf_version, scratch_pool));
  SVN_ERR(b->walk_func(b->walk_baton, relpath, new_status, scratch_pool));
  return SVN_NO_ERROR;
}

/* Report the shelved status of the path SHELF_VERSION:WC_RELPATH
 * via WALK_FUNC(WALK_BATON, ...).
 */
static svn_error_t *
shelf_status_visit_path(svn_client__shelf_version_t *shelf_version,
                        const char *wc_relpath,
                        shelf_status_visitor_t walk_func,
                        void *walk_baton,
                        apr_pool_t *scratch_pool)
{
  svn_wc_status3_t *status;

  SVN_ERR(status_read(&status, shelf_version, wc_relpath,
                      scratch_pool, scratch_pool));
  SVN_ERR(walk_func(walk_baton, wc_relpath, status, scratch_pool));
  return SVN_NO_ERROR;
}

/* Report the shelved status of all the shelved paths in SHELF_VERSION
 * at and under WC_RELPATH, via WALK_FUNC(WALK_BATON, ...).
 */
static svn_error_t *
shelf_status_walk(svn_client__shelf_version_t *shelf_version,
                  const char *wc_relpath,
                  shelf_status_visitor_t walk_func,
                  void *walk_baton,
                  apr_pool_t *scratch_pool)
{
  svn_client_ctx_t *ctx = shelf_version->shelf->ctx;
  char *walk_root_abspath
    = svn_dirent_join(shelf_version->files_dir_abspath, wc_relpath,
                      scratch_pool);
  struct shelf_status_baton_t baton;
  svn_error_t *err;

  baton.shelf_version = shelf_version;
  baton.walk_func = walk_func;
  baton.walk_baton = walk_baton;
  err = svn_wc_walk_status(ctx->wc_ctx, walk_root_abspath,
                           svn_depth_infinity,
                           FALSE /*get_all*/,
                           TRUE /*no_ignore*/,
                           FALSE /*ignore_text_mods*/,
                           NULL /*ignore_patterns: use the defaults*/,
                           shelf_status_visitor, &baton,
                           NULL, NULL, /*cancellation*/
                           scratch_pool);
  if (err && APR_STATUS_IS_ENOENT(err->apr_err))
    svn_error_clear(err);
  else
    SVN_ERR(err);

  return SVN_NO_ERROR;
}

/* Baton for wc_status_visitor(). */
typedef struct wc_status_baton_t
{
  svn_client__shelf_version_t *shelf_version;
  svn_wc_status_func4_t walk_func;
  void *walk_baton;
} wc_status_baton_t;

/* Convert a shelf_status_visitor_t callback invocation to call a
 * svn_wc_status_func4_t callback.
 *
 * Call BATON->walk_func(BATON->walk_baton, abspath, ...) for the WC-
 * relative path RELPATH, converting RELPATH to an abspath in the user's WC.
 *
 * The opposite of shelf_status_visitor().
 *
 * Implements shelf_status_visitor_t. */
static svn_error_t *
wc_status_visitor(void *baton,
                  const char *relpath,
                  const svn_wc_status3_t *status,
                  apr_pool_t *scratch_pool)
{
  struct wc_status_baton_t *b = baton;
  svn_client__shelf_t *shelf = b->shelf_version->shelf;
  const char *abspath = svn_dirent_join(shelf->wc_root_abspath, relpath,
                                        scratch_pool);
  SVN_ERR(b->walk_func(b->walk_baton, abspath, status, scratch_pool));
  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf_version_status_walk(svn_client__shelf_version_t *shelf_version,
                                     const char *wc_relpath,
                                     svn_wc_status_func4_t walk_func,
                                     void *walk_baton,
                                     apr_pool_t *scratch_pool)
{
  wc_status_baton_t baton;

  baton.shelf_version = shelf_version;
  baton.walk_func = walk_func;
  baton.walk_baton = walk_baton;
  SVN_ERR(shelf_status_walk(shelf_version, wc_relpath,
                            wc_status_visitor, &baton,
                            scratch_pool));
  return SVN_NO_ERROR;
}

/*-------------------------------------------------------------------------*/
/* Shelf Storage */

/* Construct a shelf object representing an empty shelf: no versions,
 * no revprops, no looking to see if such a shelf exists on disk.
 */
static svn_error_t *
shelf_construct(svn_client__shelf_t **shelf_p,
                const char *name,
                const char *local_abspath,
                svn_client_ctx_t *ctx,
                apr_pool_t *result_pool)
{
  svn_client__shelf_t *shelf = apr_palloc(result_pool, sizeof(*shelf));
  char *shelves_dir;

  SVN_ERR(svn_client_get_wc_root(&shelf->wc_root_abspath,
                                 local_abspath, ctx,
                                 result_pool, result_pool));
  SVN_ERR(get_shelves_dir(&shelves_dir, ctx->wc_ctx, local_abspath,
                          result_pool, result_pool));
  shelf->shelves_dir = shelves_dir;
  shelf->ctx = ctx;
  shelf->pool = result_pool;

  shelf->name = apr_pstrdup(result_pool, name);
  shelf->revprops = apr_hash_make(result_pool);
  shelf->max_version = 0;

  *shelf_p = shelf;
  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf_open_existing(svn_client__shelf_t **shelf_p,
                               const char *name,
                               const char *local_abspath,
                               svn_client_ctx_t *ctx,
                               apr_pool_t *result_pool)
{
  SVN_ERR(shelf_construct(shelf_p, name,
                          local_abspath, ctx, result_pool));
  SVN_ERR(shelf_read_revprops(*shelf_p, result_pool));
  SVN_ERR(shelf_read_current(*shelf_p, result_pool));
  if ((*shelf_p)->max_version < 0)
    {
      return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
                               _("Shelf '%s' not found"),
                               name);
    }
  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf_open_or_create(svn_client__shelf_t **shelf_p,
                                const char *name,
                                const char *local_abspath,
                                svn_client_ctx_t *ctx,
                                apr_pool_t *result_pool)
{
  svn_client__shelf_t *shelf;

  SVN_ERR(shelf_construct(&shelf, name,
                          local_abspath, ctx, result_pool));
  SVN_ERR(shelf_read_revprops(shelf, result_pool));
  SVN_ERR(shelf_read_current(shelf, result_pool));
  if (shelf->max_version < 0)
    {
      shelf->max_version = 0;
      SVN_ERR(shelf_write_current(shelf, result_pool));
    }
  *shelf_p = shelf;
  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf_close(svn_client__shelf_t *shelf,
                       apr_pool_t *scratch_pool)
{
  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf_delete(const char *name,
                        const char *local_abspath,
                        svn_boolean_t dry_run,
                        svn_client_ctx_t *ctx,
                        apr_pool_t *scratch_pool)
{
  svn_client__shelf_t *shelf;
  int i;
  char *abspath;

  SVN_ERR(svn_client__shelf_open_existing(&shelf, name,
                                         local_abspath, ctx, scratch_pool));

  /* Remove the versions. */
  for (i = shelf->max_version; i > 0; i--)
    {
      SVN_ERR(shelf_version_delete(shelf, i, scratch_pool));
    }

  /* Remove the other files */
  SVN_ERR(get_log_abspath(&abspath, shelf, scratch_pool, scratch_pool));
  SVN_ERR(svn_io_remove_file2(abspath, TRUE /*ignore_enoent*/, scratch_pool));
  SVN_ERR(get_current_abspath(&abspath, shelf, scratch_pool));
  SVN_ERR(svn_io_remove_file2(abspath, TRUE /*ignore_enoent*/, scratch_pool));

  SVN_ERR(svn_client__shelf_close(shelf, scratch_pool));
  return SVN_NO_ERROR;
}

/* Baton for paths_changed_visitor(). */
struct paths_changed_walk_baton_t
{
  apr_hash_t *paths_hash;
  const char *wc_root_abspath;
  apr_pool_t *pool;
};

/* Add to the list(s) in BATON, the RELPATH of a shelved 'binary' file.
 * Implements shelved_files_walk_func_t. */
static svn_error_t *
paths_changed_visitor(void *baton,
                      const char *relpath,
                      const svn_wc_status3_t *s,
                      apr_pool_t *scratch_pool)
{
  struct paths_changed_walk_baton_t *b = baton;

  relpath = apr_pstrdup(b->pool, relpath);
  svn_hash_sets(b->paths_hash, relpath, relpath);
  return SVN_NO_ERROR;
}

/* Get the paths changed, relative to WC root or as abspaths, as a hash
 * and/or an array (in no particular order).
 */
static svn_error_t *
shelf_paths_changed(apr_hash_t **paths_hash_p,
                    apr_array_header_t **paths_array_p,
                    svn_client__shelf_version_t *shelf_version,
                    apr_pool_t *result_pool,
                    apr_pool_t *scratch_pool)
{
  svn_client__shelf_t *shelf = shelf_version->shelf;
  apr_hash_t *paths_hash = apr_hash_make(result_pool);
  struct paths_changed_walk_baton_t baton;

  baton.paths_hash = paths_hash;
  baton.wc_root_abspath = shelf->wc_root_abspath;
  baton.pool = result_pool;
  SVN_ERR(shelf_status_walk(shelf_version, "",
                            paths_changed_visitor, &baton,
                            scratch_pool));

  if (paths_hash_p)
    *paths_hash_p = paths_hash;
  if (paths_array_p)
    SVN_ERR(svn_hash_keys(paths_array_p, paths_hash, result_pool));

  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf_paths_changed(apr_hash_t **affected_paths,
                               svn_client__shelf_version_t *shelf_version,
                               apr_pool_t *result_pool,
                               apr_pool_t *scratch_pool)
{
  SVN_ERR(shelf_paths_changed(affected_paths, NULL, shelf_version,
                              result_pool, scratch_pool));
  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf_replay(svn_client__shelf_version_t *shelf_version,
                         const char *top_relpath,
                         const svn_delta_editor_t *editor,
                         void *edit_baton,
                         svn_wc_notify_func2_t notify_func,
                         void *notify_baton,
                         apr_pool_t *scratch_pool)
{
  svn_client_ctx_t *ctx = shelf_version->shelf->ctx;
  apr_array_header_t *src_targets = apr_array_make(scratch_pool, 1,
                                                   sizeof(char *));
  const char *src_wc_abspath
    = svn_dirent_join(shelf_version->files_dir_abspath, top_relpath, scratch_pool);

  APR_ARRAY_PUSH(src_targets, const char *) = src_wc_abspath;
  SVN_ERR(svn_client__wc_replay(src_wc_abspath,
                                src_targets, svn_depth_infinity, NULL,
                                editor, edit_baton,
                                notify_func, notify_baton,
                                ctx, scratch_pool));
  return SVN_NO_ERROR;
}

/* Baton for test_apply_file_visitor(). */
struct test_apply_files_baton_t
{
  svn_client__shelf_version_t *shelf_version;
  svn_boolean_t conflict;  /* would it conflict? */
  svn_client_ctx_t *ctx;
};

/* Ideally, set BATON->conflict if we can't apply a change to WC
 * at RELPATH without conflict. But in fact, just check
 * if WC at RELPATH is locally modified.
 *
 * Implements shelved_files_walk_func_t. */
static svn_error_t *
test_apply_file_visitor(void *baton,
                        const char *relpath,
                        const svn_wc_status3_t *s,
                        apr_pool_t *scratch_pool)
{
  struct test_apply_files_baton_t *b = baton;
  const char *wc_root_abspath = b->shelf_version->shelf->wc_root_abspath;
  const char *to_wc_abspath = svn_dirent_join(wc_root_abspath, relpath,
                                              scratch_pool);
  svn_wc_status3_t *status;

  SVN_ERR(svn_wc_status3(&status, b->ctx->wc_ctx, to_wc_abspath,
                         scratch_pool, scratch_pool));
  switch (status->node_status)
    {
    case svn_wc_status_normal:
    case svn_wc_status_none:
      break;
    default:
      b->conflict = TRUE;
    }

  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf_test_apply_file(svn_boolean_t *conflict_p,
                                 svn_client__shelf_version_t *shelf_version,
                                 const char *file_relpath,
                                 apr_pool_t *scratch_pool)
{
  struct test_apply_files_baton_t baton = {0};

  baton.shelf_version = shelf_version;
  baton.conflict = FALSE;
  baton.ctx = shelf_version->shelf->ctx;
  SVN_ERR(shelf_status_visit_path(shelf_version, file_relpath,
                           test_apply_file_visitor, &baton,
                           scratch_pool));
  *conflict_p = baton.conflict;

  return SVN_NO_ERROR;
}

static svn_error_t *
wc_mods_editor(const svn_delta_editor_t **editor_p,
               void **edit_baton_p,
               const char *dst_wc_abspath,
               svn_wc_notify_func2_t notify_func,
               void *notify_baton,
               svn_client_ctx_t *ctx,
               apr_pool_t *result_pool,
               apr_pool_t *scratch_pool)
{
  svn_client__pathrev_t *base;
  const char *dst_wc_url;
  svn_ra_session_t *ra_session;

  /* We'll need an RA session to obtain the base of any copies */
  SVN_ERR(svn_client__wc_node_get_base(&base,
                                       dst_wc_abspath, ctx->wc_ctx,
                                       scratch_pool, scratch_pool));
  dst_wc_url = base->url;
  SVN_ERR(svn_client_open_ra_session2(&ra_session,
                                      dst_wc_url, dst_wc_abspath,
                                      ctx, result_pool, scratch_pool));
  SVN_ERR(svn_client__wc_editor(editor_p, edit_baton_p,
                                dst_wc_abspath,
                                notify_func, notify_baton,
                                ra_session, ctx, result_pool));
  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf_mods_editor(const svn_delta_editor_t **editor_p,
                              void **edit_baton_p,
                              svn_client__shelf_version_t *shelf_version,
                              svn_wc_notify_func2_t notify_func,
                              void *notify_baton,
                              svn_client_ctx_t *ctx,
                              apr_pool_t *result_pool)
{
  SVN_ERR(wc_mods_editor(editor_p, edit_baton_p,
                         shelf_version->files_dir_abspath,
                         notify_func, notify_baton,
                         ctx, result_pool, result_pool));
  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf_apply(svn_client__shelf_version_t *shelf_version,
                       svn_boolean_t dry_run,
                       apr_pool_t *scratch_pool)
{
  svn_client__shelf_t *shelf = shelf_version->shelf;
  const svn_delta_editor_t *editor;
  void *edit_baton;

  SVN_ERR(wc_mods_editor(&editor, &edit_baton,
                         shelf->wc_root_abspath,
                         NULL, NULL, /*notification*/
                         shelf->ctx, scratch_pool, scratch_pool));

  SVN_ERR(svn_client__shelf_replay(shelf_version, "",
                                   editor, edit_baton,
                                   shelf->ctx->notify_func2, shelf->ctx->notify_baton2,
                                   scratch_pool));

  svn_io_sleep_for_timestamps(shelf->wc_root_abspath,
                              scratch_pool);
  return SVN_NO_ERROR;
}

/* Baton for paths_changed_visitor(). */
struct unapply_walk_baton_t
{
  const char *wc_root_abspath;
  svn_boolean_t dry_run;
  svn_boolean_t use_commit_times;
  svn_client_ctx_t *ctx;
  apr_pool_t *pool;
};

/* Revert the change at RELPATH in the user's WC.
 * Implements shelved_files_walk_func_t. */
static svn_error_t *
unapply_visitor(void *baton,
                const char *relpath,
                const svn_wc_status3_t *s,
                apr_pool_t *scratch_pool)
{
  struct unapply_walk_baton_t *b = baton;
  const char *abspath = svn_dirent_join(b->wc_root_abspath, relpath,
                                        scratch_pool);

  if (!b->dry_run)
    {
      apr_array_header_t *targets
        = apr_array_make(scratch_pool, 1, sizeof(char *));
      svn_depth_t depth;

      APR_ARRAY_PUSH(targets, const char *) = abspath;

      /* If the local modification is a "delete" then revert it all
         (recursively). Otherwise we'd have to walk paths in
         top-down order to revert a delete, whereas we need bottom-up
         order to revert children of an added directory. */
      if (s->node_status == svn_wc_status_deleted
          || s->node_status == svn_wc_status_replaced
          || s->node_status == svn_wc_status_added)
        depth = svn_depth_infinity;
      else
        depth = svn_depth_empty;
      SVN_ERR(svn_wc_revert6(b->ctx->wc_ctx,
                             abspath,
                             depth,
                             b->use_commit_times,
                             NULL /*changelists*/,
                             FALSE /*clear_changelists*/,
                             FALSE /*metadata_only*/,
                             FALSE /*added_keep_local*/,
                             b->ctx->cancel_func, b->ctx->cancel_baton,
                             NULL, NULL, /*notification*/
                             scratch_pool));
    }
  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf_unapply(svn_client__shelf_version_t *shelf_version,
                         svn_boolean_t dry_run,
                         apr_pool_t *scratch_pool)
{
  svn_client_ctx_t *ctx = shelf_version->shelf->ctx;
  svn_client__shelf_t *shelf = shelf_version->shelf;
  struct unapply_walk_baton_t baton;
  svn_config_t *cfg;

  baton.wc_root_abspath = shelf->wc_root_abspath;
  baton.dry_run = dry_run;
  baton.ctx = ctx;
  baton.pool = scratch_pool;

  cfg = ctx->config ? svn_hash_gets(ctx->config, SVN_CONFIG_CATEGORY_CONFIG)
                    : NULL;
  SVN_ERR(svn_config_get_bool(cfg, &baton.use_commit_times,
                              SVN_CONFIG_SECTION_MISCELLANY,
                              SVN_CONFIG_OPTION_USE_COMMIT_TIMES, FALSE));

  SVN_WC__CALL_WITH_WRITE_LOCK(
    shelf_status_walk(shelf_version, "",
                      unapply_visitor, &baton,
                      scratch_pool),
    ctx->wc_ctx, shelf_version->shelf->wc_root_abspath,
    FALSE /*lock_anchor*/, scratch_pool);
  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf_delete_newer_versions(svn_client__shelf_t *shelf,
                                       svn_client__shelf_version_t *shelf_version,
                                       apr_pool_t *scratch_pool)
{
  int previous_version = shelf_version ? shelf_version->version_number : 0;
  int i;

  /* Delete any newer checkpoints */
  for (i = shelf->max_version; i > previous_version; i--)
    {
      SVN_ERR(shelf_version_delete(shelf, i, scratch_pool));
    }

  shelf->max_version = previous_version;
  SVN_ERR(shelf_write_current(shelf, scratch_pool));
  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf_diff(svn_client__shelf_version_t *shelf_version,
                       const char *shelf_relpath,
                       svn_depth_t depth,
                       svn_boolean_t ignore_ancestry,
                       const svn_diff_tree_processor_t *diff_processor,
                       apr_pool_t *scratch_pool)
{
  svn_client_ctx_t *ctx = shelf_version->shelf->ctx;
  char *local_abspath
    = svn_dirent_join(shelf_version->files_dir_abspath, shelf_relpath,
                      scratch_pool);

  if (shelf_version->version_number == 0)
    return SVN_NO_ERROR;

  SVN_ERR(svn_wc__diff7(FALSE /*anchor_at_given_paths*/,
                        ctx->wc_ctx, local_abspath,
                        depth,
                        ignore_ancestry,
                        NULL /*changelists*/,
                        diff_processor,
                        NULL, NULL, /*cancellation*/
                        scratch_pool, scratch_pool));
  return SVN_NO_ERROR;
}

/* Populate the storage a new shelf-version object NEW_SHELF_VERSION,
 * by creating a shelf storage WC with its base state copied from the
 * 'real' WC.
 */
static svn_error_t *
shelf_copy_base(svn_client__shelf_version_t *new_shelf_version,
                apr_pool_t *scratch_pool)
{
  svn_client_ctx_t *ctx = new_shelf_version->shelf->ctx;
  const char *users_wc_abspath = new_shelf_version->shelf->wc_root_abspath;
  svn_client__pathrev_t *users_wc_root_base;
  svn_opt_revision_t users_wc_root_rev;
  svn_ra_session_t *ra_session = NULL;
  svn_boolean_t sleep_here = FALSE;

  SVN_ERR(svn_client__wc_node_get_base(&users_wc_root_base,
                                       users_wc_abspath, ctx->wc_ctx,
                                       scratch_pool, scratch_pool));

  /* ### We need to read and recreate the mixed-rev, switched-URL,
     mixed-depth WC state; but for a rough start we'll just use
     HEAD, unswitched, depth-infinity. */
  users_wc_root_rev.kind = svn_opt_revision_head;

  /* ### TODO: Create an RA session that reads from the user's WC.
     For a rough start, we'll just let 'checkout' read from the repo. */

  SVN_ERR(svn_client__checkout_internal(NULL /*result_rev*/, &sleep_here,
                                        users_wc_root_base->url,
                                        new_shelf_version->files_dir_abspath,
                                        &users_wc_root_rev, &users_wc_root_rev,
                                        svn_depth_infinity,
                                        TRUE /*ignore_externals*/,
                                        FALSE /*allow_unver_obstructions*/,
                                        ra_session,
                                        ctx, scratch_pool));
  /* ### hopefully we won't eventually need to sleep_here... */
  if (sleep_here)
    svn_io_sleep_for_timestamps(new_shelf_version->files_dir_abspath,
                                scratch_pool);
  return SVN_NO_ERROR;
}

/*  */
struct shelf_save_notifer_baton_t
{
  svn_client__shelf_version_t *shelf_version;
  svn_wc_notify_func2_t notify_func;
  void *notify_baton;
  svn_client_status_func_t shelved_func;
  void *shelved_baton;
  svn_boolean_t any_shelved;
};

/*  */
static void
shelf_save_notifier(void *baton,
                    const svn_wc_notify_t *notify,
                    apr_pool_t *pool)
{
  struct shelf_save_notifer_baton_t *nb = baton;
  const char *wc_relpath
    = svn_dirent_skip_ancestor(nb->shelf_version->shelf->wc_root_abspath,
                               notify->path);
  svn_client_status_t *cst = NULL;
#if 0
  svn_wc_status3_t *wc_status;

  svn_error_clear(status_read(&wc_status, nb->shelf_version, wc_relpath,
                              pool, pool));
  svn_error_clear(svn_client__create_status(
                    &cst, nb->shelf_version->shelf->ctx->wc_ctx,
                    notify->path, wc_status, pool, pool));
#endif
  svn_error_clear(nb->shelved_func(nb->shelved_baton, wc_relpath, cst, pool));
  nb->any_shelved = TRUE;

  nb->notify_func(nb->notify_baton, notify, pool);
}

svn_error_t *
svn_client__shelf_save_new_version3(svn_client__shelf_version_t **new_version_p,
                                   svn_client__shelf_t *shelf,
                                   const apr_array_header_t *paths,
                                   svn_depth_t depth,
                                   const apr_array_header_t *changelists,
                                   svn_client_status_func_t shelved_func,
                                   void *shelved_baton,
                                   svn_client_status_func_t not_shelved_func,
                                   void *not_shelved_baton,
                                   apr_pool_t *scratch_pool)
{
  svn_client_ctx_t *ctx = shelf->ctx;
  int next_version = shelf->max_version + 1;
  svn_client__shelf_version_t *new_shelf_version;
  struct shelf_save_notifer_baton_t nb;
  const svn_delta_editor_t *editor;
  void *edit_baton;

  SVN_ERR(shelf_version_create(&new_shelf_version,
                               shelf, next_version, scratch_pool));
  SVN_ERR(shelf_copy_base(new_shelf_version, scratch_pool));

  nb.shelf_version = new_shelf_version;
  nb.notify_func = ctx->notify_func2;
  nb.notify_baton = ctx->notify_baton2;
  nb.shelved_func = shelved_func;
  nb.shelved_baton = shelved_baton;
  nb.any_shelved = FALSE;
  SVN_ERR(svn_client__shelf_mods_editor(&editor, &edit_baton,
                                        new_shelf_version,
                                        NULL, NULL, /*notification*/
                                        ctx, scratch_pool));
  SVN_ERR(svn_client__wc_replay(shelf->wc_root_abspath,
                                paths, depth, changelists,
                                editor, edit_baton,
                                shelf_save_notifier, &nb,
                                ctx, scratch_pool));

  if (nb.any_shelved)
    {
      shelf->max_version = next_version;
      SVN_ERR(shelf_write_current(shelf, scratch_pool));

      if (new_version_p)
        SVN_ERR(svn_client__shelf_version_open(new_version_p, shelf, next_version,
                                               scratch_pool, scratch_pool));
    }
  else
    {
      if (new_version_p)
        *new_version_p = NULL;
    }
  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf_get_log_message(char **log_message,
                                 svn_client__shelf_t *shelf,
                                 apr_pool_t *result_pool)
{
  svn_string_t *propval = svn_hash_gets(shelf->revprops, SVN_PROP_REVISION_LOG);

  if (propval)
    *log_message = apr_pstrdup(result_pool, propval->data);
  else
    *log_message = NULL;
  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf_set_log_message(svn_client__shelf_t *shelf,
                                 const char *message,
                                 apr_pool_t *scratch_pool)
{
  svn_string_t *propval
    = message ? svn_string_create(message, shelf->pool) : NULL;

  SVN_ERR(svn_client__shelf_revprop_set(shelf, SVN_PROP_REVISION_LOG, propval,
                                       scratch_pool));
  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf_list(apr_hash_t **shelf_infos,
                      const char *local_abspath,
                      svn_client_ctx_t *ctx,
                      apr_pool_t *result_pool,
                      apr_pool_t *scratch_pool)
{
  const char *wc_root_abspath;
  char *shelves_dir;
  apr_hash_t *dirents;
  apr_hash_index_t *hi;

  SVN_ERR(svn_wc__get_wcroot(&wc_root_abspath, ctx->wc_ctx, local_abspath,
                             scratch_pool, scratch_pool));
  SVN_ERR(get_shelves_dir(&shelves_dir, ctx->wc_ctx, local_abspath,
                          scratch_pool, scratch_pool));
  SVN_ERR(svn_io_get_dirents3(&dirents, shelves_dir, FALSE /*only_check_type*/,
                              result_pool, scratch_pool));

  *shelf_infos = apr_hash_make(result_pool);

  /* Remove non-shelves */
  for (hi = apr_hash_first(scratch_pool, dirents); hi; hi = apr_hash_next(hi))
    {
      const char *filename = apr_hash_this_key(hi);
      svn_io_dirent2_t *dirent = apr_hash_this_val(hi);
      char *name = NULL;

      svn_error_clear(shelf_name_from_filename(&name, filename, result_pool));
      if (name && dirent->kind == svn_node_file)
        {
          svn_client__shelf_info_t *info
            = apr_palloc(result_pool, sizeof(*info));

          info->mtime = dirent->mtime;
          svn_hash_sets(*shelf_infos, name, info);
        }
    }

  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf_version_open(svn_client__shelf_version_t **shelf_version_p,
                              svn_client__shelf_t *shelf,
                              int version_number,
                              apr_pool_t *result_pool,
                              apr_pool_t *scratch_pool)
{
  svn_client__shelf_version_t *shelf_version;
  const svn_io_dirent2_t *dirent;

  SVN_ERR(shelf_version_create(&shelf_version,
                               shelf, version_number, result_pool));
  SVN_ERR(svn_io_stat_dirent2(&dirent,
                              shelf_version->files_dir_abspath,
                              FALSE /*verify_truename*/,
                              TRUE /*ignore_enoent*/,
                              result_pool, scratch_pool));
  if (dirent->kind == svn_node_none)
    {
      return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
                               _("Shelf '%s' version %d not found"),
                               shelf->name, version_number);
    }
  shelf_version->mtime = dirent->mtime;
  *shelf_version_p = shelf_version;
  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf_get_newest_version(svn_client__shelf_version_t **shelf_version_p,
                                    svn_client__shelf_t *shelf,
                                    apr_pool_t *result_pool,
                                    apr_pool_t *scratch_pool)
{
  if (shelf->max_version == 0)
    {
      *shelf_version_p = NULL;
      return SVN_NO_ERROR;
    }

  SVN_ERR(svn_client__shelf_version_open(shelf_version_p,
                                        shelf, shelf->max_version,
                                        result_pool, scratch_pool));
  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__shelf_get_all_versions(apr_array_header_t **versions_p,
                                  svn_client__shelf_t *shelf,
                                  apr_pool_t *result_pool,
                                  apr_pool_t *scratch_pool)
{
  int i;

  *versions_p = apr_array_make(result_pool, shelf->max_version - 1,
                               sizeof(svn_client__shelf_version_t *));

  for (i = 1; i <= shelf->max_version; i++)
    {
      svn_client__shelf_version_t *shelf_version;

      SVN_ERR(svn_client__shelf_version_open(&shelf_version,
                                            shelf, i,
                                            result_pool, scratch_pool));
      APR_ARRAY_PUSH(*versions_p, svn_client__shelf_version_t *) = shelf_version;
    }
  return SVN_NO_ERROR;
}