/*
 * ra_loader.c:  logic for loading different RA library implementations
 *
 * ====================================================================
 *    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.
 * ====================================================================
 */

/* ==================================================================== */

/*** Includes. ***/
#define APR_WANT_STRFUNC
#include <apr_want.h>

#include <apr.h>
#include <apr_strings.h>
#include <apr_pools.h>
#include <apr_hash.h>
#include <apr_uri.h>

#include "svn_hash.h"
#include "svn_types.h"
#include "svn_error.h"
#include "svn_delta.h"
#include "svn_ra.h"
#include "svn_dirent_uri.h"
#include "svn_props.h"
#include "svn_iter.h"

#include "private/svn_branch_compat.h"
#include "private/svn_branch_repos.h"
#include "private/svn_ra_private.h"
#include "private/svn_delta_private.h"
#include "private/svn_string_private.h"
#include "svnmover.h"
#include "svn_private_config.h"


/* Read the branching info string VALUE belonging to revision REVISION.
 */
static svn_error_t *
read_rev_prop(svn_string_t **value,
              svn_ra_session_t *ra_session,
              const char *branch_info_dir,
              svn_revnum_t revision,
              apr_pool_t *result_pool)
{
  apr_pool_t *scratch_pool = result_pool;

  if (branch_info_dir)
    {
      const char *file_path;
      svn_stream_t *stream;
      svn_error_t *err;

      file_path = svn_dirent_join(branch_info_dir,
                                  apr_psprintf(scratch_pool, "branch-info-r%ld",
                                               revision), scratch_pool);
      err = svn_stream_open_readonly(&stream, file_path, scratch_pool, scratch_pool);
      if (err)
        {
          svn_error_clear(err);
          *value = NULL;
          return SVN_NO_ERROR;
        }
      SVN_ERR(err);
      SVN_ERR(svn_string_from_stream2(value, stream, 0, result_pool));
    }
  else
    {
      SVN_ERR(svn_ra_rev_prop(ra_session, revision, "svn-br-info", value,
                              result_pool));
    }
  return SVN_NO_ERROR;
}

/* Store the branching info string VALUE belonging to revision REVISION.
 */
static svn_error_t *
write_rev_prop(svn_ra_session_t *ra_session,
               const char *branch_info_dir,
               svn_revnum_t revision,
               svn_string_t *value,
               apr_pool_t *scratch_pool)
{
  if (branch_info_dir)
    {
      const char *file_path;
      svn_error_t *err;

     file_path = svn_dirent_join(branch_info_dir,
                                  apr_psprintf(scratch_pool, "branch-info-r%ld",
                                               revision), scratch_pool);
      err = svn_io_file_create(file_path, value->data, scratch_pool);
      if (err)
        {
          svn_error_clear(err);
          SVN_ERR(svn_io_dir_make(branch_info_dir, APR_FPROT_OS_DEFAULT,
                                  scratch_pool));
          err = svn_io_file_create(file_path, value->data, scratch_pool);
        }
      SVN_ERR(err);
    }
  else
    {
      SVN_ERR(svn_ra_change_rev_prop2(ra_session, revision, "svn-br-info",
                                      NULL, value, scratch_pool));
    }

  return SVN_NO_ERROR;
}

/* Create a new revision-root object and read the move-tracking /
 * branch-tracking metadata from the repository into it.
 */
