/*
 * mtcc.c -- Multi Command Context implementation. This allows
 *           performing many operations without a working copy.
 *
 * ====================================================================
 *    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.
 * ====================================================================
 */

#include "svn_dirent_uri.h"
#include "svn_hash.h"
#include "svn_path.h"
#include "svn_props.h"
#include "svn_pools.h"
#include "svn_subst.h"

#include "private/svn_client_mtcc.h"


#include "svn_private_config.h"

#include "client.h"

#include <assert.h>

#define SVN_PATH_IS_EMPTY(s) ((s)[0] == '\0')

/* The kind of operation to perform in an mtcc_op_t */
typedef enum mtcc_kind_t
{
  OP_OPEN_DIR,
  OP_OPEN_FILE,
  OP_ADD_DIR,
  OP_ADD_FILE,
  OP_DELETE
} mtcc_kind_t;

typedef struct mtcc_op_t
{
  const char *name;                 /* basename of operation */
  mtcc_kind_t kind;                 /* editor operation */

  apr_array_header_t *children;     /* List of mtcc_op_t * */

  const char *src_relpath;              /* For ADD_DIR, ADD_FILE */
  svn_revnum_t src_rev;                 /* For ADD_DIR, ADD_FILE */
  svn_stream_t *src_stream;             /* For ADD_FILE, OPEN_FILE */
  svn_checksum_t *src_checksum;         /* For ADD_FILE, OPEN_FILE */
  svn_stream_t *base_stream;            /* For ADD_FILE, OPEN_FILE */
  const svn_checksum_t *base_checksum;  /* For ADD_FILE, OPEN_FILE */

  apr_array_header_t *prop_mods;        /* For all except DELETE
                                           List of svn_prop_t */

  svn_boolean_t performed_stat;         /* Verified kind with repository */
} mtcc_op_t;

/* Check if the mtcc doesn't contain any modifications yet */
#define MTCC_UNMODIFIED(mtcc)                                               \
    ((mtcc->root_op->kind == OP_OPEN_DIR                                    \
                            || mtcc->root_op->kind == OP_OPEN_FILE)         \
     && (mtcc->root_op->prop_mods == NULL                                   \
                            || !mtcc->root_op->prop_mods->nelts)            \
     && (mtcc->root_op->children == NULL                                    \
                            || !mtcc->root_op->children->nelts))

struct svn_client__mtcc_t
{
  apr_pool_t *pool;
  svn_revnum_t head_revision;
  svn_revnum_t base_revision;

  svn_ra_session_t *ra_session;
  svn_client_ctx_t *ctx;

  mtcc_op_t *root_op;
};

static mtcc_op_t *
mtcc_op_create(const char *name,
               svn_boolean_t add,
               svn_boolean_t directory,
               apr_pool_t *result_pool)
{
  mtcc_op_t *op;

  op = apr_pcalloc(result_pool, sizeof(*op));
  op->name = name ? apr_pstrdup(result_pool, name) : "";

  if (add)
    op->kind = directory ? OP_ADD_DIR : OP_ADD_FILE;
  else
    op->kind = directory ? OP_OPEN_DIR : OP_OPEN_FILE;

  if (directory)
    op->children = apr_array_make(result_pool, 4, sizeof(mtcc_op_t *));

  op->src_rev = SVN_INVALID_REVNUM;

  return op;
}

static svn_error_t *
mtcc_op_find(mtcc_op_t **op,
             svn_boolean_t *created,
             const char *relpath,
             mtcc_op_t *base_op,
             svn_boolean_t find_existing,
             svn_boolean_t find_deletes,
             svn_boolean_t create_file,
             apr_pool_t *result_pool,
             apr_pool_t *scratch_pool)
{
  const char *name;
  const char *child;
  int i;

  assert(svn_relpath_is_canonical(relpath));
  if (created)
    *created = FALSE;

  if (SVN_PATH_IS_EMPTY(relpath))
    {
      if (find_existing)
        *op = base_op;
      else
        *op = NULL;

      return SVN_NO_ERROR;
    }

  child = strchr(relpath, '/');

  if (child)
    {
      name = apr_pstrmemdup(scratch_pool, relpath, (child-relpath));
      child++; /* Skip '/' */
    }
  else
    name = relpath;

  if (!base_op->children)
    {
      if (!created)
        {
          *op = NULL;
           return SVN_NO_ERROR;
        }
      else
        return svn_error_createf(SVN_ERR_FS_NOT_DIRECTORY, NULL,
                                 _("Can't operate on '%s' because '%s' is not a "
                                   "directory"),
                                 name, base_op->name);
    }

  for (i = base_op->children->nelts-1; i >= 0 ; i--)
    {
      mtcc_op_t *cop;

      cop = APR_ARRAY_IDX(base_op->children, i, mtcc_op_t *);

      if (! strcmp(cop->name, name)
          && (find_deletes || cop->kind != OP_DELETE))
        {
          return svn_error_trace(
                        mtcc_op_find(op, created, child ? child : "", cop,
                                     find_existing, find_deletes, create_file,
                                     result_pool, scratch_pool));
        }
    }

  if (!created)
    {
      *op = NULL;
      return SVN_NO_ERROR;
    }

  {
    mtcc_op_t *cop;

    cop = mtcc_op_create(name, FALSE, child || !create_file, result_pool);

    APR_ARRAY_PUSH(base_op->children, mtcc_op_t *) = cop;

    if (!child)
      {
        *op = cop;
        *created = TRUE;
        return SVN_NO_ERROR;
      }

    return svn_error_trace(
                mtcc_op_find(op, created, child, cop, find_existing,
                             find_deletes, create_file,
                             result_pool, scratch_pool));
  }
}

/* Gets the original repository location of RELPATH, checking things
   like copies, moves, etc.  */
