/*
 * merge.c: handle the MERGE response processing
 *
 * ====================================================================
 * 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/.
 * ====================================================================
 */

#include <apr_pools.h>
#include <apr_buckets.h>
#include <apr_xml.h>

#include <httpd.h>
#include <util_filter.h>

#include "svn_pools.h"
#include "svn_fs.h"
#include "svn_repos.h"

#include "dav_svn.h"


/* #################################################################

   These functions are currently *VERY* SVN specific.

   * we don't check prop_elem for what the client requested
   * we presume a baseline was checked out into the activity, and is
     part of the MERGE
   * we presume that all "changed" files/dirs were checked out into
     the activity and are part of the MERGE
     (not sure if this is SVN specific; I can't see how a file/dir
      would be part of the new revision if a working resource had
      not been created for it)
   * we return some props for some resources, and a different set for
     other resources (to keep the wire smaller for now)

   At some point in the future, we'll want to make this "real". Especially
   for proper interoperability.

   #################################################################
*/

typedef struct {
  apr_pool_t *pool;
  ap_filter_t *output;
  apr_bucket_brigade *bb;
  svn_fs_root_t *root;
  const dav_svn_repos *repos;

} merge_response_ctx;

typedef struct mr_baton {
  merge_response_ctx *mrc;

  /* for directories, this is a subpool. otherwise, the pool to use. */
  apr_pool_t *pool;

  /* path for this baton's corresponding FS object */
  const char *path;

  /* for a directory, have we seen a change yet? */
  svn_boolean_t seen_change;

} mr_baton;


/* -------------------------------------------------------------------------

   PRIVATE HELPER FUNCTIONS
*/

static mr_baton *make_child_baton(mr_baton *parent, const char *name,
                                  svn_boolean_t is_dir)
{
  apr_pool_t *pool;
  mr_baton *subdir;

  if (is_dir)
    pool = svn_pool_create(parent->pool);
  else
    pool = parent->pool;

  subdir = apr_pcalloc(pool, sizeof(*subdir));
  subdir->mrc = parent->mrc;
  subdir->pool = pool;

  if (parent->path[1] == '\0')  /* must be "/" */
    subdir->path = apr_pstrcat(pool, "/", name, NULL);
  else
    subdir->path = apr_pstrcat(pool, parent->path, "/", name, NULL);

  return subdir;
}

/* send a response to the client for this baton */
static svn_error_t *send_response(mr_baton *baton, svn_boolean_t is_dir)
{
  merge_response_ctx *mrc = baton->mrc;
  const char *href;
  const char *rt;
  svn_fs_id_t *id;
  svn_stringbuf_t *stable_id;
  const char *vsn_url;
  apr_status_t status;

  href = dav_svn_build_uri(mrc->repos, DAV_SVN_BUILD_URI_PUBLIC,
                           SVN_IGNORED_REVNUM, baton->path,
                           0 /* add_href */, baton->pool);

  rt = is_dir
    ? "<D:resourcetype><D:collection/></D:resourcetype>" DEBUG_CR
    : "<D:resourcetype/>" DEBUG_CR;

  SVN_ERR( svn_fs_node_id(&id, mrc->root, baton->path, baton->pool) );

  stable_id = svn_fs_unparse_id(id, baton->pool);
  svn_stringbuf_appendcstr(stable_id, baton->path);

  vsn_url = dav_svn_build_uri(mrc->repos, DAV_SVN_BUILD_URI_VERSION,
                              SVN_INVALID_REVNUM, stable_id->data,
                              0 /* add_href */, baton->pool);

  status = ap_fputstrs(mrc->output, mrc->bb,
                       "<D:response>" DEBUG_CR
                       "<D:href>", 
                       apr_xml_quote_string (baton->pool, href, 1),
                       "</D:href>" DEBUG_CR
                       "<D:propstat><D:prop>" DEBUG_CR,
                       rt,
                       "<D:checked-in><D:href>",
                       apr_xml_quote_string (baton->pool, vsn_url, 1),
                       "</D:href></D:checked-in>" DEBUG_CR
                       "</D:prop>" DEBUG_CR
                       "<D:status>HTTP/1.1 200 OK</D:status>" DEBUG_CR
                       "</D:propstat>" DEBUG_CR
                       "</D:response>" DEBUG_CR,
                       NULL);

  if (status != APR_SUCCESS)
    return svn_error_create(status, 0, NULL, baton->pool,
                            "could not write response to output");

  return APR_SUCCESS;
}


/* -------------------------------------------------------------------------

   EDITOR FUNCTIONS
*/

