/*
 * copy.c:  copy/move wrappers around wc 'copy' functionality.
 *
 * ====================================================================
 * Copyright (c) 2000-2002 CollabNet.  All rights reserved.
 *
 * This software is licensed as described in the file COPYING, which
 * you should have received as part of this distribution.  The terms
 * are also available at http://subversion.tigris.org/license-1.html.
 * If newer versions of this license are posted there, you may use a
 * newer version instead, at your option.
 *
 * This software consists of voluntary contributions made by many
 * individuals.  For exact contribution history, see the revision
 * history and logs, available at http://subversion.tigris.org/.
 * ====================================================================
 */

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


/*** Includes. ***/

#include <string.h>
#include <assert.h>
#include "svn_wc.h"
#include "svn_client.h"
#include "svn_string.h"
#include "svn_pools.h"
#include "svn_error.h"
#include "svn_path.h"
#include "client.h"


/*** Code. ***/

/*
 * if (not exist src_path)
 *   return ERR_BAD_SRC error
 *
 * if (exist dst_path)
 *   {
 *     if (dst_path is directory)
 *       copy src_path into dst_path as basename (src_path)
 *     else
 *       return ERR_OBSTRUCTION error
 *   }
 * else
 *   copy src_path into parent_of_dst_path as basename (dst_path)
 *
 * if (this is a move)
 *   delete src_path
 */


/* Copy SRC_PATH into DST_PATH as DST_BASENAME, deleting SRC_PATH
   afterwards if IS_MOVE is TRUE.  Use POOL for all necessary
   allocations. */
static svn_error_t *
wc_to_wc_copy (svn_stringbuf_t *src_path,
               svn_stringbuf_t *dst_path,
               svn_boolean_t is_move,
               svn_wc_notify_func_t notify_func,
               void *notify_baton,
               apr_pool_t *pool)
{
  svn_node_kind_t src_kind, dst_kind;
  svn_stringbuf_t *unused, *parent = dst_path, *basename;

  /* Verify that SRC_PATH exists. */
  SVN_ERR (svn_io_check_path (src_path->data, &src_kind, pool));
  if (src_kind == svn_node_none)
    return svn_error_createf (SVN_ERR_UNKNOWN_NODE_KIND, 0, NULL, pool,
                              "path `%s' does not exist.", src_path->data);

  /* If DST_PATH does not exist, then its basename will become a new
     file or dir added to its parent (possibly an implicit '.').  If
     DST_PATH is a dir, then SRC_PATH's basename will become a new
     file or dir within DST_PATH itself.  Else if it's a file, just
     error out. */
  SVN_ERR (svn_io_check_path (dst_path->data, &dst_kind, pool));
  if (dst_kind == svn_node_none)
    svn_path_split (dst_path, &parent, &basename, pool);
  else if (dst_kind == svn_node_dir)
    svn_path_split (src_path, &unused, &basename, pool);
  else
    return svn_error_createf (SVN_ERR_ENTRY_EXISTS, 0, NULL, pool,
                              "file `%s' already exists.", dst_path->data);

  /* Perform the copy and (optionally) delete. */
  SVN_ERR (svn_wc_copy (src_path, parent, basename,
                        notify_func, notify_baton, pool));
  if (is_move)
    {
      apr_status_t apr_err;

      SVN_ERR (svn_wc_delete (src_path,
                              notify_func, notify_baton, pool));

      if (src_kind == svn_node_file)
        {
          apr_err = apr_file_remove (src_path->data, pool);
          if (apr_err)
            return svn_error_createf (apr_err, 0, NULL, pool, 
                                      "error deleting %s", src_path->data);
        }
      /* else do nothing;  we don't want to blow away a directory,
         because 'svn revert' wouldn't be able to undo such a thing. */      
    }

  return SVN_NO_ERROR;
}


