/*
** Copyright (c) 2007 D. Richard Hipp
**
** This program is free software; you can redistribute it and/or
** modify it under the terms of the Simplified BSD License (also
** known as the "2-Clause License" or "FreeBSD License".)

** This file contains code to implement the "info" command.  The
** "info" command gives command-line access to information about
** the current tree, or a particular artifact or check-in.
*/
#include "config.h"
#include "info.h"
#include <assert.h>

/*-----------------------------------------------------------------------------
** LOCAL DIFF CHANGES
**
** The goal is to show "(working) changes in the current checkout" in much the
** same way as the current "check-in" pages show the changes within a check-in.
**
** The page is on "/local" (no parameters needed; an alias of "/vinfo" and
** "/ci"), but at present there are no links to it within Fossil. Other changes:
** "/localpatch" produces a patch-set for all changes in the current checkout;
** "/localdiff" is an alias for "/fdiff" to show changes for an individual file;
** both "/file" and "/hexdump" have been extended to support local files.
**
** A number of points-of-query are labeld "TODO:LD". Most relate to these
** changes, although some are about existing code.
**
** In "checkin.c", the function "locate_unmanaged_files()" has been made
** non-static so that it can be called from here.
**-----------------------------------------------------------------------------
** Options to control the "local changes" changes. At present, these are
** defines: if these changes are adopted, some may want to be made into
** configuration options.
**
** INTEGER: Controls how many unmanaged files will be shown before the "plus xxx
** other matching files." line is shown (with an option to view all of them).*/
#define LOCAL_DIFF_MAX_EXTRAS       (5)
/*
** STRING: Controls whether the "extras" report is initially shown or hidden. A
** value of "0" hides the report; a value of "" (an empty string) will show it.
*/
#define LOCAL_DIFF_EXTRAS_MODE      ("")
/*
** BOOLEAN: Controls whether one or two passes are made through the list of
** changed files. In two-pass mode, all single-line differences are displayed
** ahead of all differences involving "diff-blocks", making them less likely to
** be overlooked. If disabled, only one pass is made, listing all changes in the
** order found. Possible TODO: Do the same for "normal" diffs. */
#define LOCAL_DIFF_USE_TWO_PASSES   (1)
/*
** BOOLEAN: Controls whether dividers ("<hr/>") added after any "diff-blocks"
** (except the last one)... IMHO doing so makes it easier to see where one block
** ends and the next starts. Possible TODO: Do the same for "normal" diffs. */
#define LOCAL_DIFF_ADD_DIVIDER      (1)
/*---------------------------------------------------------------------------*/

/*
** Return a string (in memory obtained from malloc) holding a
** comma-separated list of tags that apply to check-in with
** record-id rid.  If the "propagatingOnly" flag is true, then only
** show branch tags (tags that propagate to children).
**

         |TIMELINE_XMERGE
         |TIMELINE_CHPICK,
       0, 0, 0, rid, rid2, 0);
  db_finalize(&q);
}

/*
** Read the content of file zName (prepended with the checkout directory) and
** put it into the uninitialized blob, returning 1. The blob is zeroed if the
** file does not exist or cannot be accessed, in which case it returns 0.

*/
static int content_from_file(
  const char *zName,    /* Filename (relative to checkout) of file to be read */
  Blob *pBlob           /* Pointer to blob to receive contents */
){
  const char *zFullPath = mprintf("%s%s", g.zLocalRoot, zName);
  blob_zero(pBlob);
  if( file_size(zFullPath, ExtFILE)<0 ){
    return 0;
  }
  blob_read_from_file(pBlob, zFullPath, ExtFILE);
  return 1;
}