static svn_error_t *
get_origin(svn_boolean_t *done,
           const char **origin_relpath,
           svn_revnum_t *rev,
           mtcc_op_t *op,
           const char *relpath,
           apr_pool_t *result_pool,
           apr_pool_t *scratch_pool)
{
  const char *child;
  const char *name;
  if (SVN_PATH_IS_EMPTY(relpath))
    {
      if (op->kind == OP_ADD_DIR || op->kind == OP_ADD_FILE)
        *done = TRUE;
      *origin_relpath = op->src_relpath
                                ? apr_pstrdup(result_pool, op->src_relpath)
                                : NULL;
      *rev = op->src_rev;
      return SVN_NO_ERROR;
    }

  child = strchr(relpath, '/');
  if (child)
    {
      name = apr_pstrmemdup(scratch_pool, relpath, child-relpath);
      child++; /* Skip '/' */
    }
  else
    name = relpath;

  if (op->children && op->children->nelts)
    {
      int i;

      for (i = op->children->nelts-1; i >= 0; i--)
        {
           mtcc_op_t *cop;

           cop = APR_ARRAY_IDX(op->children, i, mtcc_op_t *);

           if (! strcmp(cop->name, name))
            {
              if (cop->kind == OP_DELETE)
                {
                  *done = TRUE;
                  return SVN_NO_ERROR;
                }

              SVN_ERR(get_origin(done, origin_relpath, rev,
                                 cop, child ? child : "",
                                 result_pool, scratch_pool));

              if (*origin_relpath || *done)
                return SVN_NO_ERROR;

              break;
            }
        }
    }

  if (op->kind == OP_ADD_DIR || op->kind == OP_ADD_FILE)
    {
      *done = TRUE;
      if (op->src_relpath)
        {
          *origin_relpath = svn_relpath_join(op->src_relpath, relpath,
                                             result_pool);
          *rev = op->src_rev;
        }
    }

  return SVN_NO_ERROR;
}

/* Obtains the original repository location for an mtcc relpath as
   *ORIGIN_RELPATH @ *REV, if it has one. If it has not and IGNORE_ENOENT
   is TRUE report *ORIGIN_RELPATH as NULL, otherwise return an error */