static svn_error_t *
repos_to_repos_copy (svn_client_commit_info_t **commit_info,
                     svn_stringbuf_t *src_url, 
                     const svn_client_revision_t *src_revision, 
                     svn_stringbuf_t *dst_url, 
                     svn_client_auth_baton_t *auth_baton,
                     svn_stringbuf_t *message,
                     svn_boolean_t is_move,
                     apr_pool_t *pool)
{
  svn_stringbuf_t *top_url, *src_rel, *dst_rel, *basename, *unused;
  apr_array_header_t *src_pieces = NULL, *dst_pieces = NULL;
  svn_revnum_t youngest;
  void *ra_baton, *sess;
  svn_ra_plugin_t *ra_lib;
  svn_node_kind_t src_kind, dst_kind;
  const svn_delta_editor_t *editor;
  void *edit_baton;
  void *root_baton, *baton;
  void **batons;
  int i = 0;
  svn_revnum_t committed_rev = SVN_INVALID_REVNUM;
  const char *committed_date = NULL;
  const char *committed_author = NULL;
  svn_revnum_t src_revnum;
  svn_stringbuf_t *piece, *telepath;

  /* ### TODO:  Currently, this function will violate the depth-first
     rule of editors when doing a move of something up into one of its
     grandparent directories, such as:

        svn mv http://server/repos/dir1/dir2/file http://server/repos/dir1

     While it seems to work just fine, we might want to evaluate this
     from a purely "correctness" standpoint.
  */

  /* We have to open our session to the longest path common to both
     SRC_URL and DST_URL in the repository so we can do existence
     checks on both paths, and so we can operate on both paths in the
     case of a move. */
  top_url = svn_path_get_longest_ancestor (src_url, dst_url, pool);

  /* Get the portions of the SRC and DST URLs that are relative to
     TOP_URL. */
  src_rel = svn_path_is_child (top_url, src_url, pool);
  if (src_rel)
    {
      src_pieces = svn_path_decompose (src_rel, pool);
      if ((! src_pieces) || (! src_pieces->nelts))
        return svn_error_createf 
          (SVN_ERR_WC_PATH_NOT_FOUND, 0, NULL, pool,
           "error decomposing relative path `%s'", src_rel->data);
    }

  dst_rel = svn_path_is_child (top_url, dst_url, pool);
  if (dst_rel)
    {
      dst_pieces = svn_path_decompose (dst_rel, pool);
      if ((! dst_pieces) || (! dst_pieces->nelts))
        return svn_error_createf 
          (SVN_ERR_WC_PATH_NOT_FOUND, 0, NULL, pool,
           "error decomposing relative path `%s'", dst_rel->data);
    }

  /* Allocate room for the root baton, the pieces of the
     source's or destination's path, and the destination itself. */
  {
    int num, num2;
    num = src_pieces ? src_pieces->nelts : 0;
    if (((num2 = (dst_pieces ? dst_pieces->nelts : 0))) > num)
      num = num2;

    batons = apr_palloc (pool, sizeof (void *) * (num + 2));
  }

  /* Get the RA vtable that matches URL. */
  SVN_ERR (svn_ra_init_ra_libs (&ra_baton, pool));
  SVN_ERR (svn_ra_get_ra_library (&ra_lib, ra_baton, top_url->data, pool));

  /* Open an RA session for the URL. Note that we don't have a local
     directory, nor a place to put temp files or store the auth data. */
  SVN_ERR (svn_client__open_ra_session (&sess, ra_lib, top_url, NULL,
                                        NULL, FALSE, FALSE, TRUE, 
                                        auth_baton, pool));

  /* Pass null for the path, to ensure error if trying to get a
     revision based on the working copy. */
  SVN_ERR (svn_client__get_revision_number
           (&src_revnum, ra_lib, sess, src_revision, NULL, pool));

  SVN_ERR (ra_lib->get_latest_revnum (sess, &youngest));

  /* Use YOUNGEST for copyfrom args if not provided. */
  if (! SVN_IS_VALID_REVNUM (src_revnum))
    src_revnum = youngest;
  
  /* Verify that SRC_URL exists in the repository. */
  SVN_ERR (ra_lib->check_path (&src_kind, sess,
                               src_rel ? src_rel->data : NULL, src_revnum));
  if (src_kind == svn_node_none)
    return svn_error_createf 
      (SVN_ERR_FS_NOT_FOUND, 0, NULL, pool,
       "path `%s' does not exist in revision `%ld'",
       src_url->data, src_revnum);

  /* Figure out the basename that will result from this operation. */
  SVN_ERR (ra_lib->check_path (&dst_kind, sess, 
                               dst_rel ? dst_rel->data : NULL, youngest));
  if (dst_kind == svn_node_none)
    {
      svn_path_split (dst_url, &unused, &basename, pool);
      dst_pieces->nelts--; /* hack - where's apr_array_pop()? */
    }
  else if (dst_kind == svn_node_dir)
    svn_path_split (src_url, &unused, &basename, pool);
  else
    return svn_error_createf (SVN_ERR_FS_ALREADY_EXISTS, 0, NULL, pool,
                              "file `%s' already exists.", dst_url->data);

  /* Fetch RA commit editor. */
  SVN_ERR (ra_lib->get_commit_editor (sess, &editor, &edit_baton,
                                      &committed_rev,
                                      &committed_date,
                                      &committed_author,
                                      message));

  /* Initialize telepath to an empty string that's as big as our
     biggest relative target (we don't want to have to realloc this
     thing. */
  if (src_rel->len > dst_rel->len)
    telepath = svn_stringbuf_dup (src_rel, pool);
  else
    telepath = svn_stringbuf_dup (dst_rel, pool);
  svn_stringbuf_setempty (telepath);

  /* Drive that editor, baby! */
  SVN_ERR (editor->open_root (edit_baton, youngest, pool, &root_baton));

  /* Stuff the root baton here for convenience. */
  batons[i] = root_baton;

  /* Open directories down to the place where we need to make our
     copy. */
  if (dst_pieces && dst_pieces->nelts)
    {
      /* open_directory() all the way down to DST's parent. */
      while (i < dst_pieces->nelts)
        {
          piece = (((svn_stringbuf_t **)(dst_pieces)->elts)[i]);
          svn_path_add_component (telepath, piece);
          SVN_ERR (editor->open_directory (telepath->data, batons[i], 
                                           youngest, pool, &(batons[i + 1])));
          i++;
        }
    }
  /* Add our file/dir with copyfrom history. */
  svn_path_add_component (telepath, basename);
  if (src_kind == svn_node_dir)
    {
      SVN_ERR (editor->add_directory (telepath->data, batons[i], src_url->data,
                                      src_revnum, pool, &baton));
      SVN_ERR (editor->close_directory (baton));
    }
  else
    {
      SVN_ERR (editor->add_file (telepath->data, batons[i], src_url->data,
                                 src_revnum, pool, &baton));
      SVN_ERR (editor->close_file (baton));
    }

  /* Now, close up all those batons (except the root
     baton). */
  while (i)
    {
      SVN_ERR (editor->close_directory (batons[i]));
      batons[i--] = NULL;
    }

  /* If this was a move, we need to remove the SRC_URL. */
  svn_stringbuf_setempty (telepath);
  if (is_move)
    {
      /* If SRC_PIECES is NULL, we're trying to move a directory into
         itself (or one of its chidren...we should have caught that by
         now). */
      assert (src_pieces != NULL);

      /* open_directory() all the way down to SRC's parent. */
      while (i < (src_pieces->nelts - 1))
        {
          piece = (((svn_stringbuf_t **)(src_pieces)->elts)[i]);
          svn_path_add_component (telepath, piece);
          SVN_ERR (editor->open_directory (telepath->data, batons[i], 
                                           youngest, pool, &(batons[i + 1])));
          i++;
        }
          
      /* Delete SRC. */
      piece = (((svn_stringbuf_t **)(src_pieces)->elts)[i]);
      svn_path_add_component (telepath, piece);
      SVN_ERR (editor->delete_entry (telepath->data, SVN_INVALID_REVNUM, 
                                     batons[i], pool));

      /* Now, close up all those batons (except the root
         baton). */
      while (i)
        {
          SVN_ERR (editor->close_directory (batons[i--]));
        }
    }

  /* Turn off the lights, close up the shop, and go home. */
  SVN_ERR (editor->close_directory (batons[0]));
  SVN_ERR (editor->close_edit (edit_baton));

  /* Fill in the commit_info structure. */
  *commit_info = svn_client__make_commit_info (committed_rev,
                                               committed_author,
                                               committed_date,
                                               pool);

  SVN_ERR (ra_lib->close (sess));

  return SVN_NO_ERROR;
}


