/*
 * main.c: Subversion server inspection tool.
 *
 * ====================================================================
 * 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_general.h>
#include <apr_pools.h>
#include <apr_time.h>
#include <apr_thread_proc.h>
#include <apr_file_io.h>

#define APR_WANT_STDIO
#define APR_WANT_STRFUNC
#include <apr_want.h>

#include "svn_types.h"
#include "svn_pools.h"
#include "svn_error.h"
#include "svn_path.h"
#include "svn_repos.h"
#include "svn_fs.h"
#include "svn_repos.h"
#include "svn_time.h"


/*** Some convenience macros and types. ***/

/* Temporary subdirectory created for use by svnlook.  ### todo: we
   need to either find a way to query APR for a suitable (that is,
   writable) temporary directory, or add this #define to the
   svn_private_config.h stuffs (with a default of perhaps "/tmp/.svnlook" */
#define SVNLOOK_TMPDIR       ".svnlook"

typedef enum svnlook_cmd_t
{
  svnlook_cmd_default = 0,

  svnlook_cmd_author,
  svnlook_cmd_changed,
  svnlook_cmd_date,
  svnlook_cmd_diff,
  svnlook_cmd_dirs_changed,
  svnlook_cmd_ids,
  svnlook_cmd_info,
  svnlook_cmd_log,
  svnlook_cmd_tree,
  
} svnlook_cmd_t;


typedef struct svnlook_ctxt_t
{
  svn_repos_t *repos;
  svn_fs_t *fs;
  svn_boolean_t is_revision;
  svn_revnum_t rev_id;
  svn_fs_txn_t *txn;
  char *txn_name;

} svnlook_ctxt_t;


/*** Helper functions. ***/
static svn_error_t *
get_property (svn_string_t **prop_value,
              svnlook_ctxt_t *c, 
              const char *prop_name,
              apr_pool_t *pool)
{
  /* Fetch transaction property... */
  if (! c->is_revision)
    return svn_fs_txn_prop (prop_value, c->txn, prop_name, pool);

  /* ...or revision property -- it's your call. */
  return svn_fs_revision_prop (prop_value, c->fs, c->rev_id, prop_name, pool);
}


static svn_error_t *
get_root (svn_fs_root_t **root,
          svnlook_ctxt_t *c,
          apr_pool_t *pool)
{
  /* Open up the appropriate root (revision or transaction). */
  if (c->is_revision)
    {
      /* If we didn't get a valid revision number, we'll look at the
         youngest revision. */
      if (! SVN_IS_VALID_REVNUM (c->rev_id))
        SVN_ERR (svn_fs_youngest_rev (&(c->rev_id), c->fs, pool));

      SVN_ERR (svn_fs_revision_root (root, c->fs, c->rev_id, pool));
    }
  else
    {
      SVN_ERR (svn_fs_txn_root (root, c->txn, pool));
    }

  return SVN_NO_ERROR;
}


/*** Tree Routines ***/

/* Generate a generic delta tree. */
static svn_error_t *
generate_delta_tree (svn_repos_node_t **tree,
                     svn_repos_t *repos,
                     svn_fs_root_t *root, 
                     svn_revnum_t base_rev, 
                     apr_pool_t *pool)
{
  svn_fs_root_t *base_root;
  const svn_delta_edit_fns_t *editor;
  void *edit_baton;
  apr_hash_t *src_revs = apr_hash_make (pool);
  apr_pool_t *edit_pool = svn_pool_create (pool);
  svn_fs_t *fs = svn_repos_fs (repos);

  /* Get the current root. */
  apr_hash_set (src_revs, "", APR_HASH_KEY_STRING, &base_rev);

  /* Get the base root. */
  SVN_ERR (svn_fs_revision_root (&base_root, fs, base_rev, pool));

  /* Request our editor. */
  SVN_ERR (svn_repos_node_editor (&editor, &edit_baton, repos,
                                  base_root, root, pool, edit_pool));
  
  /* Drive our editor. */
  SVN_ERR (svn_repos_dir_delta (base_root, "", NULL, src_revs, root, "",
                                editor, edit_baton, FALSE, TRUE, FALSE,
                                edit_pool));

  /* Return the tree we just built. */
  *tree = svn_repos_node_from_baton (edit_baton);
  svn_pool_destroy (edit_pool);
  return SVN_NO_ERROR;
}