static svn_error_t *mr_open_root(void *edit_baton,
                                 svn_revnum_t base_revision,
                                 void **root_baton)
{
  merge_response_ctx *mrc = edit_baton;
  apr_pool_t *pool;
  mr_baton *b;

  /* note that we create a subpool; the root_baton is passed to the
     close_directory callback, where we will destroy the pool. */
  pool = svn_pool_create(mrc->pool);
  b = apr_pcalloc(pool, sizeof(*b));
  b->mrc = mrc;
  b->pool = pool;
  b->path = "/";

  *root_baton = b;
  return NULL;
}

static svn_error_t *mr_delete_entry(svn_stringbuf_t *name,
                                    svn_revnum_t revision,
                                    void *parent_baton)
{
  mr_baton *parent = parent_baton;

  /* Removing an item is an explicit change to the parent. Mark it so the
     client will get the data on the new parent. */
  parent->seen_change = TRUE;

  return NULL;
}

static svn_error_t *mr_add_directory(svn_stringbuf_t *name,
                                     void *parent_baton,
                                     svn_stringbuf_t *copyfrom_path,
                                     svn_revnum_t copyfrom_revision,
                                     void **child_baton)
{
  mr_baton *parent = parent_baton;
  mr_baton *subdir = make_child_baton(parent, name->data, TRUE);

  /* pretend that we've already seen a change for this dir (so that a prop
     change won't generate a second response) */
  subdir->seen_change = TRUE;

  /* the response for this directory will occur at close_directory time */

  /* Adding a subdir is an explicit change to the parent. Mark it so the
     client will get the data on the new parent. */
  parent->seen_change = TRUE;

  *child_baton = subdir;
  return NULL;
}

static svn_error_t *mr_open_directory(svn_stringbuf_t *name,
                                      void *parent_baton,
                                      svn_revnum_t base_revision,
                                      void **child_baton)
{
  mr_baton *parent = parent_baton;
  mr_baton *subdir = make_child_baton(parent, name->data, TRUE);

  /* Don't issue a response until we see a prop change, or a file/subdir
     is added/removed inside this directory. */

  *child_baton = subdir;
  return NULL;
}

static svn_error_t *mr_change_dir_prop(void *dir_baton,
                                       svn_stringbuf_t *name,
                                       svn_stringbuf_t *value)
{
  mr_baton *dir = dir_baton;

  /* okay, this qualifies as a change, and we need to tell the client
     (which happens at close_directory time). */
  dir->seen_change = TRUE;

  return NULL;
}

static svn_error_t *mr_close_directory(void *dir_baton)
{
  mr_baton *dir = dir_baton;

  /* if we ever saw a change for this directory, then issue a response
     for it. */
  if (dir->seen_change)
    {
      SVN_ERR( send_response(dir, TRUE /* is_dir */) );
    }

  svn_pool_destroy(dir->pool);

  return NULL;
}

static svn_error_t *mr_add_file(svn_stringbuf_t *name,
                                void *parent_baton,
                                svn_stringbuf_t *copy_path,
                                svn_revnum_t copy_revision,
                                void **file_baton)
{
  mr_baton *parent = parent_baton;
  mr_baton *file = make_child_baton(parent, name->data, FALSE);

  /* We wait until close_file to issue a response for this. */

  /* Adding a file is an explicit change to the parent. Mark it so the
     client will get the data on the new parent. */
  parent->seen_change = TRUE;

  *file_baton = file;
  return NULL;
}

static svn_error_t *mr_open_file(svn_stringbuf_t *name,
                                 void *parent_baton,
                                 svn_revnum_t base_revision,
                                 void **file_baton)
{
  mr_baton *parent = parent_baton;
  mr_baton *file = make_child_baton(parent, name->data, FALSE);

  /* We wait until close_file to issue a response for this. */

  *file_baton = file;
  return NULL;
}

static svn_error_t *mr_close_file(void *file_baton)
{
  /* nothing to do except for sending the response. */
  return send_response(file_baton, FALSE /* is_dir */);
}


/* -------------------------------------------------------------------------

   PUBLIC FUNCTIONS
*/