static svn_error_t *
branch_revision_fetch_info(svn_branch__txn_t **txn_p,
                           svn_branch__repos_t *repos,
                           svn_ra_session_t *ra_session,
                           const char *branch_info_dir,
                           svn_revnum_t revision,
                           apr_pool_t *result_pool,
                           apr_pool_t *scratch_pool)
{
  svn_string_t *value;
  svn_stream_t *stream;
  svn_branch__txn_t *txn;

  SVN_ERR_ASSERT(SVN_IS_VALID_REVNUM(revision));

  /* Read initial state from repository */
  SVN_ERR(read_rev_prop(&value, ra_session, branch_info_dir, revision,
                        scratch_pool));
  if (! value && revision == 0)
    {
      value = svn_branch__get_default_r0_metadata(scratch_pool);
      /*SVN_DBG(("fetch_per_revision_info(r%ld): LOADED DEFAULT INFO:\n%s",
               revision, value->data));*/
      SVN_ERR(write_rev_prop(ra_session, branch_info_dir, revision, value,
                             scratch_pool));
    }
  else if (! value)
    {
      return svn_error_createf(SVN_BRANCH__ERR, NULL,
                               _("Move-tracking metadata not found in r%ld "
                                 "in this repository. Run svnmover on an "
                                 "empty repository to initialize the "
                                 "metadata"), revision);
    }
  stream = svn_stream_from_string(value, scratch_pool);

  SVN_ERR(svn_branch__txn_parse(&txn, repos, stream,
                                result_pool, scratch_pool));

  /* Self-test: writing out the info should produce exactly the same string. */
  {
    svn_stringbuf_t *buf = svn_stringbuf_create_empty(scratch_pool);

    stream = svn_stream_from_stringbuf(buf, scratch_pool);
    SVN_ERR(svn_branch__txn_serialize(txn, stream, scratch_pool));
    SVN_ERR(svn_stream_close(stream));

    SVN_ERR_ASSERT(svn_string_compare(value,
                                      svn_stringbuf__morph_into_string(buf)));
  }

  *txn_p = txn;
  return SVN_NO_ERROR;
}

/* Fetch all element payloads in TXN.
 */
static svn_error_t *
txn_fetch_payloads(svn_branch__txn_t *txn,
                   svn_branch__compat_fetch_func_t fetch_func,
                   void *fetch_baton,
                   apr_pool_t *result_pool,
                   apr_pool_t *scratch_pool)
{
  apr_array_header_t *branches = svn_branch__txn_get_branches(txn, scratch_pool);
  int i;

  /* Read payload of each element.
     (In a real implementation, of course, we'd delay this until demanded.) */
  for (i = 0; i < branches->nelts; i++)
    {
      svn_branch__state_t *branch = APR_ARRAY_IDX(branches, i, void *);
      svn_element__tree_t *element_tree;
      apr_hash_index_t *hi;

      SVN_ERR(svn_branch__state_get_elements(branch, &element_tree,
                                             scratch_pool));
      for (hi = apr_hash_first(scratch_pool, element_tree->e_map);
           hi; hi = apr_hash_next(hi))
        {
          int eid = svn_eid__hash_this_key(hi);
          svn_element__content_t *element /*= apr_hash_this_val(hi)*/;

          SVN_ERR(svn_branch__state_get_element(branch, &element,
                                                eid, scratch_pool));
          if (! element->payload->is_subbranch_root)
            {
              SVN_ERR(svn_branch__compat_fetch(&element->payload,
                                               txn,
                                               element->payload->branch_ref,
                                               fetch_func, fetch_baton,
                                               result_pool, scratch_pool));
            }
        }
    }

  return SVN_NO_ERROR;
}

/* Create a new repository object and read the move-tracking /
 * branch-tracking metadata from the repository into it.
 */
static svn_error_t *
branch_repos_fetch_info(svn_branch__repos_t **repos_p,
                        svn_ra_session_t *ra_session,
                        const char *branch_info_dir,
                        svn_branch__compat_fetch_func_t fetch_func,
                        void *fetch_baton,
                        apr_pool_t *result_pool,
                        apr_pool_t *scratch_pool)
{
  svn_branch__repos_t *repos
    = svn_branch__repos_create(result_pool);
  svn_revnum_t base_revision;
  svn_revnum_t r;

  SVN_ERR(svn_ra_get_latest_revnum(ra_session, &base_revision, scratch_pool));

  for (r = 0; r <= base_revision; r++)
    {
      svn_branch__txn_t *txn;

      SVN_ERR(branch_revision_fetch_info(&txn,
                                         repos, ra_session, branch_info_dir,
                                         r,
                                         result_pool, scratch_pool));
      SVN_ERR(svn_branch__repos_add_revision(repos, txn));
      SVN_ERR(txn_fetch_payloads(txn, fetch_func, fetch_baton,
                                 result_pool, scratch_pool));
      }

  *repos_p = repos;
  return SVN_NO_ERROR;
}