static svn_error_t *
mtcc_get_origin(const char **origin_relpath,
                svn_revnum_t *rev,
                const char *relpath,
                svn_boolean_t ignore_enoent,
                svn_client__mtcc_t *mtcc,
                apr_pool_t *result_pool,
                apr_pool_t *scratch_pool)
{
  svn_boolean_t done = FALSE;

  *origin_relpath = NULL;
  *rev = SVN_INVALID_REVNUM;

  SVN_ERR(get_origin(&done, origin_relpath, rev, mtcc->root_op, relpath,
                     result_pool, scratch_pool));

  if (!*origin_relpath && !done)
    {
      *origin_relpath = apr_pstrdup(result_pool, relpath);
      *rev = mtcc->base_revision;
    }
  else if (!ignore_enoent)
    {
      return svn_error_createf(SVN_ERR_FS_NOT_FOUND, NULL,
                               _("No origin found for node at '%s'"),
                               relpath);
    }

  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__mtcc_create(svn_client__mtcc_t **mtcc,
                        const char *anchor_url,
                        svn_revnum_t base_revision,
                        svn_client_ctx_t *ctx,
                        apr_pool_t *result_pool,
                        apr_pool_t *scratch_pool)
{
  apr_pool_t *mtcc_pool;

  mtcc_pool = svn_pool_create(result_pool);

  *mtcc = apr_pcalloc(mtcc_pool, sizeof(**mtcc));
  (*mtcc)->pool = mtcc_pool;

  (*mtcc)->root_op = mtcc_op_create(NULL, FALSE, TRUE, mtcc_pool);

  (*mtcc)->ctx = ctx;

  SVN_ERR(svn_client_open_ra_session2(&(*mtcc)->ra_session, anchor_url,
                                      NULL /* wri_abspath */, ctx,
                                      mtcc_pool, scratch_pool));

  SVN_ERR(svn_ra_get_latest_revnum((*mtcc)->ra_session, &(*mtcc)->head_revision,
                                   scratch_pool));

  if (SVN_IS_VALID_REVNUM(base_revision))
    (*mtcc)->base_revision = base_revision;
  else
    (*mtcc)->base_revision = (*mtcc)->head_revision;

  if ((*mtcc)->base_revision > (*mtcc)->head_revision)
    return svn_error_createf(SVN_ERR_FS_NO_SUCH_REVISION, NULL,
                             _("No such revision %ld (HEAD is %ld)"),
                             base_revision, (*mtcc)->head_revision);

  return SVN_NO_ERROR;
}

static svn_error_t *
update_copy_src(mtcc_op_t *op,
                const char *add_relpath,
                apr_pool_t *result_pool)
{
  int i;

  if (op->src_relpath)
    op->src_relpath = svn_relpath_join(add_relpath, op->src_relpath,
                                       result_pool);

  if (!op->children)
    return SVN_NO_ERROR;

  for (i = 0; i < op->children->nelts; i++)
    {
      mtcc_op_t *cop;

      cop = APR_ARRAY_IDX(op->children, i, mtcc_op_t *);

      SVN_ERR(update_copy_src(cop, add_relpath, result_pool));
    }

  return SVN_NO_ERROR;
}

static svn_error_t *
mtcc_reparent(const char *new_anchor_url,
              svn_client__mtcc_t *mtcc,
              apr_pool_t *scratch_pool)
{
  const char *session_url;
  const char *up;

  SVN_ERR(svn_ra_get_session_url(mtcc->ra_session, &session_url,
                                 scratch_pool));

  up = svn_uri_skip_ancestor(new_anchor_url, session_url, scratch_pool);

  if (! up)
    {
      return svn_error_createf(SVN_ERR_RA_ILLEGAL_URL, NULL,
                               _("'%s' is not an ancestor of  '%s'"),
                               new_anchor_url, session_url);
    }
  else if (!*up)
    {
      return SVN_NO_ERROR; /* Same url */
    }

  /* Update copy origins recursively...:( */
  SVN_ERR(update_copy_src(mtcc->root_op, up, mtcc->pool));

  SVN_ERR(svn_ra_reparent(mtcc->ra_session, new_anchor_url, scratch_pool));

  /* Create directory open operations for new ancestors */
  while (*up)
    {
      mtcc_op_t *root_op;

      mtcc->root_op->name = svn_relpath_basename(up, mtcc->pool);
      up = svn_relpath_dirname(up, scratch_pool);

      root_op = mtcc_op_create(NULL, FALSE, TRUE, mtcc->pool);

      APR_ARRAY_PUSH(root_op->children, mtcc_op_t *) = mtcc->root_op;

      mtcc->root_op = root_op;
    }

  return SVN_NO_ERROR;
}

/* Check if it is safe to create a new node at NEW_RELPATH. Return a proper
   error if it is not */
static svn_error_t *
mtcc_verify_create(svn_client__mtcc_t *mtcc,
                   const char *new_relpath,
                   apr_pool_t *scratch_pool)
{
  svn_node_kind_t kind;

  if (*new_relpath || !MTCC_UNMODIFIED(mtcc))
    {
      mtcc_op_t *op;

      SVN_ERR(mtcc_op_find(&op, NULL, new_relpath, mtcc->root_op, TRUE, FALSE,
                           FALSE, mtcc->pool, scratch_pool));

      if (op)
        return svn_error_createf(SVN_ERR_FS_ALREADY_EXISTS, NULL,
                                 _("Path '%s' already exists, or was created "
                                   "by an earlier operation"),
                                 new_relpath);

      SVN_ERR(mtcc_op_find(&op, NULL, new_relpath, mtcc->root_op, TRUE, TRUE,
                           FALSE, mtcc->pool, scratch_pool));

      if (op)
        return SVN_NO_ERROR; /* Node is explicitly deleted. We can replace */
    }

  /* mod_dav_svn used to allow overwriting existing directories. Let's hide
     that for users of this api */
  SVN_ERR(svn_client__mtcc_check_path(&kind, new_relpath, FALSE,
                                      mtcc, scratch_pool));

  if (kind != svn_node_none)
    return svn_error_createf(SVN_ERR_FS_ALREADY_EXISTS, NULL,
                             _("Path '%s' already exists"),
                             new_relpath);

  return SVN_NO_ERROR;
}


svn_error_t *
svn_client__mtcc_add_add_file(const char *relpath,
                              svn_stream_t *src_stream,
                              const svn_checksum_t *src_checksum,
                              svn_client__mtcc_t *mtcc,
                              apr_pool_t *scratch_pool)
{
  mtcc_op_t *op;
  svn_boolean_t created;
  SVN_ERR_ASSERT(svn_relpath_is_canonical(relpath) && src_stream);

  SVN_ERR(mtcc_verify_create(mtcc, relpath, scratch_pool));

  if (SVN_PATH_IS_EMPTY(relpath) && MTCC_UNMODIFIED(mtcc))
    {
      /* Turn the root operation into a file addition */
      op = mtcc->root_op;
    }
  else
    {
      SVN_ERR(mtcc_op_find(&op, &created, relpath, mtcc->root_op, FALSE, FALSE,
                           TRUE, mtcc->pool, scratch_pool));

      if (!op || !created)
        {
          return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
                                   _("Can't add file at '%s'"),
                                   relpath);
        }
    }

  op->kind = OP_ADD_FILE;
  op->src_stream = src_stream;
  op->src_checksum = src_checksum ? svn_checksum_dup(src_checksum, mtcc->pool)
                                  : NULL;

  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__mtcc_add_copy(const char *src_relpath,
                          svn_revnum_t revision,
                          const char *dst_relpath,
                          svn_client__mtcc_t *mtcc,
                          apr_pool_t *scratch_pool)
{
  mtcc_op_t *op;
  svn_boolean_t created;
  svn_node_kind_t kind;

  SVN_ERR_ASSERT(svn_relpath_is_canonical(src_relpath)
                 && svn_relpath_is_canonical(dst_relpath));

  if (! SVN_IS_VALID_REVNUM(revision))
    revision = mtcc->head_revision;
  else if (revision > mtcc->head_revision)
    {
      return svn_error_createf(SVN_ERR_FS_NO_SUCH_REVISION, NULL,
                               _("No such revision %ld"), revision);
    }

  SVN_ERR(mtcc_verify_create(mtcc, dst_relpath, scratch_pool));

  /* Subversion requires the kind of a copy */
  SVN_ERR(svn_ra_check_path(mtcc->ra_session, src_relpath, revision, &kind,
                            scratch_pool));

  if (kind != svn_node_dir && kind != svn_node_file)
    {
      return svn_error_createf(SVN_ERR_FS_NOT_FOUND, NULL,
                               _("Path '%s' not found in revision %ld"),
                               src_relpath, revision);
    }

  SVN_ERR(mtcc_op_find(&op, &created, dst_relpath, mtcc->root_op, FALSE, FALSE,
                       (kind == svn_node_file), mtcc->pool, scratch_pool));

  if (!op || !created)
    {
      return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
                               _("Can't add node at '%s'"),
                               dst_relpath);
    }

  op->kind = (kind == svn_node_file) ? OP_ADD_FILE : OP_ADD_DIR;
  op->src_relpath = apr_pstrdup(mtcc->pool, src_relpath);
  op->src_rev = revision;

  return SVN_NO_ERROR;
}

/* Check if this operation contains at least one change that is not a
   plain delete */
static svn_boolean_t
mtcc_op_contains_non_delete(const mtcc_op_t *op)
{
  if (op->kind != OP_OPEN_DIR && op->kind != OP_OPEN_FILE
      && op->kind != OP_DELETE)
    {
      return TRUE;
    }

  if (op->prop_mods && op->prop_mods->nelts)
    return TRUE;

  if (op->src_stream)
    return TRUE;

  if (op->children)
    {
      int i;

      for (i = 0; i < op->children->nelts; i++)
        {
          const mtcc_op_t *c_op = APR_ARRAY_IDX(op->children, i,
                                                const mtcc_op_t *);

          if (mtcc_op_contains_non_delete(c_op))
            return TRUE;
        }
    }
  return FALSE;
}