static svn_error_t *
unlock_dirs (apr_hash_t *locked_dirs,
             apr_pool_t *pool)
{
  apr_hash_index_t *hi;

  /* Split if there's nothing to be done. */
  if (! locked_dirs)
    return SVN_NO_ERROR;

  /* Clean up any locks. */
  for (hi = apr_hash_first (pool, locked_dirs); hi; hi = apr_hash_next (hi))
    {
      const void *key;
      apr_ssize_t keylen;
      void *val;
      svn_stringbuf_t *strkey;

      apr_hash_this (hi, &key, &keylen, &val);
      strkey = svn_stringbuf_ncreate ((const char *)key, keylen, pool);
      SVN_ERR (svn_wc_unlock (strkey, pool));
    }

  return SVN_NO_ERROR;
}  


static svn_error_t *
remove_tmpfiles (apr_hash_t *tempfiles,
                 apr_pool_t *pool)
{
  apr_hash_index_t *hi;

  /* Split if there's nothing to be done. */
  if (! tempfiles)
    return SVN_NO_ERROR;

  /* Clean up any tempfiles. */
  for (hi = apr_hash_first (pool, tempfiles); hi; hi = apr_hash_next (hi))
    {
      const void *key;
      apr_ssize_t keylen;
      void *val;
      svn_node_kind_t kind;

      apr_hash_this (hi, &key, &keylen, &val);
      SVN_ERR (svn_io_check_path ((const char *)key, &kind, pool));
      if (kind == svn_node_file)
        SVN_ERR (svn_io_remove_file ((const char *)key, pool));
    }

  return SVN_NO_ERROR;
}