/* Return a mutable state based on revision BASE_REVISION in REPOS.
 */
static svn_error_t *
branch_get_mutable_state(svn_branch__txn_t **txn_p,
                         svn_branch__repos_t *repos,
                         svn_ra_session_t *ra_session,
                         const char *branch_info_dir,
                         svn_revnum_t base_revision,
                         svn_branch__compat_fetch_func_t fetch_func,
                         void *fetch_baton,
                         apr_pool_t *result_pool,
                         apr_pool_t *scratch_pool)
{
  svn_branch__txn_t *txn;
  apr_array_header_t *branches;
  int i;

  SVN_ERR_ASSERT(SVN_IS_VALID_REVNUM(base_revision));

  SVN_ERR(branch_revision_fetch_info(&txn,
                                     repos, ra_session, branch_info_dir,
                                     base_revision,
                                     result_pool, scratch_pool));
  SVN_ERR_ASSERT(txn->rev == base_revision);
  SVN_ERR(txn_fetch_payloads(txn, fetch_func, fetch_baton,
                             result_pool, scratch_pool));

  /* Update all the 'predecessor' info to point to the BASE_REVISION instead
     of to that revision's predecessor. */
  txn->base_rev = base_revision;
  txn->rev = SVN_INVALID_REVNUM;

  branches = svn_branch__txn_get_branches(txn, scratch_pool);
  for (i = 0; i < branches->nelts; i++)
    {
      svn_branch__state_t *b = APR_ARRAY_IDX(branches, i, void *);
      svn_branch__history_t *history
        = svn_branch__history_create_empty(result_pool);

      /* Set each branch's parent to the branch in the base rev */
      svn_branch__rev_bid_t *parent
        = svn_branch__rev_bid_create(base_revision,
                                     svn_branch__get_id(b, scratch_pool),
                                     result_pool);

      svn_hash_sets(history->parents,
                    apr_pstrdup(result_pool, b->bid), parent);
      SVN_ERR(svn_branch__state_set_history(b, history, scratch_pool));
    }

  *txn_p = txn;
  return SVN_NO_ERROR;
}

/* Store the move-tracking / branch-tracking metadata from TXN into the
 * repository. TXN->rev is the newly committed revision number.
 */
static svn_error_t *
store_repos_info(svn_branch__txn_t *txn,
                 svn_ra_session_t *ra_session,
                 const char *branch_info_dir,
                 apr_pool_t *scratch_pool)
{
  svn_stringbuf_t *buf = svn_stringbuf_create_empty(scratch_pool);
  svn_stream_t *stream = svn_stream_from_stringbuf(buf, scratch_pool);

  SVN_ERR(svn_branch__txn_serialize(txn, stream, scratch_pool));

  SVN_ERR(svn_stream_close(stream));
  /*SVN_DBG(("store_repos_info: %s", buf->data));*/
  SVN_ERR(write_rev_prop(ra_session, branch_info_dir, txn->rev,
                         svn_stringbuf__morph_into_string(buf), scratch_pool));

  return SVN_NO_ERROR;
}

struct ccw_baton
{
  svn_commit_callback2_t original_callback;
  void *original_baton;

  svn_ra_session_t *session;
  const char *branch_info_dir;
  svn_branch__txn_t *branching_txn;
};

/* Wrapper which stores the branching/move-tracking info.
 */