static svn_error_t *
mtcc_add_delete(const char *relpath,
                svn_boolean_t for_move,
                svn_client__mtcc_t *mtcc,
                apr_pool_t *scratch_pool)
{
  mtcc_op_t *op;
  svn_boolean_t created;
  svn_node_kind_t kind;

  SVN_ERR_ASSERT(svn_relpath_is_canonical(relpath));

  SVN_ERR(svn_client__mtcc_check_path(&kind, relpath, FALSE,
                                      mtcc, scratch_pool));

  if (kind == svn_node_none)
    return svn_error_createf(SVN_ERR_FS_NOT_FOUND, NULL,
                             _("Can't delete node at '%s' as it "
                                "does not exist"),
                             relpath);

  if (SVN_PATH_IS_EMPTY(relpath) && MTCC_UNMODIFIED(mtcc))
    {
      /* Turn root operation into delete */
      op = mtcc->root_op;
    }
  else
    {
      SVN_ERR(mtcc_op_find(&op, &created, relpath, mtcc->root_op, FALSE, TRUE,
                           TRUE, mtcc->pool, scratch_pool));

      if (!for_move && !op && !created)
        {
          /* Allow deleting directories, that are unmodified except for
              one or more deleted descendants */

          SVN_ERR(mtcc_op_find(&op, &created, relpath, mtcc->root_op, TRUE,
                  FALSE, FALSE, mtcc->pool, scratch_pool));

          if (op && mtcc_op_contains_non_delete(op))
            op = NULL;
          else
            created = TRUE;
        }

      if (!op || !created)
        {
          return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
                                   _("Can't delete node at '%s'"),
                                   relpath);
        }
    }

  op->kind = OP_DELETE;
  op->children = NULL;
  op->prop_mods = NULL;

  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__mtcc_add_delete(const char *relpath,
                            svn_client__mtcc_t *mtcc,
                            apr_pool_t *scratch_pool)
{
  return svn_error_trace(mtcc_add_delete(relpath, FALSE, mtcc, scratch_pool));
}

svn_error_t *
svn_client__mtcc_add_mkdir(const char *relpath,
                           svn_client__mtcc_t *mtcc,
                           apr_pool_t *scratch_pool)
{
  mtcc_op_t *op;
  svn_boolean_t created;
  SVN_ERR_ASSERT(svn_relpath_is_canonical(relpath));

  SVN_ERR(mtcc_verify_create(mtcc, relpath, scratch_pool));

  if (SVN_PATH_IS_EMPTY(relpath) && MTCC_UNMODIFIED(mtcc))
    {
      /* Turn the root of the operation in an MKDIR */
      mtcc->root_op->kind = OP_ADD_DIR;

      return SVN_NO_ERROR;
    }

  SVN_ERR(mtcc_op_find(&op, &created, relpath, mtcc->root_op, FALSE, FALSE,
                       FALSE, mtcc->pool, scratch_pool));

  if (!op || !created)
    {
      return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
                               _("Can't create directory at '%s'"),
                               relpath);
    }

  op->kind = OP_ADD_DIR;

  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__mtcc_add_move(const char *src_relpath,
                          const char *dst_relpath,
                          svn_client__mtcc_t *mtcc,
                          apr_pool_t *scratch_pool)
{
  const char *origin_relpath;
  svn_revnum_t origin_rev;

  SVN_ERR(mtcc_get_origin(&origin_relpath, &origin_rev,
                          src_relpath, FALSE, mtcc,
                          scratch_pool, scratch_pool));

  SVN_ERR(svn_client__mtcc_add_copy(src_relpath, mtcc->base_revision,
                                    dst_relpath, mtcc, scratch_pool));
  SVN_ERR(mtcc_add_delete(src_relpath, TRUE, mtcc, scratch_pool));

  return SVN_NO_ERROR;
}

/* Baton for mtcc_prop_getter */
struct mtcc_prop_get_baton
{
  svn_client__mtcc_t *mtcc;
  const char *relpath;
  svn_cancel_func_t cancel_func;
  void *cancel_baton;
};