dav_error * dav_svn__merge_response(ap_filter_t *output,
                                    const dav_svn_repos *repos,
                                    svn_revnum_t new_rev,
                                    apr_xml_elem *prop_elem,
                                    apr_pool_t *pool)
{
  apr_bucket_brigade *bb;
  svn_fs_root_t *committed_root;
  svn_fs_root_t *previous_root;
  svn_error_t *serr;
  const char *vcc;
  char revbuf[20];      /* long enough for %ld */
  svn_string_t *creationdate, *creator_displayname;
  apr_hash_t *revs;
  svn_revnum_t *rev_ptr;
  svn_delta_edit_fns_t *editor;
  merge_response_ctx mrc = { 0 };

  serr = svn_fs_revision_root(&committed_root, repos->fs, new_rev, pool);
  if (serr != NULL)
    {
      return dav_svn_convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
                                 "Could not open the FS root for the "
                                 "revision just committed.");
    }
  serr = svn_fs_revision_root(&previous_root, repos->fs, new_rev - 1, pool);
  if (serr != NULL)
    {
      return dav_svn_convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
                                 "Could not open the FS root for the "
                                 "previous revision.");
    }

  bb = apr_brigade_create(pool, output->c->bucket_alloc);

  /* prep some strings */
  
  /* the HREF for the baseline is actually the VCC */
  vcc = dav_svn_build_uri(repos, DAV_SVN_BUILD_URI_VCC, SVN_IGNORED_REVNUM,
                          NULL, 0 /* add_href */, pool);

  /* the version-name of the baseline is the revision number */
  sprintf(revbuf, "%ld", new_rev);

  /* get the creationdate and creator-displayname of the new revision, too. */
  serr = svn_fs_revision_prop(&creationdate, repos->fs, new_rev,
                              SVN_PROP_REVISION_DATE, pool);
  if (serr != NULL)
    {
      return dav_svn_convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
                                 "Could not get date of newest revision"); 
    }
  serr = svn_fs_revision_prop(&creator_displayname, repos->fs, new_rev,
                              SVN_PROP_REVISION_AUTHOR, pool);
  if (serr != NULL)
    {
      return dav_svn_convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
                                 "Could not get author of newest revision"); 
    }


  (void) ap_fputstrs(output, bb,
                     DAV_XML_HEADER DEBUG_CR
                     "<D:merge-response xmlns:D=\"DAV:\">" DEBUG_CR
                     "<D:updated-set>" DEBUG_CR

                     /* generate a response for the new baseline */
                     "<D:response>" DEBUG_CR
                     "<D:href>", 
                     apr_xml_quote_string (pool, vcc, 1),
                     "</D:href>" DEBUG_CR
                     "<D:propstat><D:prop>" DEBUG_CR
                     /* ### this is wrong. it's a VCC, not a baseline. but
                        ### we need to tell the client to look at *this*
                        ### resource for the version-name. */
                     "<D:resourcetype><D:baseline/></D:resourcetype>" DEBUG_CR
                     "<D:version-name>", revbuf, "</D:version-name>" DEBUG_CR
                     "<D:creationdate>", creationdate->data, 
                                     "</D:creationdate>" DEBUG_CR
                     "<D:creator-displayname>", creator_displayname->data,
                                     "</D:creator-displayname>" DEBUG_CR
                     "</D:prop>" DEBUG_CR
                     "<D:status>HTTP/1.1 200 OK</D:status>" DEBUG_CR
                     "</D:propstat>" DEBUG_CR
                     "</D:response>" DEBUG_CR,

                     NULL);

  /* Now we need to generate responses for all the resources which changed.
     This is done through a delta of the two roots.

     Note that a directory is not marked when open_dir is seen (since it
     typically is used just for changing members in that directory); instead,
     we want for a property change (the only reason the client would need to
     fetch a new directory).

     ### we probably should say something about the dirs, so that we can
     ### pass back the new version URL */

  /* ### hrm. needing this hash table feels wonky. */
  revs = apr_hash_make(pool);
  rev_ptr = apr_palloc(pool, sizeof(*rev_ptr));
  *rev_ptr = new_rev - 1;
  apr_hash_set(revs, "", APR_HASH_KEY_STRING, rev_ptr);

  /* set up the editor for the delta process */
  editor = svn_delta_old_default_editor(pool);
  editor->open_root = mr_open_root;
  editor->delete_entry = mr_delete_entry;
  editor->add_directory = mr_add_directory;
  editor->open_directory = mr_open_directory;
  editor->change_dir_prop = mr_change_dir_prop;
  editor->close_directory = mr_close_directory;
  editor->add_file = mr_add_file;
  editor->open_file = mr_open_file;
  editor->close_file = mr_close_file;

  /* set up the merge response context */
  mrc.pool = pool;
  mrc.output = output;
  mrc.bb = bb;
  mrc.root = committed_root;
  mrc.repos = repos;

  serr = svn_repos_dir_delta(previous_root, "/",
                             NULL,      /* ### should fix */
                             revs,
                             committed_root, "/",
                             editor, &mrc, 
                             FALSE, /* don't bother with text-deltas */
                             TRUE, /* Do recurse into subdirectories */
                             FALSE, /* Do not allow copyfrom args */
                             pool);
  if (serr != NULL)
    {
      return dav_svn_convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
                                 "could not process the merge delta.");
    }

  /* wrap up the merge response */
  (void) ap_fputs(output, bb,
                  "</D:updated-set>" DEBUG_CR
                  "</D:merge-response>" DEBUG_CR);

  /* send whatever is left in the brigade */
  (void) ap_pass_brigade(output, bb);

  return NULL;
}


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