/*** Tree Printing Routines ***/

/* Recursively print only directory nodes that either a) have property
   mods, or b) contains files that have changed. */
static void
print_dirs_changed_tree (svn_repos_node_t *node,
                         svn_stringbuf_t *path,
                         apr_pool_t *pool)
{
  svn_repos_node_t *tmp_node;
  int print_me = 0;
  svn_stringbuf_t *full_path;

  if (! node)
    return;

  /* Not a directory?  We're not interested. */
  if (node->kind != svn_node_dir)
    return;

  /* Got prop mods?  Excellent. */
  if (node->prop_mod)
    print_me = 1;

  if (! print_me)
    {
      /* Fly through the list of children, checking for modified files. */
      tmp_node = node->child;
      if (tmp_node)
        {
          if ((tmp_node->kind == svn_node_file)
              || (tmp_node->text_mod)
              || (tmp_node->action == 'A')
              || (tmp_node->action == 'D'))
            {
              print_me = 1;
            }
          while (tmp_node->sibling && (! print_me ))
            {
              tmp_node = tmp_node->sibling;
              if ((tmp_node->kind == svn_node_file)
                  || (tmp_node->text_mod)
                  || (tmp_node->action == 'A')
                  || (tmp_node->action == 'D'))
                {
                  print_me = 1;
                }
            }
        }
    }
  
  /* Print the node if it qualifies. */
  if (print_me)
    {
      printf ("%s/\n", path->data);
    }

  /* Recursively handle the node's children. */
  tmp_node = node->child;
  if (! tmp_node)
    return;

  full_path = svn_stringbuf_dup (path, pool);
  svn_path_add_component_nts (full_path, tmp_node->name);
  print_dirs_changed_tree (tmp_node, full_path, pool);
  while (tmp_node->sibling)
    {
      tmp_node = tmp_node->sibling;
      svn_stringbuf_set (full_path, path->data);
      svn_path_add_component_nts (full_path, tmp_node->name);
      print_dirs_changed_tree (tmp_node, full_path, pool);
    }

  return;
}


/* Recursively print all nodes in the tree that have been modified
   (do not include directories affected only by "bubble-up"). */
static void
print_changed_tree (svn_repos_node_t *node,
                    svn_stringbuf_t *path,
                    apr_pool_t *pool)
{
  svn_repos_node_t *tmp_node;
  svn_stringbuf_t *full_path;
  char status[3] = "_ ";
  int print_me = 1;

  if (! node)
    return;

  /* Print the node. */
  tmp_node = node;
  if (tmp_node->action == 'A')
    status[0] = 'A';
  else if (tmp_node->action == 'D')
    status[0] = 'D';
  else if (tmp_node->action == 'R')
    {
      if ((! tmp_node->text_mod) && (! tmp_node->prop_mod))
        print_me = 0;
      if (tmp_node->text_mod)
        status[0] = 'U';
      if (tmp_node->prop_mod)
        status[1] = 'U';
    }
  else
    print_me = 0;

  /* Print this node unless told to skip it. */
  if (print_me)
    printf ("%s  %s%s\n",
            status,
            path->data,
            tmp_node->kind == svn_node_dir ? "/" : "");
  
  /* Return here if the node has no children. */
  tmp_node = tmp_node->child;
  if (! tmp_node)
    return;

  /* Recursively handle the node's children. */
  full_path = svn_stringbuf_dup (path, pool);
  svn_path_add_component_nts (full_path, tmp_node->name);
  print_changed_tree (tmp_node, full_path, pool);
  while (tmp_node->sibling)
    {
      tmp_node = tmp_node->sibling;
      svn_stringbuf_set (full_path, path->data);
      svn_path_add_component_nts (full_path, tmp_node->name);
      print_changed_tree (tmp_node, full_path, pool);
    }

  return;
}