/* Implements svn_wc_canonicalize_svn_prop_get_file_t */
static svn_error_t *
mtcc_prop_getter(const svn_string_t **mime_type,
                 svn_stream_t *stream,
                 void *baton,
                 apr_pool_t *pool)
{
  struct mtcc_prop_get_baton *mpgb = baton;
  const char *origin_relpath;
  svn_revnum_t origin_rev;
  apr_hash_t *props = NULL;

  mtcc_op_t *op;

  if (mime_type)
    *mime_type = NULL;

  /* Check if we have the information locally */
  SVN_ERR(mtcc_op_find(&op, NULL, mpgb->relpath, mpgb->mtcc->root_op, TRUE,
                       FALSE, FALSE, pool, pool));

  if (op)
    {
      if (mime_type)
        {
          int i;

          for (i = 0; op->prop_mods && i < op->prop_mods->nelts; i++)
            {
              const svn_prop_t *mod = &APR_ARRAY_IDX(op->prop_mods, i,
                                                     svn_prop_t);

              if (! strcmp(mod->name, SVN_PROP_MIME_TYPE))
                {
                  *mime_type = svn_string_dup(mod->value, pool);
                  mime_type = NULL;
                  break;
                }
            }
        }

      if (stream && op->src_stream)
        {
          svn_stream_mark_t *mark;
          svn_error_t *err;

          /* Is the source stream capable of being read multiple times? */
          err = svn_stream_mark(op->src_stream, &mark, pool);

          if (err && err->apr_err != SVN_ERR_STREAM_SEEK_NOT_SUPPORTED)
            return svn_error_trace(err);
          svn_error_clear(err);

          if (!err)
            {
              err = svn_stream_copy3(svn_stream_disown(op->src_stream, pool),
                                     svn_stream_disown(stream, pool),
                                     mpgb->cancel_func, mpgb->cancel_baton,
                                     pool);

              SVN_ERR(svn_error_compose_create(
                            err,
                            svn_stream_seek(op->src_stream, mark)));
            }
          /* else: ### Create tempfile? */

          stream = NULL; /* Stream is handled */
        }
    }

  if (!stream && !mime_type)
    return SVN_NO_ERROR;

  SVN_ERR(mtcc_get_origin(&origin_relpath, &origin_rev, mpgb->relpath, TRUE,
                          mpgb->mtcc, pool, pool));

  if (!origin_relpath)
    return SVN_NO_ERROR; /* Nothing to fetch at repository */

  SVN_ERR(svn_ra_get_file(mpgb->mtcc->ra_session, origin_relpath, origin_rev,
                          stream, NULL, mime_type ? &props : NULL, pool));

  if (mime_type && props)
    *mime_type = svn_hash_gets(props, SVN_PROP_MIME_TYPE);

  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__mtcc_add_propset(const char *relpath,
                             const char *propname,
                             const svn_string_t *propval,
                             svn_boolean_t skip_checks,
                             svn_client__mtcc_t *mtcc,
                             apr_pool_t *scratch_pool)
{
  mtcc_op_t *op;
  SVN_ERR_ASSERT(svn_relpath_is_canonical(relpath));

  if (! svn_prop_name_is_valid(propname))
    return svn_error_createf(SVN_ERR_CLIENT_PROPERTY_NAME, NULL,
                             _("Bad property name: '%s'"), propname);

  if (svn_prop_is_known_svn_rev_prop(propname))
    return svn_error_createf(SVN_ERR_CLIENT_PROPERTY_NAME, NULL,
                             _("Revision property '%s' not allowed "
                               "in this context"), propname);

  if (svn_property_kind2(propname) == svn_prop_wc_kind)
    return svn_error_createf(SVN_ERR_CLIENT_PROPERTY_NAME, NULL,
                             _("'%s' is a wcprop, thus not accessible "
                               "to clients"), propname);

  if (!skip_checks && svn_prop_needs_translation(propname))
    {
      svn_string_t *translated_value;
      SVN_ERR_W(svn_subst_translate_string2(&translated_value, NULL,
                                            NULL, propval,
                                            NULL, FALSE,
                                            scratch_pool, scratch_pool),
                _("Error normalizing property value"));

      propval = translated_value;
    }

  if (propval && svn_prop_is_svn_prop(propname))
    {
      struct mtcc_prop_get_baton mpbg;
      svn_node_kind_t kind;
      SVN_ERR(svn_client__mtcc_check_path(&kind, relpath, FALSE, mtcc,
                                          scratch_pool));

      mpbg.mtcc = mtcc;
      mpbg.relpath = relpath;
      mpbg.cancel_func = mtcc->ctx->cancel_func;
      mpbg.cancel_baton = mtcc->ctx->cancel_baton;

      SVN_ERR(svn_wc_canonicalize_svn_prop(&propval, propname, propval,
                                           relpath, kind, skip_checks,
                                           mtcc_prop_getter, &mpbg,
                                           scratch_pool));
    }

  if (SVN_PATH_IS_EMPTY(relpath) && MTCC_UNMODIFIED(mtcc))
    {
      svn_node_kind_t kind;

      /* Probing the node for an unmodified root will fix the node type to
         a file if necessary */

      SVN_ERR(svn_client__mtcc_check_path(&kind, relpath, FALSE,
                                          mtcc, scratch_pool));

      if (kind == svn_node_none)
        return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
                                 _("Can't set properties at not existing '%s'"),
                                   relpath);

      op = mtcc->root_op;
    }
  else
    {
      SVN_ERR(mtcc_op_find(&op, NULL, relpath, mtcc->root_op, TRUE, FALSE,
                           FALSE, mtcc->pool, scratch_pool));

      if (!op)
        {
          svn_node_kind_t kind;
          svn_boolean_t created;

          /* ### TODO: Check if this node is within a newly copied directory,
                       and update origin values accordingly */

          SVN_ERR(svn_client__mtcc_check_path(&kind, relpath, FALSE,
                                              mtcc, scratch_pool));

          if (kind == svn_node_none)
            return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
                                     _("Can't set properties at not existing '%s'"),
                                     relpath);

          SVN_ERR(mtcc_op_find(&op, &created, relpath, mtcc->root_op, TRUE, FALSE,
                               (kind != svn_node_dir),
                               mtcc->pool, scratch_pool));

          SVN_ERR_ASSERT(op != NULL);
        }
    }

  if (!op->prop_mods)
      op->prop_mods = apr_array_make(mtcc->pool, 4, sizeof(svn_prop_t));

  {
    svn_prop_t propchange;
    propchange.name = apr_pstrdup(mtcc->pool, propname);

    if (propval)
      propchange.value = svn_string_dup(propval, mtcc->pool);
    else
      propchange.value = NULL;

    APR_ARRAY_PUSH(op->prop_mods, svn_prop_t) = propchange;
  }

  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__mtcc_add_update_file(const char *relpath,
                                 svn_stream_t *src_stream,
                                 const svn_checksum_t *src_checksum,
                                 svn_stream_t *base_stream,
                                 const svn_checksum_t *base_checksum,
                                 svn_client__mtcc_t *mtcc,
                                 apr_pool_t *scratch_pool)
{
  mtcc_op_t *op;
  svn_boolean_t created;
  svn_node_kind_t kind;
  SVN_ERR_ASSERT(svn_relpath_is_canonical(relpath) && src_stream);

  SVN_ERR(svn_client__mtcc_check_path(&kind, relpath, FALSE,
                                      mtcc, scratch_pool));

  if (kind != svn_node_file)
    return svn_error_createf(SVN_ERR_FS_NOT_FILE, NULL,
                             _("Can't update '%s' because it is not a file"),
                             relpath);

  SVN_ERR(mtcc_op_find(&op, &created, relpath, mtcc->root_op, TRUE, FALSE,
                       TRUE, mtcc->pool, scratch_pool));

  if (!op
      || (op->kind != OP_OPEN_FILE && op->kind != OP_ADD_FILE)
      || (op->src_stream != NULL))
    {
      return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
                               _("Can't update file at '%s'"), relpath);
    }

  op->src_stream = src_stream;
  op->src_checksum = src_checksum ? svn_checksum_dup(src_checksum, mtcc->pool)
                                  : NULL;

  op->base_stream = base_stream;
  op->base_checksum = base_checksum ? svn_checksum_dup(base_checksum,
                                                       mtcc->pool)
                                    : NULL;

  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__mtcc_check_path(svn_node_kind_t *kind,
                            const char *relpath,
                            svn_boolean_t check_repository,
                            svn_client__mtcc_t *mtcc,
                            apr_pool_t *scratch_pool)
{
  const char *origin_relpath;
  svn_revnum_t origin_rev;
  mtcc_op_t *op;

  SVN_ERR_ASSERT(svn_relpath_is_canonical(relpath));

  if (SVN_PATH_IS_EMPTY(relpath) && MTCC_UNMODIFIED(mtcc)
      && !mtcc->root_op->performed_stat)
    {
      /* We know nothing about the root. Perhaps it is a file? */
      SVN_ERR(svn_ra_check_path(mtcc->ra_session, "", mtcc->base_revision,
                                kind, scratch_pool));

      mtcc->root_op->performed_stat = TRUE;
      if (*kind == svn_node_file)
        {
          mtcc->root_op->kind = OP_OPEN_FILE;
          mtcc->root_op->children = NULL;
        }
      return SVN_NO_ERROR;
    }

  SVN_ERR(mtcc_op_find(&op, NULL, relpath, mtcc->root_op, TRUE, FALSE,
                       FALSE, mtcc->pool, scratch_pool));

  if (!op || (check_repository && !op->performed_stat))
    {
      SVN_ERR(mtcc_get_origin(&origin_relpath, &origin_rev,
                              relpath, TRUE, mtcc,
                              scratch_pool, scratch_pool));

      if (!origin_relpath)
        *kind = svn_node_none;
      else
        SVN_ERR(svn_ra_check_path(mtcc->ra_session, origin_relpath,
                                  origin_rev, kind, scratch_pool));

      if (op && *kind == svn_node_dir)
        {
          if (op->kind == OP_OPEN_DIR || op->kind == OP_ADD_DIR)
            op->performed_stat = TRUE;
          else if (op->kind == OP_OPEN_FILE || op->kind == OP_ADD_FILE)
            return svn_error_createf(SVN_ERR_FS_NOT_FILE, NULL,
                                     _("Can't perform file operation "
                                       "on '%s' as it is not a file"),
                                     relpath);
        }
      else if (op && *kind == svn_node_file)
        {
          if (op->kind == OP_OPEN_FILE || op->kind == OP_ADD_FILE)
            op->performed_stat = TRUE;
          else if (op->kind == OP_OPEN_DIR || op->kind == OP_ADD_DIR)
            return svn_error_createf(SVN_ERR_FS_NOT_DIRECTORY, NULL,
                                     _("Can't perform directory operation "
                                       "on '%s' as it is not a directory"),
                                     relpath);
        }
      else if (op && (op->kind == OP_OPEN_DIR || op->kind == OP_OPEN_FILE))
        {
          return svn_error_createf(SVN_ERR_FS_NOT_FOUND, NULL,
                                   _("Can't open '%s' as it does not exist"),
                                   relpath);
        }

      return SVN_NO_ERROR;
    }

  /* op != NULL */
  if (op->kind == OP_OPEN_DIR || op->kind == OP_ADD_DIR)
    {
      *kind = svn_node_dir;
      return SVN_NO_ERROR;
    }
  else if (op->kind == OP_OPEN_FILE || op->kind == OP_ADD_FILE)
    {
      *kind = svn_node_file;
      return SVN_NO_ERROR;
    }
  SVN_ERR_MALFUNCTION(); /* No other kinds defined as delete is filtered */
}