static svn_error_t *
reconcile_errors (svn_error_t *commit_err,
                  svn_error_t *unlock_err,
                  svn_error_t *cleanup_err,
                  apr_pool_t *pool)
{
  svn_error_t *err;

  /* Early release (for good behavior). */
  if (! (commit_err || unlock_err || cleanup_err))
    return SVN_NO_ERROR;

  /* If there was a commit error, start off our error chain with
     that. */
  if (commit_err)
    {
      commit_err = svn_error_quick_wrap 
        (commit_err, "Commit failed (details follow):");
      err = commit_err;
    }

  /* Else, create a new "general" error that will head off the errors
     that follow. */
  else
    err = svn_error_create (SVN_ERR_GENERAL, 0, NULL, pool,
                            "Commit succeeded, but other errors follow:");

  /* If there was an unlock error... */
  if (unlock_err)
    {
      /* Wrap the error with some headers. */
      unlock_err = svn_error_quick_wrap 
        (unlock_err, "Error unlocking locked dirs (details follow):");

      /* Append this error to the chain. */
      svn_error_compose (err, unlock_err);
    }

  /* If there was a cleanup error... */
  if (cleanup_err)
    {
      /* Wrap the error with some headers. */
      cleanup_err = svn_error_quick_wrap 
        (cleanup_err, "Error in post-commit clean-up (details follow):");

      /* Append this error to the chain. */
      svn_error_compose (err, cleanup_err);
    }

  return err;
}