static svn_error_t *
open_writable_binary_file (apr_file_t **fh, 
                           svn_stringbuf_t *path, 
                           apr_pool_t *pool)
{
  apr_array_header_t *path_pieces;
  apr_status_t apr_err;
  int i;
  svn_stringbuf_t *full_path, *dir, *basename;
  
  /* Try the easy way to open the file. */
  apr_err = apr_file_open (fh, path->data, 
                           APR_WRITE | APR_CREATE | APR_TRUNCATE | APR_BINARY,
                           APR_OS_DEFAULT, pool);
  if (! apr_err)
    return SVN_NO_ERROR;

  svn_path_split (path, &dir, &basename, pool);

  /* If the file path has no parent, then we've already tried to open
     it as best as we care to try above. */
  if (svn_path_is_empty (dir))
    return svn_error_createf (apr_err, 0, NULL, pool,
                              "Error opening writable file %s", path->data);

  path_pieces = svn_path_decompose (dir, pool);
  if (! path_pieces->nelts)
    return APR_SUCCESS;

  full_path = svn_stringbuf_create ("", pool);
  for (i = 0; i < path_pieces->nelts; i++)
    {
      enum svn_node_kind kind;
      svn_stringbuf_t *piece = ((svn_stringbuf_t **) (path_pieces->elts))[i];
      svn_path_add_component (full_path, piece);
      SVN_ERR (svn_io_check_path (full_path->data, &kind, pool));

      /* Does this path component exist at all? */
      if (kind == svn_node_none)
        {
          apr_err = apr_dir_make (full_path->data, APR_OS_DEFAULT, pool);
          if (apr_err)
            return svn_error_createf (apr_err, 0, NULL, pool,
                                      "Error creating dir %s", 
                                      full_path->data);
        }
      else if (kind != svn_node_dir)
        {
          if (apr_err)
            return svn_error_createf (apr_err, 0, NULL, pool,
                                      "Error creating dir %s (path exists)", 
                                      full_path->data);
        }
    }

  /* Now that we are ensured that the parent path for this file
     exists, try once more to open it. */
  apr_err = apr_file_open (fh, path->data, 
                           APR_WRITE | APR_CREATE | APR_TRUNCATE | APR_BINARY,
                           APR_OS_DEFAULT, pool);
  if (apr_err)
    return svn_error_createf (apr_err, 0, NULL, pool,
                              "Error opening writable file %s", path->data);
    
  return SVN_NO_ERROR;
}


static svn_error_t *
dump_contents (apr_file_t *fh,
               svn_fs_root_t *root,
               svn_stringbuf_t *path,
               apr_pool_t *pool)
{
  apr_status_t apr_err;
  apr_size_t len, len2;
  svn_stream_t *stream;
  unsigned char buffer[1024];

  /* Get a stream to the current file's contents. */
  SVN_ERR (svn_fs_file_contents (&stream, root, path->data, pool));
  
  /* Now, route that data into our temporary file. */
  while (1)
    {
      len = sizeof (buffer);
      SVN_ERR (svn_stream_read (stream, buffer, &len));
      len2 = len;
      apr_err = apr_file_write (fh, buffer, &len2);
      if ((apr_err) || (len2 != len))
        return svn_error_createf 
          (apr_err ? apr_err : SVN_ERR_INCOMPLETE_DATA, 0, NULL, pool,
               "Error writing contents of %s", path->data);
      if (len != sizeof (buffer))
        break;
    }

  /* And close the file. */
  apr_file_close (fh);
  return SVN_NO_ERROR;
}


/* Recursively print all nodes in the tree that have been modified
   (do not include directories affected only by "bubble-up"). */