/*
** Append the difference between artifacts to the output
** If zLocal is not NULL, instead compare against the local
** copy of the file it names in the repository.
*/

  int isLink,           /* Is the file a symbolic link? */
  u64 diffFlags,        /* Flags for text_diff().  Zero to omit diffs */
  ReCompiled *pRe,      /* Only show diffs that match this regex, if not NULL */
  int pass              /* 0x01 - Display single-line entries only        */
                        /* 0x02 - Display entries with "diff blocks" only */
                        /* 0x03 - Display both                            */
){
#if LOCAL_DIFF_ADD_DIVIDER
  /* This remembers whether a side-by-side "diff-block" was shown the last
  ** time through. If it was, we will add "<hr/>" to better separate the
  ** blocks.

  */
  static int diffShownLastTime = 0;
#endif
  char *zFullName = mprintf("%s%s", g.zLocalRoot, zName);
  int isFilePresent = !file_access(zFullName, F_OK);
  /* Determing up-front whether we would be showing a "diff-block" so we can
  ** filter them according to which pass we are on: the first pass will show

                                           )
                 );
  /* We don't use 'diffFlags' in these tests so that whether "Hide diffs" is
  ** in effect or not, the order won't change.
  */
  if(  showDiff && (pass == 1) ){ return; } /* Don't do diff on pass 1 of 2 */
  if( !showDiff && (pass == 2) ){ return; } /* Don't do line on pass 2 of 2 */
#if LOCAL_DIFF_ADD_DIVIDER
  /* If a SBS diff-block was shown by the previous entry, add a divider */
  if( diffShownLastTime && (diffFlags & DIFF_SIDEBYSIDE) ){
    @ <hr/>
  }
  /* Record whether we will be showing a diff-block this time. We DO factor in
  ** 'diffFlags' here so that in "Hide diffs" mode, we don't get extra lines.
  */
  diffShownLastTime = showDiff && diffFlags;
#endif





  @ <p>
  if( !g.perm.Hyperlink ){
    if( isDeleted ){
      if( isFilePresent ){
        @ Deleted %h(zName) (still present as a local file).

      }else{
        @ Deleted %h(zName).
      }
    }else if( isNew ){
      if( isFilePresent ){
        @ Added %h(zName) but not committed.
      }else{
        @ Missing %h(zName) (was added to checkout).
      }
    }else switch( isChnged ){





      case 3:
        @ Added %h(zName) due to a merge.
        break;
      case 5:
        @ Added %h(zName) due to an integrate-merge.
        break;
      case 6:   append_status( "gained", "executable", zName, zOld);    break;

            @ Merge
            break;
          case 4:
            @ Integrate-merge
            break;
        }
        @ of %h(zName).

    }
    if( showDiff && diffFlags ){
      append_diff(zOld, NULL, zName, diffFlags, pRe);
    }
  }else{ /* With hyperlinks */
    if( isDeleted ){
      if( isFilePresent ){                    /* DELETEd but still on disk */
        @ Deleted %z(href("%R/finfo?name=%T&m=%!S",zName,zOld))%h(zName)</a>
        @ from %z(href("%R/artifact/%!S",zOld))[%S(zOld)]</a> (still present
        @ as %z(href("%R/file/%T?ci=ckout&annot=removed from checkout",zName))
        @ [local file]</a>).

      }else{                              /* DELETEd and deleted from disk */
        @ Deleted %z(href("%R/finfo?name=%T&m=%!S",zName,zOld))%h(zName)</a>
        @ from %z(href("%R/artifact/%!S",zOld))[%S(zOld)]</a>.
      }
    }else if( isNew ){
      if( isFilePresent ){                    /* ADDed and present on disk */
        @ Added %z(href("%R/file/%T?ci=ckout",zName))%h(zName)</a>
        @ but not committed.
      }else{                              /* ADDed but not present on disk */
        @ Missing %h(zName) (was added to checkout).
      }
    }else switch( isChnged ){

      case 3:                                          /* Added by a merge */
        @ Added
        @ %z(href("%R/file/%T?ci=ckout&annot=added by merge",zName))%h(zName)
        @ </a> to %z(href("%R/artifact/%!S",zOld))[%S(zOld)]</a> due to merge.
        break;
      case 5:                             /* Added by an integration merge */
        @ Added

            @ Integrate-merge
            break;
        }
        @ of %z(href("%R/finfo?name=%T&m=%!S",zName,zOld))%h(zName)</a>
        @ from %z(href("%R/artifact/%!S",zOld))[%S(zOld)]</a> to
        @ %z(href("%R/file/%T?ci=ckout&annot=edited locally",zName))
        @ [local file]</a>

    }
    if( showDiff ){
      if( diffFlags ){
        append_diff(zOld, NULL, zName, diffFlags, pRe);
      }else if( isChnged ){
        @ &nbsp;&nbsp;
        @ %z(href("%R/localdiff?name=%T&from=%!S",zName,zOld))[diff]</a>

  zCleanFlag = db_get("clean-glob", 0);   /* ...that "clean" clobbers */
  zKeepFlag = db_get("keep-glob", 0);     /* ...that "clean" won't touch */
  pIgnore = glob_create(zIgnoreFlag);     /* Object versions of above */
  pKeep = glob_create(zKeepFlag);
  pClean = glob_create(zCleanFlag);
  nRoot = (int)strlen(g.zLocalRoot);      /* Length of root component */
  Stmt q;
  Blob repo;                              /* TODO:LD May not be needed */
  int maxExtrasToShow = LOCAL_DIFF_MAX_EXTRAS;
  int extrasFlags = atoi(zExtra);         /* Which entries to show */
  int nExtras;
  int nMatch;
  int nShown;
  int nPlain;
  int nIgnore;
  int nClean;
  int nKeep;

  /*TODO:LD?
  ** It feels sensible to limit the number of "extra" entries shown by default
  ** for cases where "ignore-glob" or "clean-glob" haven't been fully setup.
  ** A minor irritation is that this can lead to "... plus 1 more file", on a
  ** line that COULD have been used to display the omitted file. If we knew in
  ** advance how many entries were going to match, we could temporarily "bump"
  ** the limit by one show all entries would be shown. However, to know the
  ** number of matches in advance we'd have to:
  ** a) Pre-scan SFILE, testing and counting matches against each glob-list,
  **    possibly bump the limit, then re-scan the table repeating the tests
  **    against each glob-list to decide which to show.
  ** b) SFILE could have an extra FLAGS field: during the pre-scan, this could
  **    be updated to indicate which groups each file belong to. This would
  **    save re-testing every file against each glob-list (the main pass could
  **    select "WHERE flags & selector" to get only the matching entries), but
  **    the updates (selecting by "pathname" each time) could be a bit much.
  ** c) vfile_scan() -- where SFILE is populated -- COULD have an option to
  **    do the testing at the time entries are added. This would be the "best"
  **    way, but feels too much disruption to other code for what is only a
  **    minor benefit.
  ** For now, I'll stick with the minor annoyance of "plus 1 more file" :-)
  **
  ** Being able to determine the counts up-front would also allow us to hide
  ** the whole "extras report" if there were no unmanaged files.
  **
  **TODO:LD?
  ** Does it make sense (and/or is it practiable) to offer an "ADD" button
  ** against files that are unmanaged?
  **
  **TODO:LD?
  ** Does it make sense (and/or ...) to offer ediing of the various blob-lists
  ** from the Extras report? Showing the existing configuration screen would
  ** probably not be a problem (permissions permitting), but what happens if
  ** those settings have been overriden by .fossil-settings/ignore-glob? As we
  ** have access to the local checkout, is it feasible to edit it in the browser
  ** (perhaps piggy-backing /fileedit)?
  */

  locate_unmanaged_files(0, NULL, 0, NULL);   /* Get all unmanaged */
  /*TODO:LD
  ** The first two of these exclusions come from clean_cmd() in checkin.c.
  ** Not sure exactly what they are intended to do (seem to have no effect on
  ** my test repos). Last exclusion is an alternative to the WHERE clause above
  ** so that COUNT(*) returns the correct value. TODO Even though, as noted
  ** above, getting the count ahead of time is of little use (it was used to
  ** bump the display limit if only one entry would be omitted), I'll probably
  ** retain omitting the WHERE, and using DELETE FROM to exclude reserved
  ** names, just in case (c) above were to be implemented.
  */
  /*TODO:LD deletions from clean_cmd() */
  if( file_tree_name(g.zRepositoryName, &repo, 0, 0) ){
    db_multi_exec("DELETE FROM sfile WHERE pathname=%B", &repo);
  }
  db_multi_exec("DELETE FROM sfile WHERE pathname IN"
                " (SELECT pathname FROM vfile)");
  /*TODO:LD Delete reserved names, rather than WHERE them out. */
  db_multi_exec("DELETE FROM sfile WHERE pathname IN (%s)",
                fossil_all_reserved_names(0));

  /*TODO:LD
  ** If we had a count of matching entries before scanning, this is where
  ** we'd bump the maximum to show so as to avoid "plus 1 file".
  ** ...
  ** If there's only one more than the maximum, let it through...
  ** a line used to say "plus 1 more" may as well display that item!
  if( nExtras == maxExtrasToShow+1 ){ maxExtrasToShow++; }
  ** ...
  */

  /* Handle the special case where zExtra was empty (and got converted to zero).
  ** If so, show "plain" files (those not matching any glob-list) but with an
  ** upper limit to the number shown (set above). If a value WAS given (i.e.
  ** after following a link), display all of the selected entries. */

  if( extrasFlags==0 ){
    extrasFlags = EX_PLAIN;
  }else{
    maxExtrasToShow = 0x7fffffff; /* Basically, all of them... */
  }

  /* Describe the files listed. Currently, the only "built-in" options are to

  }else{
    Blob desc;
    blob_zero(&desc);
    if( extrasFlags & EX_PLAIN  ){ blob_appendf(&desc, " + unmanaged"    ); }
    if( extrasFlags & EX_IGNORE ){ blob_appendf(&desc, " + ignored"      ); }
    if( extrasFlags & EX_CLEAN  ){ blob_appendf(&desc, " + to be cleaned"); }
    if( extrasFlags & EX_KEEP   ){ blob_appendf(&desc, " + to be kept"   ); }
    if( blob_size(&desc) > 3 ){         /* Should never fail... */
      /* Add the string built above, skipping the leading " + " */
      @ (%h(blob_str(&desc)+3))
    }
    blob_reset(&desc);
  }
  @ </b></p>

  db_prepare(&q,
      "SELECT %Q || pathname FROM sfile"
      " ORDER BY 1",  /*TODO:LD Order by pathname, as for differences? */
      g.zLocalRoot
  );
  /*
  ** Put the file-list in one paragraph with line-breaks between.
  **TODO:LD
  ** Might a table (with columns for name, ignore/clean/keep) work?
  */
  @ <p>
  nExtras = nMatch = nShown = nPlain = nKeep = nClean = nIgnore = 0;
  while( db_step(&q)==SQLITE_ROW ){
    const char *zName = db_column_text(&q, 0);
    int entryFlags = 0

  ** "1" would list ALL unmanaged files without limiting their number).
  **
  ** If the "ef=" isn't present (as when first navigating to "/local") then a
  ** default setting is used. Set to "0" to initially hide the report.
  */
  zExtra = P("ef");
  if( zExtra==NULL ) {
    zExtra = LOCAL_DIFF_EXTRAS_MODE;
  }
  showExtras = strcmp(zExtra,"0")!=0;

  /* Local mode is selected by either "/local" or with a "name" of "ckout".
  ** First, check we have access to the checkout (and report to the user if we
  ** don't), then refresh the "vfile" table (recording which files in the
  ** checkout have changed etc.). We then change the "name" parameter to "tip"
  ** so that the "header" section displays info about the check-in that the
  ** checkout came from.
  **TODO:LD
  ** It would probably make sense to limit "/local" (and other links that come
  ** from it) to only be permitted when Fossil is running locally in "ui" mode.
  ** It's probably not critical when all you can do is view files in the
  ** checkout (they can already see the checked-in versions), but if a COMMIT
  ** option WERE ever to be implemented, you wouldn't essentially random people
  ** on the internet firing off commits!
  */
  bLocalMode = (g.zPath[0]=='l') || (fossil_strcmp(zName,"ckout")==0);
  if( bLocalMode ){
    vid = g.localOpen ? db_lget_int("checkout", 0) : 0;
    if( vid==0 ){
      /*TODO:LD Is this the right response? */
      style_header("No Local Checkout");
      @ No access to local checkout.
      style_footer();
      return;
    }
    vfile_check_signature(vid, CKSIG_ENOTFILE);
    zName = "tip";

  }
  if( bLocalMode ){
    if( showExtras ){
      @ %z(chref("button","%R/local?diff=%d%s&ef=0",diffType,zW))Hide Extras</a>
    }else{
      @ %z(chref("button","%R/local?diff=%d%s&ef=",diffType,zW))Show Extras</a>
    }
    /*TODO:LD
    ** There would be a fair chunk of stuff to get right (not least appropriate
    ** restrictions), but it MIGHT be nice to have a COMMIT button here...
    */
  }
  @</div>
  if( pRe ){
    @ <p><b>Only differences that match regular expression "%h(zRe)"
    @ are shown.</b></p>
  }
  if( bLocalMode ){
    if( showExtras ){
      append_extras_report(zExtra, diffType, zW);
    }
    /* Following SQL taken from diff_against_disk() in diffcmd.c */
    /*TODO:LD
    ** That code wrapped the query/processing in a transaction (but, from
    ** memory, other similar uses did not). Is it neeeded?
    */
    db_begin_transaction();
    db_prepare(&q3,
      "SELECT pathname, deleted, chnged , rid==0, rid, islink"
      "  FROM vfile"

    ** differences. If enabled, the first pass will only show one-line entries
    ** and the second pass will only show those with diff-blocks. This has the
    ** side-effect of altering the order entries are shown in (but within each
    ** group the original order is maintained).
    **
    ** If disabled, (pass gets set to 3), only one pass is made on which all
    ** entries are shown in their "normal" order.
    **TODO:LD
    ** Add this to the original (non-local) loop?
    */



    int pass = LOCAL_DIFF_USE_TWO_PASSES?1:3;
    int anyDifferences = 0;
    do{
      while( db_step(&q3)==SQLITE_ROW ){
        const char *zPathname = db_column_text(&q3,0);
        int isDeleted = db_column_int(&q3, 1);
        int isChnged = db_column_int(&q3,2);
        int isNew = db_column_int(&q3,3);
        int srcid = db_column_int(&q3, 4);
        int isLink = db_column_int(&q3, 5);
        char *zUuid = db_text(0, "SELECT uuid FROM blob WHERE rid=%d", srcid);
        append_local_file_change_line( zPathname, zUuid,
                      isDeleted, isChnged, isNew, isLink, diffFlags,pRe,pass );
        free(zUuid);
        anyDifferences = 1;
      }
      db_reset(&q3);
    }while( ++pass < 3 ); /* Either "1, 2, stop" or "3, stop". */
    if( !anyDifferences ){
      @ <p>No changes in the local checkout.</p>
    }
    db_finalize(&q3);
    db_end_transaction(1);  /* ROLLBACK */
  }else{ /* Normal, non-local-mode: show diffs against parent */
    /*TODO:LD: Implement the optional two-pass code? */
    db_prepare(&q3,
      "SELECT name,"
      "       mperm,"
      "       (SELECT uuid FROM blob WHERE rid=mlink.pid),"
      "       (SELECT uuid FROM blob WHERE rid=mlink.fid),"
      "       (SELECT name FROM filename WHERE filename.fnid=mlink.pfnid)"
      "  FROM mlink JOIN filename ON filename.fnid=mlink.fnid"

  int vid;

  login_check_credentials();
  if( !g.perm.Read ){ login_needed(g.anon.Read); return; }

  vid = g.localOpen ? db_lget_int("checkout", 0) : 0;
  if( vid==0 ){
    /*TODO:LD Is this the right response? */
    style_header("No Local Checkout");
    @ No access to local checkout.
    style_footer();
    return;
  }
  vfile_check_signature(vid, CKSIG_ENOTFILE);

  cgi_set_content_type("text/plain");

  db_begin_transaction();
  /*TODO:LD
  ** This query is the same as in ci_page() for local-mode (as well as in
  ** diff_against_disk() in diffcmd.c, where it was originally taken from).
  ** Should they be "coalesced" in some way?
  */
  db_prepare(&q3,
    "SELECT pathname, deleted, chnged , rid==0, rid, islink"
    "  FROM vfile"

  if( diffType!=1 ){
    style_submenu_element("Unified Diff",
                          "%R/vdiff?%s&diff=1%s%T%s",
                          zQuery,
                          zGlob ? "&glob=" : "", zGlob ? zGlob : "", zW);
  }
  if( zBranch==0 ){
    //TODO:LD Is there an extra "&" here?
    style_submenu_element("Invert",
                          "%R/vdiff?from=%T&to=%T&%s%T%s", zTo, zFrom,
                          zGlob ? "&glob=" : "", zGlob ? zGlob : "", zW);
  }
  if( zGlob ){
    //TODO:LD Is there an extra "&" here?
    style_submenu_element("Clear glob",
                          "%R/vdiff?%s&%s", zQuery, zW);
  }else{
    style_submenu_element("Patch", "%R/vpatch?from=%T&to=%T%s", zFrom, zTo, zW);
  }
  if( diffType!=0 ){
    style_submenu_checkbox("w", "Ignore Whitespace", 0, 0);

              g.zTop, zUuid);
      }else{
        style_submenu_element("Shun", "%s/shun?shun=%s#addshun", g.zTop, zUuid);
      }
    }
  }
  style_header("Hex Artifact Content");
  /*TODO:LD
  ** Could the call to style_header() be moved so these two exclusion
  ** blocks could be merged? I don't think any of them make sense for
  ** a local file.
  */
  if( !bLocalMode ){
    zUuid = db_text("?","SELECT uuid FROM blob WHERE rid=%d", rid);
    @ <h2>Artifact

  if( bLocalMode ){
      content_from_file(zLocalName, &content);
  }else{
    content_get(rid, &content);
  }
  @ <blockquote><pre>
  hexdump(&content);
  /* TODO:LD: Should content (and downloadName?) be reset/freed? */
  @ </pre></blockquote>
  style_footer();
}

/*
** Look for "ci" and "filename" query parameters.  If found, try to
** use them to extract the record ID of an artifact for the file.

    /* If there is no ci= query parameter, then prefer to interpret
    ** name= as a hash for /artifact and /whatis.  But for not for /file.
    ** For /file, a name= without a ci= while prefer to use the default
    ** "tip" value for ci=. */
    rid = name_to_rid(zName);
  }
  if( fossil_strcmp(zCI,"ckout")==0 ){
    /* "ci=ckout" is an extension for viewing files in the local checkout. */
    bLocalMode = 1;
    rid = -1;     /* Dummy value to make it look found */
  }else if( rid==0 ){
    rid = artifact_from_ci_and_filename(0);
  }

  if( rid==0 ){  /* Artifact not found */

    objdescFlags |= OBJDESC_DETAIL;
  }
  zUuid = db_text("?", "SELECT uuid FROM blob WHERE rid=%d", rid);

  asText = P("txt")!=0;
  if( isFile ){
    if( bLocalMode ){
      /*TODO:LD
      ** Is this the best way of handling annotations to the description?
      ** If "annot=message" is part of the URL, the message is appended
      ** to the description of the file. Only used for "local" files to
      ** distinguish such files from part of the repository.
      */
      const char *annot = P("annot");
      @ <h2>File %z(href("%R/finfo?name=%T&m=tip",zName))%h(zName)</a>

    style_submenu_element("Parsed", "%R/info/%s", zUuid);
  }
  if( descOnly ){
    style_submenu_element("Content", "%R/artifact/%s", zUuid);
  }else{
    @ <hr />
    if( bLocalMode ){








      if( !content_from_file(zName, &content) ){
        fossil_warning("Cannot find/access %s.", zName);
      }
    }else{
      content_get(rid, &content);
    }
    if( renderAsWiki ){
      wiki_render_by_mimetype(&content, zMime);
    }else if( renderAsHtml ){
      @ <iframe src="%R/raw/%s(zUuid)"