static svn_error_t *
commit_properties(const svn_delta_editor_t *editor,
                  const mtcc_op_t *op,
                  void *node_baton,
                  apr_pool_t *scratch_pool)
{
  int i;
  apr_pool_t *iterpool;

  if (!op->prop_mods || op->prop_mods->nelts == 0)
    return SVN_NO_ERROR;

  iterpool = svn_pool_create(scratch_pool);
  for (i = 0; i < op->prop_mods->nelts; i++)
    {
      const svn_prop_t *mod = &APR_ARRAY_IDX(op->prop_mods, i, svn_prop_t);

      svn_pool_clear(iterpool);

      if (op->kind == OP_ADD_DIR || op->kind == OP_OPEN_DIR)
        SVN_ERR(editor->change_dir_prop(node_baton, mod->name, mod->value,
                                        iterpool));
      else if (op->kind == OP_ADD_FILE || op->kind == OP_OPEN_FILE)
        SVN_ERR(editor->change_file_prop(node_baton, mod->name, mod->value,
                                         iterpool));
    }

  svn_pool_destroy(iterpool);
  return SVN_NO_ERROR;
}

/* Handles updating a file to a delta editor and then closes it */
static svn_error_t *
commit_file(const svn_delta_editor_t *editor,
            mtcc_op_t *op,
            void *file_baton,
            const char *session_url,
            const char *relpath,
            svn_client_ctx_t *ctx,
            apr_pool_t *scratch_pool)
{
  const char *text_checksum = NULL;
  svn_checksum_t *src_checksum = op->src_checksum;
  SVN_ERR(commit_properties(editor, op, file_baton, scratch_pool));

  if (op->src_stream)
    {
      const char *base_checksum = NULL;
      apr_pool_t *txdelta_pool = scratch_pool;
      svn_txdelta_window_handler_t window_handler;
      void *handler_baton;
      svn_stream_t *src_stream = op->src_stream;

      if (op->base_checksum && op->base_checksum->kind == svn_checksum_md5)
        base_checksum = svn_checksum_to_cstring(op->base_checksum, scratch_pool);

      /* ### TODO: Future enhancement: Allocate in special pool and send
                   files after the true edit operation, like a wc commit */
      SVN_ERR(editor->apply_textdelta(file_baton, base_checksum, txdelta_pool,
                                      &window_handler, &handler_baton));

      if (ctx->notify_func2)
        {
          svn_wc_notify_t *notify;

          notify = svn_wc_create_notify_url(
                            svn_path_url_add_component2(session_url, relpath,
                                                        scratch_pool),
                            svn_wc_notify_commit_postfix_txdelta,
                            scratch_pool);

          notify->path = relpath;
          notify->kind = svn_node_file;

          ctx->notify_func2(ctx->notify_baton2, notify, scratch_pool);
        }

      if (window_handler != svn_delta_noop_window_handler)
        {
          if (!src_checksum || src_checksum->kind != svn_checksum_md5)
            src_stream = svn_stream_checksummed2(src_stream, &src_checksum, NULL,
                                                 svn_checksum_md5,
                                                 TRUE, scratch_pool);

          if (!op->base_stream)
            SVN_ERR(svn_txdelta_send_stream(src_stream,
                                            window_handler, handler_baton, NULL,
                                            scratch_pool));
          else
            SVN_ERR(svn_txdelta_run(op->base_stream, src_stream,
                                    window_handler, handler_baton,
                                    svn_checksum_md5, NULL,
                                    ctx->cancel_func, ctx->cancel_baton,
                                    scratch_pool, scratch_pool));
        }

      SVN_ERR(svn_stream_close(src_stream));
      if (op->base_stream)
        SVN_ERR(svn_stream_close(op->base_stream));
    }

  if (src_checksum && src_checksum->kind == svn_checksum_md5)
    text_checksum = svn_checksum_to_cstring(src_checksum, scratch_pool);

  return svn_error_trace(editor->close_file(file_baton, text_checksum,
                                            scratch_pool));
}