static svn_error_t *
print_diff_tree (svn_fs_root_t *root,
                 svn_fs_root_t *base_root,
                 svn_repos_node_t *node, 
                 svn_stringbuf_t *path,
                 apr_pool_t *pool)
{
  svn_repos_node_t *tmp_node;
  svn_stringbuf_t *full_path;
  svn_stringbuf_t *orig_path = NULL, *new_path = NULL;
  apr_file_t *fh1, *fh2;
      
  if (! node)
    return SVN_NO_ERROR;

  /* Print the node. */
  tmp_node = node;

  /* First, we'll just print file content diffs. */
  if (tmp_node->kind == svn_node_file)
    {
      /* Here's the generalized way we do our diffs:

         - First, dump the contents of the new version of the file
           into the svnlook temporary directory, building out the
           actual directories that need to be created in order to
           fully represent the filesystem path inside the tmp
           directory.

         - Then, dump the contents of the old version of the file into
           the top level of the svnlook temporary directory using a
           unique temporary file name (we do this *after* putting the
           new version of the file there in case something actually
           versioned has a name that looks like one of our unique
           identifiers).
           
         - Next, we run 'diff', passing the repository path as the
           label.  

         - Finally, we delete the temporary files (but leave the
           built-out directories in place until after all diff
           handling has been finished).  */
      if ((tmp_node->action == 'R') && (tmp_node->text_mod))
        {
          new_path = svn_stringbuf_create (SVNLOOK_TMPDIR, pool);
          svn_path_add_component (new_path, path);
          SVN_ERR (open_writable_binary_file (&fh1, new_path, pool));
          SVN_ERR (dump_contents (fh1, root, path, pool));
          apr_file_close (fh1);

          SVN_ERR (svn_io_open_unique_file (&fh2, &orig_path, new_path->data,
                                            NULL, FALSE, pool));
          SVN_ERR (dump_contents (fh2, base_root, path, pool));
          apr_file_close (fh2);
        }
      if (tmp_node->action == 'A')
        {
          new_path = svn_stringbuf_create (SVNLOOK_TMPDIR, pool);
          svn_path_add_component (new_path, path);
          SVN_ERR (open_writable_binary_file (&fh1, new_path, pool));
          SVN_ERR (dump_contents (fh1, root, path, pool));
          apr_file_close (fh1);

          SVN_ERR (svn_io_open_unique_file (&fh2, &orig_path, new_path->data,
                                            NULL, FALSE, pool));
          apr_file_close (fh2);
        }
      if (tmp_node->action == 'D')
        {
          new_path = svn_stringbuf_create (SVNLOOK_TMPDIR, pool);
          svn_path_add_component (new_path, path);
          SVN_ERR (open_writable_binary_file (&fh1, new_path, pool));
          apr_file_close (fh1);

          SVN_ERR (svn_io_open_unique_file (&fh2, &orig_path, new_path->data,
                                            NULL, FALSE, pool));
          SVN_ERR (dump_contents (fh2, base_root, path, pool));
          apr_file_close (fh2);
        }
    }

  if (orig_path && new_path)
    {
      apr_file_t *outhandle;
      apr_status_t apr_err;
      const char *label;
      svn_stringbuf_t *abs_path;
      int exitcode;

      printf ("%s: %s\n", 
              ((tmp_node->action == 'A') ? "Added" : 
               ((tmp_node->action == 'D') ? "Deleted" :
                ((tmp_node->action == 'R') ? "Modified" : "Index"))),
              path->data);
      printf ("===============================================================\
===============\n");
      fflush (stdout);

      /* Get an apr_file_t representing stdout, which is where we'll have
         the diff program print to. */
      apr_err = apr_file_open_stdout (&outhandle, pool);
      if (apr_err)
        return svn_error_create 
          (apr_err, 0, NULL, pool,
           "print_diff_tree: can't open handle to stdout");

      label = apr_psprintf (pool, "%s\t(original)", path->data);
      SVN_ERR (svn_path_get_absolute (&abs_path, orig_path, pool));
      SVN_ERR (svn_io_run_diff (SVNLOOK_TMPDIR, NULL, 0, label,
                                abs_path->data, path->data, 
                                &exitcode, outhandle, NULL, pool));

      /* TODO: Handle exit code == 2 (i.e. diff error) here. */

      printf ("\n");
      fflush (stdout);
    }
  
  /* Now, delete any temporary files. */
  if (orig_path)
    apr_file_remove (orig_path->data, pool);
  if (new_path)
    apr_file_remove (new_path->data, pool);

  /* Return here if the node has no children. */
  tmp_node = tmp_node->child;
  if (! tmp_node)
    return SVN_NO_ERROR;

  /* Recursively handle the node's children. */
  full_path = svn_stringbuf_dup (path, pool);
  svn_path_add_component_nts (full_path, tmp_node->name);
  SVN_ERR (print_diff_tree (root, base_root, tmp_node, full_path, pool));
  while (tmp_node->sibling)
    {
      tmp_node = tmp_node->sibling;
      svn_stringbuf_set (full_path, path->data);
      svn_path_add_component_nts (full_path, tmp_node->name);
      SVN_ERR (print_diff_tree (root, base_root, tmp_node, full_path, pool));
    }

  return SVN_NO_ERROR;
}