static svn_error_t *
commit_callback_wrapper(const svn_commit_info_t *commit_info,
                        void *baton,
                        apr_pool_t *pool)
{
  struct ccw_baton *ccwb = baton;

  /* if this commit used element-branching info, store the new info */
  if (ccwb->branching_txn)
    {
      svn_branch__repos_t *repos = ccwb->branching_txn->repos;

      ccwb->branching_txn->rev = commit_info->revision;
      SVN_ERR(svn_branch__repos_add_revision(repos, ccwb->branching_txn));
      SVN_ERR(store_repos_info(ccwb->branching_txn, ccwb->session,
                               ccwb->branch_info_dir, pool));
    }

  /* call the wrapped callback */
  if (ccwb->original_callback)
    {
      SVN_ERR(ccwb->original_callback(commit_info, ccwb->original_baton, pool));
    }

  return SVN_NO_ERROR;
}


/* Some RA layers do not correctly fill in REPOS_ROOT in commit_info, or
   they are third-party layers conforming to an older commit_info structure.
   Interpose a utility function to ensure the field is valid.  */
static void
remap_commit_callback(svn_commit_callback2_t *callback,
                      void **callback_baton,
                      svn_ra_session_t *session,
                      svn_branch__txn_t *branching_txn,
                      const char *branch_info_dir,
                      svn_commit_callback2_t original_callback,
                      void *original_baton,
                      apr_pool_t *result_pool)
{
  /* Allocate this in RESULT_POOL, since the callback will be called
     long after this function has returned. */
  struct ccw_baton *ccwb = apr_palloc(result_pool, sizeof(*ccwb));

  ccwb->session = session;
  ccwb->branch_info_dir = apr_pstrdup(result_pool, branch_info_dir);
  ccwb->branching_txn = branching_txn;
  ccwb->original_callback = original_callback;
  ccwb->original_baton = original_baton;

  *callback = commit_callback_wrapper;
  *callback_baton = ccwb;
}


/* Ev3 shims */
struct fb_baton {
  /* A session parented at the repository root */
  svn_ra_session_t *session;
  const char *repos_root_url;
  const char *session_path;
};

/* Fetch kind and/or props and/or text.
 *
 * Implements svn_branch__compat_fetch_func_t. */
static svn_error_t *
fetch(svn_node_kind_t *kind_p,
      apr_hash_t **props_p,
      svn_stringbuf_t **file_text,
      apr_hash_t **children_names,
      void *baton,
      const char *repos_relpath,
      svn_revnum_t revision,
      apr_pool_t *result_pool,
      apr_pool_t *scratch_pool)
{
  struct fb_baton *fbb = baton;
  svn_node_kind_t kind;
  apr_hash_index_t *hi;

  if (props_p)
    *props_p = NULL;
  if (file_text)
    *file_text = NULL;
  if (children_names)
    *children_names = NULL;

  SVN_ERR(svn_ra_check_path(fbb->session, repos_relpath, revision,
                            &kind, scratch_pool));
  if (kind_p)
    *kind_p = kind;
  if (kind == svn_node_file && (props_p || file_text))
    {
      svn_stream_t *file_stream = NULL;

      if (file_text)
        {
          *file_text = svn_stringbuf_create_empty(result_pool);
          file_stream = svn_stream_from_stringbuf(*file_text, scratch_pool);
        }
      SVN_ERR(svn_ra_get_file(fbb->session, repos_relpath, revision,
                              file_stream, NULL, props_p, result_pool));
      if (file_text)
        {
          SVN_ERR(svn_stream_close(file_stream));
        }
    }
  else if (kind == svn_node_dir && (props_p || children_names))
    {
      SVN_ERR(svn_ra_get_dir2(fbb->session,
                              children_names, NULL, props_p,
                              repos_relpath, revision,
                              0 /*minimal child info*/,
                              result_pool));
    }

  /* Remove non-regular props */
  if (props_p && *props_p)
    {
      for (hi = apr_hash_first(scratch_pool, *props_p); hi; hi = apr_hash_next(hi))
        {
          const char *name = apr_hash_this_key(hi);

          if (svn_property_kind2(name) != svn_prop_regular_kind)
            svn_hash_sets(*props_p, name, NULL);

        }
    }

  return SVN_NO_ERROR;
}