static svn_error_t *
wc_to_repos_copy (svn_client_commit_info_t **commit_info,
                  svn_stringbuf_t *src_path, 
                  svn_stringbuf_t *dst_url, 
                  svn_client_auth_baton_t *auth_baton,
                  svn_stringbuf_t *message,
                  const svn_delta_editor_t *before_editor,
                  void *before_edit_baton,
                  const svn_delta_editor_t *after_editor,
                  void *after_edit_baton,
                  apr_pool_t *pool)
{
  svn_stringbuf_t *anchor, *target, *parent, *basename;
  void *ra_baton, *session;
  svn_ra_plugin_t *ra_lib;
  const svn_delta_editor_t *editor;
  void *edit_baton;
  svn_node_kind_t src_kind, dst_kind;
  svn_revnum_t committed_rev = SVN_INVALID_REVNUM;
  const char *committed_date = NULL;
  const char *committed_author = NULL;
  apr_hash_t *committables, *locked_dirs, *tempfiles = NULL;
  apr_array_header_t *commit_items;
  svn_error_t *cmt_err = NULL, *unlock_err = NULL, *cleanup_err = NULL;
  svn_boolean_t commit_in_progress = FALSE;
  svn_stringbuf_t *base_path, *base_url;

  /* Check the SRC_PATH. */
  SVN_ERR (svn_io_check_path (src_path->data, &src_kind, pool));

  /* Split the SRC_PATH into a parent and basename. */
  svn_path_split (src_path, &parent, &basename, pool);
  if (svn_path_is_empty (parent))
    parent = svn_stringbuf_create (".", pool);

  /* Split the DST_URL into an anchor and target. */
  svn_path_split (dst_url, &anchor, &target, pool);

  /* Get the RA vtable that matches URL. */
  SVN_ERR (svn_ra_init_ra_libs (&ra_baton, pool));
  SVN_ERR (svn_ra_get_ra_library (&ra_lib, ra_baton, anchor->data, pool));

  /* Open an RA session for the anchor URL. */
  SVN_ERR (svn_client__open_ra_session (&session, ra_lib, anchor, parent,
                                        NULL, TRUE, TRUE, TRUE, 
                                        auth_baton, pool));

  /* Figure out the basename that will result from this operation. */
  SVN_ERR (ra_lib->check_path (&dst_kind, session, target->data,
                               SVN_INVALID_REVNUM));
  
  /* Close the RA session.  We'll re-open it after we've figured out
     the right URL to open. */
  SVN_ERR (ra_lib->close (session));
  session = NULL;

  /* BASE_URL defaults to DST_URL. */
  base_url = svn_stringbuf_dup (dst_url, pool);
  if (dst_kind == svn_node_none)
    {
      /* DST_URL doesn't exist under it's parent URL, so the URL we
         will be creating is DST_URL. */
    }
  else if (dst_kind == svn_node_dir)
    {
      /* DST_URL is an existing directory URL.  The URL we will be
         creating, then, is DST_URL+BASENAME. */
      svn_path_add_component (base_url, basename);
    }
  else
    {
      /* DST_URL is an existing file, which can't be overwritten or
         used as a container, so error out. */
      return svn_error_createf (SVN_ERR_FS_ALREADY_EXISTS, 0, NULL, pool,
                                "file `%s' already exists.", dst_url->data);
    }

  /* Get the absolute path of the WC path. */
  SVN_ERR (svn_path_get_absolute (&base_path, src_path, pool));

  /* Crawl the working copy for commit items. */
  if ((cmt_err = svn_client__get_copy_committables (&committables, 
                                                    &locked_dirs,
                                                    base_url,
                                                    base_path,
                                                    pool)))
    goto cleanup;

  /* ### todo: There should be only one hash entry, which currently
     has a hacked name until we have the entries files storing
     canonical repository URLs.  Then, the hacked name can go away and
     be replaced with a entry->repos (or whereever the entry's
     canonical repos URL is stored). */
  if (! ((commit_items = apr_hash_get (committables, 
                                       SVN_CLIENT__SINGLE_REPOS_NAME, 
                                       APR_HASH_KEY_STRING))))
    goto cleanup;

  /* Sort and condense our COMMIT_ITEMS. */
  if ((cmt_err = svn_client__condense_commit_items (&base_url, 
                                                    commit_items, 
                                                    pool)))
    goto cleanup;

  /* Open an RA session to BASE_URL. */
  if ((cmt_err = svn_client__open_ra_session (&session, ra_lib, base_url, NULL,
                                              commit_items, TRUE, TRUE, TRUE,
                                              auth_baton, pool)))
    goto cleanup;

  /* Fetch RA commit editor, giving it svn_wc_process_committed(). */
  if ((cmt_err = ra_lib->get_commit_editor (session, &editor, &edit_baton, 
                                            &committed_rev, &committed_date, 
                                            &committed_author, message)))
    goto cleanup;

  /* Make a note that we have a commit-in-progress. */
  commit_in_progress = TRUE;

  /* Wrap the resulting editor with BEFORE and AFTER editors. */
  svn_delta_wrap_editor (&editor, &edit_baton,
                         before_editor, before_edit_baton,
                         editor, edit_baton, 
                         after_editor, after_edit_baton, pool);

  /* Perform the commit. */
  cmt_err = svn_client__do_commit (base_url, commit_items, editor, edit_baton, 
                                   NULL, NULL, NULL,
                                   &tempfiles, pool);

  commit_in_progress = FALSE;

  /* Sleep for one second to ensure timestamp integrity. */
  apr_sleep (APR_USEC_PER_SEC * 1);

 cleanup:
  /* Abort the commit if it is still in progress. */
  if (commit_in_progress)
    editor->abort_edit (edit_baton); /* ignore return value */

  /* We were committing to RA, so close the session. */
  if (session)
    ra_lib->close (session);

  /* Unlock any remaining locked dirs. */
  if (locked_dirs)
    unlock_err = unlock_dirs (locked_dirs, pool);

  /* Remove any outstanding temporary text-base files. */
  if (tempfiles)
    cleanup_err = remove_tmpfiles (tempfiles, pool);

  /* Fill in the commit_info structure */
  *commit_info = svn_client__make_commit_info (committed_rev, 
                                               committed_author, 
                                               committed_date, pool);

  return reconcile_errors (cmt_err, unlock_err, cleanup_err, pool);
}