/* Recursively print all nodes in the tree. 
 * 
 * ### todo: I'd like to write a more descriptive doc string for this
 * function, but I wasn't able to figure out in a finite amount of
 * time why it even takes the arguments it takes, or why it does what
 * it does with them.  See issue #540.  -kff
 */
static void
print_ids_tree (svn_repos_node_t *node,
                svn_fs_root_t *root,
                svn_stringbuf_t *path,
                int indentation,
                apr_pool_t *pool)
{
  svn_stringbuf_t *full_path;
  svn_repos_node_t *tmp_node;
  int i;
  svn_fs_id_t *id;
  svn_stringbuf_t *unparsed_id = NULL;
  apr_pool_t *subpool;

  if (! node)
    return;

  /* Print the indentation. */
  for (i = 0; i < indentation; i++)
    {
      printf (" ");
    }

  /* Get the node's ID */
  tmp_node = node;
  svn_fs_node_id (&id, root, path->data, pool);
  if (id)
    unparsed_id = svn_fs_unparse_id (id, pool);
  
  /* Print the node. */
  printf ("%s%s <%s>\n", 
          tmp_node->name, 
          tmp_node->kind == svn_node_dir ? "/" : "",
          unparsed_id ? unparsed_id->data : "unknown");

  /* Return here if the node has no children. */
  tmp_node = tmp_node->child;
  if (! tmp_node)
    return;

  /* Recursively handle the node's children. */
  subpool = svn_pool_create (pool);
  full_path = svn_stringbuf_dup (path, subpool);
  svn_path_add_component_nts (full_path, tmp_node->name);
  print_ids_tree (tmp_node, root, full_path, indentation + 1, subpool);
  while (tmp_node->sibling)
    {
      tmp_node = tmp_node->sibling;
      svn_stringbuf_set (full_path, path->data);
      svn_path_add_component_nts (full_path, tmp_node->name);
      print_ids_tree (tmp_node, root, full_path, indentation + 1, subpool);
    }
  svn_pool_destroy (subpool);

  return;
}


/* Recursively print all nodes in the tree.  If SHOW_IDS is non-zero,
   print the id of each node next to its name. */
static void
print_tree (svn_repos_node_t *node,
            int indentation)
{
  svn_repos_node_t *tmp_node;
  int i;

  if (! node)
    return;

  /* Print the indentation. */
  for (i = 0; i < indentation; i++)
    {
      printf (" ");
    }

  /* Print the node. */
  tmp_node = node;
  printf ("%s%s \n", 
          tmp_node->name, 
          tmp_node->kind == svn_node_dir ? "/" : "");

  /* Return here if the node has no children. */
  tmp_node = tmp_node->child;
  if (! tmp_node)
    return;

  /* Recursively handle the node's children. */
  print_tree (tmp_node, indentation + 1);
  while (tmp_node->sibling)
    {
      tmp_node = tmp_node->sibling;
      print_tree (tmp_node, indentation + 1);
    }

  return;
}


/*** Subcommand handlers. ***/

/* Print the revision's log message to stdout, followed by a newline. */
static svn_error_t *
do_log (svnlook_ctxt_t *c, svn_boolean_t print_size, apr_pool_t *pool)
{
  svn_string_t *prop_value;

  SVN_ERR (get_property (&prop_value, c, SVN_PROP_REVISION_LOG, pool));

  if (prop_value && prop_value->data)
    {
      if (print_size)
        {
          printf ("%lu\n", (unsigned long)prop_value->len);
        }

      printf ("%s", prop_value->data);
    }
  else if (print_size)
    {
      printf ("0");
    }
  
  printf ("\n");
  return SVN_NO_ERROR;
}


/* Print the timestamp of the commit (in the revision case) or the
   empty string (in the transaction case) to stdout, followed by a
   newline. */