/* Handles updating a directory to a delta editor and then closes it */
static svn_error_t *
commit_directory(const svn_delta_editor_t *editor,
                 mtcc_op_t *op,
                 const char *relpath,
                 svn_revnum_t base_rev,
                 void *dir_baton,
                 const char *session_url,
                 svn_client_ctx_t *ctx,
                 apr_pool_t *scratch_pool)
{
  SVN_ERR(commit_properties(editor, op, dir_baton, scratch_pool));

  if (op->children && op->children->nelts > 0)
    {
      apr_pool_t *iterpool = svn_pool_create(scratch_pool);
      int i;

      for (i = 0; i < op->children->nelts; i++)
        {
          mtcc_op_t *cop;
          const char * child_relpath;
          void *child_baton;

          cop = APR_ARRAY_IDX(op->children, i, mtcc_op_t *);

          svn_pool_clear(iterpool);

          if (ctx->cancel_func)
            SVN_ERR(ctx->cancel_func(ctx->cancel_baton));

          child_relpath = svn_relpath_join(relpath, cop->name, iterpool);

          switch (cop->kind)
            {
              case OP_DELETE:
                SVN_ERR(editor->delete_entry(child_relpath, base_rev,
                                             dir_baton, iterpool));
                break;

              case OP_ADD_DIR:
                SVN_ERR(editor->add_directory(child_relpath, dir_baton,
                                              cop->src_relpath
                                                ? svn_path_url_add_component2(
                                                              session_url,
                                                              cop->src_relpath,
                                                              iterpool)
                                                : NULL,
                                              cop->src_rev,
                                              iterpool, &child_baton));
                SVN_ERR(commit_directory(editor, cop, child_relpath,
                                         SVN_INVALID_REVNUM, child_baton,
                                         session_url, ctx, iterpool));
                break;
              case OP_OPEN_DIR:
                SVN_ERR(editor->open_directory(child_relpath, dir_baton,
                                               base_rev, iterpool, &child_baton));
                SVN_ERR(commit_directory(editor, cop, child_relpath,
                                         base_rev, child_baton,
                                         session_url, ctx, iterpool));
                break;

              case OP_ADD_FILE:
                SVN_ERR(editor->add_file(child_relpath, dir_baton,
                                         cop->src_relpath
                                            ? svn_path_url_add_component2(
                                                            session_url,
                                                            cop->src_relpath,
                                                            iterpool)
                                            : NULL,
                                         cop->src_rev,
                                         iterpool, &child_baton));
                SVN_ERR(commit_file(editor, cop, child_baton,
                                    session_url, child_relpath, ctx, iterpool));
                break;
              case OP_OPEN_FILE:
                SVN_ERR(editor->open_file(child_relpath, dir_baton, base_rev,
                                          iterpool, &child_baton));
                SVN_ERR(commit_file(editor, cop, child_baton,
                                    session_url, child_relpath, ctx, iterpool));
                break;

              default:
                SVN_ERR_MALFUNCTION();
            }
        }
    }

  return svn_error_trace(editor->close_directory(dir_baton, scratch_pool));
}


/* Helper function to recursively create svn_client_commit_item3_t items
   to provide to the log message callback */