static svn_error_t *
repos_to_wc_copy (svn_stringbuf_t *src_url,
                  const svn_client_revision_t *src_revision,
                  svn_stringbuf_t *dst_path, 
                  svn_client_auth_baton_t *auth_baton,
                  const svn_delta_editor_t *before_editor,
                  void *before_edit_baton,
                  const svn_delta_editor_t *after_editor,
                  void *after_edit_baton,
                  svn_wc_notify_func_t notify_func,
                  void *notify_baton,
                  apr_pool_t *pool)
{
  void *ra_baton, *sess;
  svn_ra_plugin_t *ra_lib;
  svn_node_kind_t src_kind, dst_kind;
  svn_revnum_t src_revnum;

  /* Get the RA vtable that matches URL. */
  SVN_ERR (svn_ra_init_ra_libs (&ra_baton, pool));
  SVN_ERR (svn_ra_get_ra_library (&ra_lib, ra_baton, src_url->data, pool));

  /* Open a repository session to the given URL. We do not (yet) have a
     working copy, so we don't have a corresponding path and tempfiles
     cannot go into the admin area. We do want to store the resulting
     auth data, though, once the WC is built. */
  SVN_ERR (svn_client__open_ra_session (&sess, ra_lib, src_url, NULL,
                                        NULL, TRUE, FALSE, TRUE, 
                                        auth_baton, pool));
      
  /* Pass null for the path, to ensure error if trying to get a
     revision based on the working copy. */
  SVN_ERR (svn_client__get_revision_number
           (&src_revnum, ra_lib, sess, src_revision, NULL, pool));

  /* Verify that SRC_URL exists in the repository. */
  SVN_ERR (ra_lib->check_path (&src_kind, sess, "", src_revnum));
  if (src_kind == svn_node_none)
    {
      if (SVN_IS_VALID_REVNUM (src_revnum))
        return svn_error_createf
          (SVN_ERR_FS_NOT_FOUND, 0, NULL, pool,
           "path `%s' not found in revision `%ld'", src_url->data, src_revnum);
      else
        return svn_error_createf
          (SVN_ERR_FS_NOT_FOUND, 0, NULL, pool,
           "path `%s' not found in head revision", src_url->data);
    }

  /* There are two interfering sets of cases to watch out for here:
   *
   * First set:
   *
   *   1) If DST_PATH does not exist, then great.  We're going to
   *      create a new entry in its parent.
   *   2) If it does exist, then it must be a directory and we're
   *      copying to a new entry inside that dir (the entry's name is
   *      the basename of SRC_URL).
   *
   * But while that's all going on, we must also remember:
   *
   *   A) If SRC_URL is a directory in the repository, we can check
   *      it out directly, no problem.
   *   B) If SRC_URL is a file, we have to manually get the editor
   *      started, since there won't be a root to open.
   *
   * I'm going to ignore B for the moment, and implement cases 1 and
   * 2 under A.
   */

  /* First, figure out about dst. */
  SVN_ERR (svn_io_check_path (dst_path->data, &dst_kind, pool));
  if (dst_kind == svn_node_dir)
    {
      svn_stringbuf_t *unused, *basename;
      svn_path_split (src_url, &unused, &basename, pool);

      /* We shouldn't affect the caller's dst_path, so dup first and
         then extend. */
      dst_path = svn_stringbuf_dup (dst_path, pool);
      svn_path_add_component (dst_path, basename);
    }
  else if (dst_kind != svn_node_none)  /* must be a file */
    return svn_error_createf (SVN_ERR_ENTRY_EXISTS, 0, NULL, pool,
                              "file `%s' already exists.", dst_path->data);

  /* Now that dst_path has possibly been reset, check that there's
     nothing in the way of the upcoming checkout. */
  SVN_ERR (svn_io_check_path (dst_path->data, &dst_kind, pool));
  if (dst_kind != svn_node_none)
    return svn_error_createf (SVN_ERR_WC_OBSTRUCTED_UPDATE, 0, NULL, pool,
                              "`%s' is in the way", dst_path->data);

  if (src_kind == svn_node_dir)
    {    
      const svn_delta_editor_t *editor;
      void *edit_baton;
      const svn_delta_editor_t *wrap_editor;
      void *wrap_edit_baton;
      const svn_delta_edit_fns_t *wrapped_old_editor;
      void *wrapped_old_edit_baton;

      /* Get a checkout editor and wrap it. */
      SVN_ERR (svn_wc_get_checkout_editor (dst_path,
                                           src_url,
                                           src_revnum,
                                           1,
                                           &editor,
                                           &edit_baton,
                                           pool));
      
      svn_delta_wrap_editor (&wrap_editor, &wrap_edit_baton,
                             before_editor, before_edit_baton,
                             editor, edit_baton,
                             after_editor, after_edit_baton, pool);

      /* ### todo:  This is a TEMPORARY wrapper around our editor so we
         can use it with an old driver. */
      svn_delta_compat_wrap (&wrapped_old_editor, &wrapped_old_edit_baton, 
                             wrap_editor, wrap_edit_baton, pool);

      
      /* Check out the new tree.  The parent dir will get no entry, so
         it will be as if the new tree isn't really there yet. */
      SVN_ERR (ra_lib->do_checkout (sess, src_revnum, 1, 
                                    wrapped_old_editor,
                                    wrapped_old_edit_baton));

      if (! SVN_IS_VALID_REVNUM(src_revnum))
        {
          /* If we just checked out from the "head" revision, that's fine,
             but we don't want to pass a '-1' as a copyfrom_rev to
             svn_wc_add().  That function will dump it right into the
             entry, and when we try to commit later on, the
             'add-dir-with-history' step will be -very- unhappy; it only
             accepts specific revisions.
             
             On the other hand, we *could* say that -1 is a legitimate
             copyfrom_rev, but I think that's bogus.  Somebody made a copy
             from a particular revision;  if they wait a long time to
             commit, it would be terrible if the copied happened from a
             newer revision!! */
          
          /* We just did a checkout; whatever revision we just got, that
             should be the copyfrom_revision when we commit later. */
          svn_wc_entry_t *d_entry;
          SVN_ERR (svn_wc_entry (&d_entry, dst_path, pool));
          src_revnum = d_entry->revision;
        }

    } /* end directory case */

  else if (src_kind == svn_node_file)
    {
      apr_status_t status;
      svn_stream_t *fstream;
      apr_file_t *fp;
      svn_revnum_t fetched_rev = 0;
      apr_hash_t *props;
      apr_hash_index_t *hi;
      
      /* Open DST_PATH for writing. */
      status = apr_file_open (&fp, dst_path->data, (APR_CREATE | APR_WRITE),
                              APR_OS_DEFAULT, pool);
      if (status)
        return svn_error_createf (status, 0, NULL, pool,
                                  "failed to open file '%s' for writing.",
                                  dst_path->data);

      /* Create a generic stream that operates on this file.  */
      fstream = svn_stream_from_aprfile (fp, pool);
      
      /* Have the RA layer 'push' data at this stream.  We pass a
         relative path of "", because we opened SRC_URL, which is
         already the full URL to the file. */         
      SVN_ERR (ra_lib->get_file (sess, "", src_revnum, fstream, 
                                 &fetched_rev, &props));

      for (hi = apr_hash_first(pool, props); hi; hi = apr_hash_next(hi)) 
        {
          const void *key;
          void *val;
          int len;
          enum svn_prop_kind kind;

          apr_hash_this (hi, &key, NULL, &val);

          /* We only want to set 'normal' props.  For now, we're
             ignoring any wc props (they're not needed when we commit
             an addition), and we're ignoring entry props (they're
             written to the entries file as part of the post-commit
             processing).  */
          kind = svn_property_kind (&len, key);
          if (kind == svn_prop_regular_kind)
            SVN_ERR (svn_wc_prop_set (key, val, dst_path->data, pool));
        }

      /* Close the file. */
      status = apr_file_close (fp);
      if (status)
        return svn_error_createf (status, 0, NULL, pool,
                                  "failed to close file '%s'.",
                                  dst_path->data);   
     
      /* Also, if SRC_REVNUM is invalid ('head'), then FETCHED_REV is now
         equal to the revision that was actually retrieved.  This is
         the value we want to use as 'copyfrom_rev' in the call to
         svn_wc_add() below. */
      if (! SVN_IS_VALID_REVNUM (src_revnum))
        src_revnum = fetched_rev;
    }

  /* Free the RA session. */
  SVN_ERR (ra_lib->close (sess));
      
  /* Schedule the new item for addition-with-history.

     If the new item is a directory, the URLs will be recursively
     rewritten, wcprops removed, and everything marked as 'copied'.
     See comment in svn_wc_add()'s doc about whether svn_wc_add is the
     appropriate place for this. */
  SVN_ERR (svn_wc_add (dst_path, src_url, src_revnum,
                       notify_func, notify_baton, pool));


  return SVN_NO_ERROR;
}