static svn_error_t *
do_date (svnlook_ctxt_t *c, apr_pool_t *pool)
{
  if (c->is_revision)
    {
      svn_string_t *prop_value;
      
      SVN_ERR (get_property (&prop_value, c, SVN_PROP_REVISION_DATE, pool));

      if (prop_value && prop_value->data)
        {
          /* The date stored in the repository is in a really complex
             and precise format...and we don't care.  Let's convert
             that to just "YYYY-MM-DD hh:mm".

             ### todo: Right now, "svn dates" are not GMT, but the
             results of svn_time_from_string are.  This sucks. */
          apr_time_exp_t extime;
          apr_time_t aprtime;
          apr_status_t apr_err;
              
          aprtime = svn_time_from_nts (prop_value->data);
          apr_err = apr_explode_time (&extime, aprtime, 0);
          if (apr_err)
            return svn_error_create (apr_err, 0, NULL, pool,
                                     "do_date: error exploding time");
              
          printf ("%04lu-%02lu-%02lu %02lu:%02lu GMT",
                  (unsigned long)(extime.tm_year + 1900),
                  (unsigned long)(extime.tm_mon + 1),
                  (unsigned long)(extime.tm_mday),
                  (unsigned long)(extime.tm_hour),
                  (unsigned long)(extime.tm_min));
        }
    }

  printf ("\n");
  return SVN_NO_ERROR;
}


/* Print the author of the commit to stdout, followed by a newline. */
static svn_error_t *
do_author (svnlook_ctxt_t *c, apr_pool_t *pool)
{
  svn_string_t *prop_value;

  SVN_ERR (get_property (&prop_value, c, SVN_PROP_REVISION_AUTHOR, pool));

  if (prop_value && prop_value->data)
    printf ("%s", prop_value->data);
  
  printf ("\n");
  return SVN_NO_ERROR;
}


/* Print a list of all directories in which files, or directory
   properties, have been modified. */
static svn_error_t *
do_dirs_changed (svnlook_ctxt_t *c, apr_pool_t *pool)
{ 
  svn_fs_root_t *root;
  svn_revnum_t base_rev_id;
  svn_repos_node_t *tree;

  SVN_ERR (get_root (&root, c, pool));
  if (c->is_revision)
    base_rev_id = c->rev_id - 1;
  else
    base_rev_id = svn_fs_txn_base_revision (c->txn);

  if (! SVN_IS_VALID_REVNUM (base_rev_id))
    return svn_error_createf 
      (SVN_ERR_FS_NO_SUCH_REVISION, 0, NULL, pool,
       "Transaction '%s' is not based on a revision.  How odd.",
       c->txn_name);
  
  SVN_ERR (generate_delta_tree (&tree, c->repos, root, base_rev_id, pool)); 
  if (tree)
    print_dirs_changed_tree (tree, svn_stringbuf_create ("", pool), pool);

  return SVN_NO_ERROR;
}


/* Print a list of all paths modified in a format compatible with `svn
   update'. */
static svn_error_t *
do_changed (svnlook_ctxt_t *c, apr_pool_t *pool)
{
  svn_fs_root_t *root;
  svn_revnum_t base_rev_id;
  svn_repos_node_t *tree;

  SVN_ERR (get_root (&root, c, pool));
  if (c->is_revision)
    base_rev_id = c->rev_id - 1;
  else
    base_rev_id = svn_fs_txn_base_revision (c->txn);

  if (! SVN_IS_VALID_REVNUM (base_rev_id))
    return svn_error_createf 
      (SVN_ERR_FS_NO_SUCH_REVISION, 0, NULL, pool,
       "Transaction '%s' is not based on a revision.  How odd.",
       c->txn_name);
  
  SVN_ERR (generate_delta_tree (&tree, c->repos, root, base_rev_id, pool)); 
  if (tree)
    print_changed_tree (tree, svn_stringbuf_create ("", pool), pool);

  return SVN_NO_ERROR;
}


/* Print some diff-y stuff in a TBD way. :-) */
static svn_error_t *
do_diff (svnlook_ctxt_t *c, apr_pool_t *pool)
{
  svn_fs_root_t *root, *base_root;
  svn_revnum_t base_rev_id;
  svn_repos_node_t *tree;

  SVN_ERR (get_root (&root, c, pool));
  if (c->is_revision)
    base_rev_id = c->rev_id - 1;
  else
    base_rev_id = svn_fs_txn_base_revision (c->txn);

  if (! SVN_IS_VALID_REVNUM (base_rev_id))
    return svn_error_createf 
      (SVN_ERR_FS_NO_SUCH_REVISION, 0, NULL, pool,
       "Transaction '%s' is not based on a revision.  How odd.",
       c->txn_name);
  
  SVN_ERR (generate_delta_tree (&tree, c->repos, root, base_rev_id, pool)); 
  if (tree)
    {
      SVN_ERR (svn_fs_revision_root (&base_root, c->fs, base_rev_id, pool));
      SVN_ERR (print_diff_tree 
               (root, base_root, tree, svn_stringbuf_create ("", pool), pool));
      apr_dir_remove_recursively (SVNLOOK_TMPDIR, pool);
    }
  return SVN_NO_ERROR;
}