static svn_error_t *
add_commit_items(mtcc_op_t *op,
                 const char *session_url,
                 const char *url,
                 apr_array_header_t *commit_items,
                 apr_pool_t *result_pool,
                 apr_pool_t *scratch_pool)
{
  if ((op->kind != OP_OPEN_DIR && op->kind != OP_OPEN_FILE)
      || (op->prop_mods && op->prop_mods->nelts)
      || (op->src_stream))
    {
      svn_client_commit_item3_t *item;

      item = svn_client_commit_item3_create(result_pool);

      item->path = NULL;
      if (op->kind == OP_OPEN_DIR || op->kind == OP_ADD_DIR)
        item->kind = svn_node_dir;
      else if (op->kind == OP_OPEN_FILE || op->kind == OP_ADD_FILE)
        item->kind = svn_node_file;
      else
        item->kind = svn_node_unknown;

      item->url = apr_pstrdup(result_pool, url);
      item->session_relpath = svn_uri_skip_ancestor(session_url, item->url,
                                                    result_pool);

      if (op->src_relpath)
        {
          item->copyfrom_url = svn_path_url_add_component2(session_url,
                                                           op->src_relpath,
                                                           result_pool);
          item->copyfrom_rev = op->src_rev;
          item->state_flags |= SVN_CLIENT_COMMIT_ITEM_IS_COPY;
        }
      else
        item->copyfrom_rev = SVN_INVALID_REVNUM;

      if (op->kind == OP_ADD_DIR || op->kind == OP_ADD_FILE)
        item->state_flags = SVN_CLIENT_COMMIT_ITEM_ADD;
      else if (op->kind == OP_DELETE)
        item->state_flags = SVN_CLIENT_COMMIT_ITEM_DELETE;
      /* else item->state_flags = 0; */

      if (op->prop_mods && op->prop_mods->nelts)
        item->state_flags |= SVN_CLIENT_COMMIT_ITEM_PROP_MODS;

      if (op->src_stream)
        item->state_flags |= SVN_CLIENT_COMMIT_ITEM_TEXT_MODS;

      APR_ARRAY_PUSH(commit_items, svn_client_commit_item3_t *) = item;
    }

  if (op->children && op->children->nelts)
    {
      int i;
      apr_pool_t *iterpool = svn_pool_create(scratch_pool);

      for (i = 0; i < op->children->nelts; i++)
        {
          mtcc_op_t *cop;
          const char * child_url;

          cop = APR_ARRAY_IDX(op->children, i, mtcc_op_t *);

          svn_pool_clear(iterpool);

          child_url = svn_path_url_add_component2(url, cop->name, iterpool);

          SVN_ERR(add_commit_items(cop, session_url, child_url, commit_items,
                                   result_pool, iterpool));
        }

      svn_pool_destroy(iterpool);
    }

  return SVN_NO_ERROR;
}

svn_error_t *
svn_client__mtcc_commit(apr_hash_t *revprop_table,
                        svn_commit_callback2_t commit_callback,
                        void *commit_baton,
                        svn_client__mtcc_t *mtcc,
                        apr_pool_t *scratch_pool)
{
  const svn_delta_editor_t *editor;
  void *edit_baton;
  void *root_baton;
  apr_hash_t *commit_revprops;
  svn_node_kind_t kind;
  svn_error_t *err;
  const char *session_url;
  const char *log_msg;

  if (MTCC_UNMODIFIED(mtcc))
    {
      /* No changes -> no revision. Easy out */
      svn_pool_destroy(mtcc->pool);
      return SVN_NO_ERROR;
    }

  SVN_ERR(svn_ra_get_session_url(mtcc->ra_session, &session_url, scratch_pool));

  if (mtcc->root_op->kind != OP_OPEN_DIR)
    {
      const char *name;

      svn_uri_split(&session_url, &name, session_url, scratch_pool);

      if (*name)
        {
          SVN_ERR(mtcc_reparent(session_url, mtcc, scratch_pool));

          SVN_ERR(svn_ra_reparent(mtcc->ra_session, session_url, scratch_pool));
        }
    }

    /* Create new commit items and add them to the array. */
  if (SVN_CLIENT__HAS_LOG_MSG_FUNC(mtcc->ctx))
    {
      svn_client_commit_item3_t *item;
      const char *tmp_file;
      apr_array_header_t *commit_items
                = apr_array_make(scratch_pool, 32, sizeof(item));

      SVN_ERR(add_commit_items(mtcc->root_op, session_url, session_url,
                               commit_items, scratch_pool, scratch_pool));

      SVN_ERR(svn_client__get_log_msg(&log_msg, &tmp_file, commit_items,
                                      mtcc->ctx, scratch_pool));

      if (! log_msg)
        return SVN_NO_ERROR;
    }
  else
    log_msg = "";

  SVN_ERR(svn_client__ensure_revprop_table(&commit_revprops, revprop_table,
                                           log_msg, mtcc->ctx, scratch_pool));

  /* Ugly corner case: The ra session might have died while we were waiting
     for the callback */

  err = svn_ra_check_path(mtcc->ra_session, "", mtcc->base_revision, &kind,
                          scratch_pool);

  if (err)
    {
      svn_error_t *err2 = svn_client_open_ra_session2(&mtcc->ra_session,
                                                      session_url,
                                                      NULL, mtcc->ctx,
                                                      mtcc->pool,
                                                      scratch_pool);

      if (err2)
        {
          svn_pool_destroy(mtcc->pool);
          return svn_error_trace(svn_error_compose_create(err, err2));
        }
      svn_error_clear(err);

      SVN_ERR(svn_ra_check_path(mtcc->ra_session, "",
                                mtcc->base_revision, &kind, scratch_pool));
    }

  if (kind != svn_node_dir)
    return svn_error_createf(SVN_ERR_FS_NOT_DIRECTORY, NULL,
                             _("Can't commit to '%s' because it "
                               "is not a directory"),
                             session_url);

  /* Beware that the editor object must not live longer than the MTCC.
     Otherwise, txn objects etc. in EDITOR may live longer than their
     respective FS objects.  So, we can't use SCRATCH_POOL here. */
  SVN_ERR(svn_ra_get_commit_editor3(mtcc->ra_session, &editor, &edit_baton,
                                    commit_revprops,
                                    commit_callback, commit_baton,
                                    NULL /* lock_tokens */,
                                    FALSE /* keep_locks */,
                                    mtcc->pool));

  err = editor->open_root(edit_baton, mtcc->base_revision, scratch_pool, &root_baton);

  if (!err)
    err = commit_directory(editor, mtcc->root_op, "", mtcc->base_revision,
                           root_baton, session_url, mtcc->ctx, scratch_pool);

  if (!err)
    {
      if (mtcc->ctx->notify_func2)
        {
          svn_wc_notify_t *notify;
          notify = svn_wc_create_notify_url(session_url,
                                            svn_wc_notify_commit_finalizing,
                                            scratch_pool);
          mtcc->ctx->notify_func2(mtcc->ctx->notify_baton2, notify,
                                  scratch_pool);
        }
      SVN_ERR(editor->close_edit(edit_baton, scratch_pool));
    }
  else
    err = svn_error_compose_create(err,
                                   editor->abort_edit(edit_baton, scratch_pool));

  svn_pool_destroy(mtcc->pool);

  return svn_error_trace(err);
}