static svn_error_t *
setup_copy (svn_client_commit_info_t **commit_info,
            svn_stringbuf_t *src_path,
            const svn_client_revision_t *src_revision,
            svn_stringbuf_t *dst_path,
            svn_client_auth_baton_t *auth_baton,
            svn_client_get_commit_log_t log_msg_func,
            void *log_msg_baton,
            const svn_delta_editor_t *before_editor,
            void *before_edit_baton,
            const svn_delta_editor_t *after_editor,
            void *after_edit_baton,
            svn_boolean_t is_move,
            svn_wc_notify_func_t notify_func,
            void *notify_baton,
            apr_pool_t *pool)
{
  svn_boolean_t src_is_url, dst_is_url;
  svn_string_t path_str;
  svn_stringbuf_t *message;

  /* Are either of our paths URLs? */
  path_str.data = src_path->data;
  path_str.len = src_path->len;
  src_is_url = svn_path_is_url (&path_str);
  path_str.data = dst_path->data;
  path_str.len = dst_path->len;
  dst_is_url = svn_path_is_url (&path_str);

  if (is_move)
    {
      if (src_is_url == dst_is_url)
        {
          if (svn_path_is_child (src_path, dst_path, pool))
            return svn_error_createf
              (SVN_ERR_UNSUPPORTED_FEATURE, 0, NULL, pool,
               "cannot move path '%s' into its own child '%s'",
               src_path->data, dst_path->data);
          if (svn_stringbuf_compare (src_path, dst_path))
            return svn_error_createf
              (SVN_ERR_UNSUPPORTED_FEATURE, 0, NULL, pool,
               "cannot move path '%s' into itself",
               src_path->data);
        }
      else
        {
          /* Disallow moves between the working copy and the repository. */
          return svn_error_create 
            (SVN_ERR_UNSUPPORTED_FEATURE, 0, NULL, pool,
             "no support for repos <--> working copy moves");
        }

      /* It doesn't make sense to specify revisions in a move. */

      /* ### todo: this check could fail wrongly.  For example,
         someone could pass in an svn_client_revision_number that just
         happens to be the HEAD.  It's fair enough to punt then, IMHO,
         and just demand that the user not specify a revision at all;
         beats mucking up this function with RA calls and such. */ 
      if ((src_revision->kind != svn_client_revision_unspecified)
          || (src_revision->kind != svn_client_revision_unspecified))
        {
          return svn_error_create
            (SVN_ERR_UNSUPPORTED_FEATURE, 0, NULL, pool,
             "cannot specify revisions with move operations");
        }
    }

  /* Create a new commit item and add it to the array. */
  if (dst_is_url && log_msg_func)
    {
      svn_client_commit_item_t *item;
      apr_array_header_t *commit_items 
        = apr_array_make (pool, 1, sizeof (item));
      
      item = apr_pcalloc (pool, sizeof (*item));
      item->url = svn_stringbuf_dup (dst_path, pool);
      item->state_flags = SVN_CLIENT_COMMIT_ITEM_ADD;
      (*((svn_client_commit_item_t **) apr_array_push (commit_items))) 
        = item;
      
      SVN_ERR ((*log_msg_func) (&message, commit_items, 
                                log_msg_baton, pool));
      if (! message)
        return SVN_NO_ERROR;
    }
  else
    message = svn_stringbuf_create ("", pool);

  /* Now, call the right handler for the operation. */
  if ((! src_is_url) && (! dst_is_url))
    SVN_ERR (wc_to_wc_copy (src_path, dst_path, is_move,
                            notify_func, notify_baton,
                            pool));

  else if ((! src_is_url) && (dst_is_url))
    SVN_ERR (wc_to_repos_copy (commit_info, src_path, dst_path, 
                               auth_baton, message, 
                               before_editor, before_edit_baton,
                               after_editor, after_edit_baton,
                               pool));

  else if ((src_is_url) && (! dst_is_url))
    SVN_ERR (repos_to_wc_copy (src_path, src_revision, 
                               dst_path, auth_baton,
                               before_editor, before_edit_baton,
                               after_editor, after_edit_baton,
                               notify_func, notify_baton,
                               pool));

  else
    SVN_ERR (repos_to_repos_copy (commit_info, src_path, src_revision,
                                  dst_path, auth_baton, message, is_move,
                                  pool));

  return SVN_NO_ERROR;
}