/* Print the diff between revision 0 and our our root. */
static svn_error_t *
do_tree (svnlook_ctxt_t *c, svn_boolean_t show_ids, apr_pool_t *pool)
{
  svn_fs_root_t *root;
  svn_repos_node_t *tree;

  SVN_ERR (get_root (&root, c, pool));
  SVN_ERR (generate_delta_tree (&tree, c->repos, root, 0, pool)); 
  if (tree)
    {
      if (show_ids)
        {
          print_ids_tree (tree, root, 
                          svn_stringbuf_create ("", pool), 0, pool);
        }
      else
        {
          print_tree (tree, 0);
        }
    }

  return SVN_NO_ERROR;
}


/* Print author, date, log-size, and log associated with the given
   revision or transaction. */
static svn_error_t *
do_info (svnlook_ctxt_t *c, apr_pool_t *pool)
{
  SVN_ERR (do_author (c, pool));
  SVN_ERR (do_date (c, pool));
  SVN_ERR (do_log (c, TRUE, pool));
  return SVN_NO_ERROR;
}


/* Print author, date, log-size, log, and the tree associated with the
   given revision or transaction. */
static svn_error_t *
do_default (svnlook_ctxt_t *c, apr_pool_t *pool)
{
  SVN_ERR (do_info (c,pool));
  SVN_ERR (do_tree (c, FALSE, pool));
  return SVN_NO_ERROR;
}


/*** Argument parsing and usage. ***/
static void
do_usage (const char *progname, int exit_code)
{
  fprintf
    (exit_code ? stderr : stdout,
     "usage: %s REPOS_PATH rev REV [COMMAND] - inspect revision REV\n"
     "       %s REPOS_PATH txn TXN [COMMAND] - inspect transaction TXN\n"
     "       %s REPOS_PATH [COMMAND] - inspect the youngest revision\n"
     "\n"
     "REV is a revision number > 0.\n"
     "TXN is a transaction name.\n"
     "\n"
     "If no command is given, the default output (which is the same as\n"
     "running the subcommands `info' then `tree') will be printed.\n"
     "\n"
     "COMMAND can be one of: \n"
     "\n"
     "   author:        print author.\n"
     "   changed:       print full change summary: all dirs & files changed.\n"
     "   date:          print the timestamp (revisions only).\n"
     "   diff:          print GNU-style diffs of changed files and props.\n"
     "   dirs-changed:  print changed directories.\n"
     "   ids:           print the tree, with nodes ids.\n"
     "   info:          print the author, data, log_size, and log message.\n"
     "   log:           print log message.\n"
     "   tree:          print the tree.\n"
     "\n",
     progname,
     progname,
     progname);

  exit (exit_code);
}


/*** Main. ***/

#define INT_ERR(expr)                              \
  do {                                             \
    svn_error_t *svn_err__temp = (expr);           \
    if (svn_err__temp) {                           \
      svn_handle_error (svn_err__temp, stderr, 0); \
      goto cleanup; }                              \
  } while (0)