svn_error_t *
svn_ra_load_branching_state(svn_branch__txn_t **branching_txn_p,
                            svn_branch__compat_fetch_func_t *fetch_func,
                            void **fetch_baton,
                            svn_ra_session_t *session,
                            const char *branch_info_dir,
                            svn_revnum_t base_revision,
                            apr_pool_t *result_pool,
                            apr_pool_t *scratch_pool)
{
  svn_branch__repos_t *repos;
  const char *repos_root_url, *session_url, *base_relpath;
  struct fb_baton *fbb = apr_palloc(result_pool, sizeof (*fbb));

  if (base_revision == SVN_INVALID_REVNUM)
    {
      SVN_ERR(svn_ra_get_latest_revnum(session, &base_revision, scratch_pool));
    }

  /* fetcher */
  SVN_ERR(svn_ra_get_repos_root2(session, &repos_root_url, result_pool));
  SVN_ERR(svn_ra_get_session_url(session, &session_url, scratch_pool));
  base_relpath = svn_uri_skip_ancestor(repos_root_url, session_url, result_pool);
  SVN_ERR(svn_ra__dup_session(&fbb->session, session, repos_root_url, result_pool, scratch_pool));
  fbb->session_path = base_relpath;
  fbb->repos_root_url = repos_root_url;
  *fetch_func = fetch;
  *fetch_baton = fbb;

  SVN_ERR(branch_repos_fetch_info(&repos,
                                  session, branch_info_dir,
                                  *fetch_func, *fetch_baton,
                                  result_pool, scratch_pool));
  SVN_ERR(branch_get_mutable_state(branching_txn_p,
                                   repos, session, branch_info_dir,
                                   base_revision,
                                   *fetch_func, *fetch_baton,
                                   result_pool, scratch_pool));

  return SVN_NO_ERROR;
}

svn_error_t *
svn_ra_get_commit_txn(svn_ra_session_t *session,
                      svn_branch__txn_t **edit_txn_p,
                      apr_hash_t *revprop_table,
                      svn_commit_callback2_t commit_callback,
                      void *commit_baton,
                      apr_hash_t *lock_tokens,
                      svn_boolean_t keep_locks,
                      const char *branch_info_dir,
                      apr_pool_t *pool)
{
  svn_branch__txn_t *branching_txn;
  svn_branch__compat_fetch_func_t fetch_func;
  void *fetch_baton;
  const svn_delta_editor_t *deditor;
  void *dedit_baton;
  svn_branch__compat_shim_connector_t *shim_connector;

  /* load branching info
   * ### Currently we always start from a single base revision, never from
   *     a mixed-rev state */
  SVN_ERR(svn_ra_load_branching_state(&branching_txn, &fetch_func, &fetch_baton,
                                      session, branch_info_dir,
                                      SVN_INVALID_REVNUM /*base_revision*/,
                                      pool, pool));

  /* arrange for branching info to be stored after commit */
  remap_commit_callback(&commit_callback, &commit_baton,
                        session, branching_txn, branch_info_dir,
                        commit_callback, commit_baton, pool);

  SVN_ERR(svn_ra_get_commit_editor3(session, &deditor, &dedit_baton,
                                    revprop_table,
                                    commit_callback, commit_baton,
                                    lock_tokens, keep_locks, pool));

  /* Convert to Ev3 */
  {
    const char *repos_root_url;

    SVN_ERR(svn_ra_get_repos_root2(session, &repos_root_url, pool));

    /*SVN_ERR(svn_delta__get_debug_editor(&deditor, &dedit_baton,
                                          deditor, dedit_baton, "", pool));*/
    SVN_ERR(svn_branch__compat_txn_from_delta_for_commit(
                        edit_txn_p,
                        &shim_connector,
                        deditor, dedit_baton, branching_txn,
                        repos_root_url,
                        fetch_func, fetch_baton,
                        NULL, NULL /*cancel*/,
                        pool, pool));
  }

  return SVN_NO_ERROR;
}