/* Public Interfaces */

svn_error_t *
svn_client_copy (svn_client_commit_info_t **commit_info,
                 svn_stringbuf_t *src_path,
                 const svn_client_revision_t *src_revision,
                 svn_stringbuf_t *dst_path,
                 svn_client_auth_baton_t *auth_baton,
                 svn_client_get_commit_log_t log_msg_func,
                 void *log_msg_baton,
                 const svn_delta_editor_t *before_editor,
                 void *before_edit_baton,
                 const svn_delta_editor_t *after_editor,
                 void *after_edit_baton,
                 svn_wc_notify_func_t notify_func,
                 void *notify_baton,
                 apr_pool_t *pool)
{
  return setup_copy (commit_info, 
                     src_path, src_revision, dst_path, auth_baton, 
                     log_msg_func, log_msg_baton,
                     before_editor, before_edit_baton,
                     after_editor, after_edit_baton,
                     FALSE /* is_move */,
                     notify_func, notify_baton,
                     pool);
}


svn_error_t *
svn_client_move (svn_client_commit_info_t **commit_info,
                 svn_stringbuf_t *src_path,
                 const svn_client_revision_t *src_revision,
                 svn_stringbuf_t *dst_path,
                 svn_client_auth_baton_t *auth_baton,
                 svn_client_get_commit_log_t log_msg_func,
                 void *log_msg_baton,
                 svn_wc_notify_func_t notify_func,
                 void *notify_baton,
                 apr_pool_t *pool)
{
  return setup_copy (commit_info,
                     src_path, src_revision, dst_path, auth_baton,
                     log_msg_func, log_msg_baton,
                     NULL, NULL,  /* no before_editor, before_edit_baton */
                     NULL, NULL,  /* no after_editor, after_edit_baton */
                     TRUE /* is_move */,
                     notify_func, notify_baton,
                     pool);
}


/* 
 * local variables:
 * eval: (load-file "../../tools/dev/svn-dev.el")
 * end: */