int
main (int argc, const char * const *argv)
{
  apr_pool_t *pool;
  const char *repos_path = NULL;
  int cmd_offset = 4;
  svnlook_cmd_t command;
  svnlook_ctxt_t c;

  /* Initialize context variable. */
  c.fs = NULL;
  c.rev_id = SVN_INVALID_REVNUM;
  c.is_revision = FALSE;
  c.txn = NULL;

  /* We require at least 1 arguments. */
  if (argc < 2)
    {
      do_usage (argv[0], 1);
      return EXIT_FAILURE;
    }

  /* Argument 1 is the repository path. */
  repos_path = argv[1];

  /* Argument 2 could be "rev" or "txn".  If "rev", Argument 3 is a
     numerical revision number.  If "txn", Argument 3 is a transaction
     name string.  If neither, this is an inspection of the youngest
     revision.  */
  if (argc > 3)
    {
      if (! strcmp (argv[2], "txn")) /* transaction */
        {
          c.is_revision = FALSE;
          c.txn_name = (char *)argv[3];
        }
      else if (! strcmp (argv[2], "rev")) /* revision */
        {
          c.is_revision = TRUE;
          c.rev_id = SVN_STR_TO_REV (argv[3]);
          if (c.rev_id < 1)
            {
              do_usage (argv[0], 1);
              return EXIT_FAILURE;
            }
        }
      else
        {
          c.is_revision = TRUE;
          cmd_offset = 2;
        }
    }
  else
    {
      c.is_revision = TRUE;
      cmd_offset = 2;
    }

  /* If there is a subcommand, parse it. */
  if (argc > cmd_offset)
    {
      if (! strcmp (argv[cmd_offset], "author"))
        command = svnlook_cmd_author;
      else if (! strcmp (argv[cmd_offset], "changed"))
        command = svnlook_cmd_changed;
      else if (! strcmp (argv[cmd_offset], "date"))
        command = svnlook_cmd_date;
      else if (! strcmp (argv[cmd_offset], "diff"))
        command = svnlook_cmd_diff;
      else if (! strcmp (argv[cmd_offset], "dirs-changed"))
        command = svnlook_cmd_dirs_changed;
      else if (! strcmp (argv[cmd_offset], "ids"))
        command = svnlook_cmd_ids;
      else if (! strcmp (argv[cmd_offset], "info"))
        command = svnlook_cmd_info;
      else if (! strcmp (argv[cmd_offset], "log"))
        command = svnlook_cmd_log;
      else if (! strcmp (argv[cmd_offset], "tree"))
        command = svnlook_cmd_tree;
      else
        {
          do_usage (argv[0], 2);
          return EXIT_FAILURE;
        }
    }
  else
    {
      command = svnlook_cmd_default;
    }

  /* Now, let's begin processing.  */

  /* Initialize APR and our top-level pool. */
  apr_initialize ();
  pool = svn_pool_create (NULL);

  /* Open the repository with the given path. */
  INT_ERR (svn_repos_open (&(c.repos), repos_path, pool));
  c.fs = svn_repos_fs (c.repos);

  /* If this is a transaction, open the transaction. */
  if (! c.is_revision)
    INT_ERR (svn_fs_open_txn (&(c.txn), c.fs, c.txn_name, pool));
 
  /* If this is a revision with an invalid revision number, just use
     the head revision. */
  if (c.is_revision && (! SVN_IS_VALID_REVNUM (c.rev_id)))
    INT_ERR (svn_fs_youngest_rev (&(c.rev_id), c.fs, pool));

  /* Now, out context variable is full of all the stuff we might need
     to know.  Get to work.  */
  switch (command)
    {
    case svnlook_cmd_author:
      INT_ERR (do_author (&c, pool));
      break;

    case svnlook_cmd_changed:
      INT_ERR (do_changed (&c, pool));
      break;

    case svnlook_cmd_date:
      INT_ERR (do_date (&c, pool));
      break;

    case svnlook_cmd_diff:
      INT_ERR (do_diff (&c, pool));
      break;

    case svnlook_cmd_dirs_changed:
      INT_ERR (do_dirs_changed (&c, pool));
      break;

    case svnlook_cmd_ids:
      INT_ERR (do_tree (&c, TRUE, pool));
      break;

    case svnlook_cmd_info:
      INT_ERR (do_info (&c, pool));
      break;

    case svnlook_cmd_log:
      INT_ERR (do_log (&c, FALSE, pool));
      break;

    case svnlook_cmd_tree:
      INT_ERR (do_tree (&c, FALSE, pool));
      break;

    case svnlook_cmd_default:
    default:
      INT_ERR (do_default (&c, pool));
      break;
    }

 cleanup:  /* Cleanup after ourselves. */
  if (c.txn && (! c.is_revision))
    svn_fs_close_txn (c.txn);

  if (c.repos)
    svn_repos_close (c.repos);

  svn_pool_destroy (pool);
  apr_terminate ();

  return EXIT_SUCCESS;
}


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