/*
 *  AstroVersion.java
 *  $URL: svn://svn/open/trunk/www/astroVersion/WEB-INF/src/ca/bc/webarts/widgets/AstroVersion.java $
 *  $Revision: 576 $
 *  $LastChangedDate: 2012-11-18 16:30:11 -0800 (Sun, 18 Nov 2012) $
 *  $LastChangedBy: tgutwin $
 *  Copyright (c) 2005-2012 Tom B. Gutwin P.Eng.
 *  http://www.webarts.bc.ca
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version 2
 *  of the License, or any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
package ca.bc.webarts.widgets;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
import org.tmatesoft.svn.core.io.ISVNLogEntryHandler;
import org.tmatesoft.svn.core.ISVNWorkspace;
import org.tmatesoft.svn.core.io.SVNDirEntry;
import org.tmatesoft.svn.core.io.SVNException;
import org.tmatesoft.svn.core.io.SVNLogEntry;
import org.tmatesoft.svn.core.io.SVNNodeKind;
import org.tmatesoft.svn.core.io.SVNURL;
import org.tmatesoft.svn.core.SVNWorkspaceManager;
import org.tmatesoft.svn.core.diff.*;
import org.tmatesoft.svn.core.internal.io.dav.DAVRepositoryFactory;
import org.tmatesoft.svn.core.internal.io.svn.SVNRepositoryFactoryImpl;
import org.tmatesoft.svn.core.internal.io.fs.FSRepositoryFactory;
import org.tmatesoft.svn.core.io.*;
import org.tmatesoft.svn.core.io.SVNFileRevision;
import org.tmatesoft.svn.core.io.SVNRepository;
import org.tmatesoft.svn.core.io.SVNRepositoryLocation;
import org.tmatesoft.svn.core.io.diff.SVNDiffWindow;
import org.tmatesoft.svn.util.PathUtil;
import org.tmatesoft.svn.util.SVNUtil;
import org.tigris.subversion.javahl.ClientException;
import org.tigris.subversion.javahl.Revision;
import org.tigris.subversion.javahl.SVNClient;

import bmsi.util.Diff;
import bmsi.util.DiffPrint;



/**
 *  This is a helper bean for the astroVersion webapp. The web app is a web
 *  viewer for Subversion repositories and is written entirely in
 *  Java/JSP/Servlets. <br>
 *  This class acts as a helper to the jsps for the web app and performs SVN
 *  lookup functionality to remove the grunt-work from the JSP pages. It uses
 *  the JavaSVN library for doing its SVN access. <br>
 *  <br>
 *  Copyright (c) 2005-2012 Tom B. Gutwin P.Eng.<br>
 *  <img src="http://www.webarts.bc.ca/webArts/images/tbgEmail.png"
 *       alt="tbg email address"><br>
 *  <a href="http://www.webarts.bc.ca">http://www.webarts.bc.ca</a> <br>
 *  <a href="http://svn.webarts.bc.ca">http://svn.webarts.bc.ca</a> <br>
 *
 *
 * @author    tgutwin
 */
public class AstroVersion
{
  /**  Class holder for the currently used repo location object. */
  SVNRepositoryLocation location_ = null;
  /**  Class holder for the currently used repo location object. */
  SVNRepository repository_ = null;
  ISVNWorkspace workspace_ = null;
  SVNURL svnURL_ = null;

  /**  Class flag keeping track if the repo has been setup for use. */
  boolean repoIsInit_ = false;
  /**  Class holder for file revision log information that needs to be shared
       with internal private classes. */
  TreeMap revLogHashTree_ = new TreeMap();
  /**  Class holder for file revision information that needs to be shared
       with internal private classes. */
  //TreeMap fileRevHashTree_ = new TreeMap();


  /**
   *  Setup the SVN Repository objects as required by the JavaSVN Library.
   *
   * @param  repository        The String representation of the URL for the
   *                           repository to access.
   * @exception  SVNException  Thrown if issues with the spec'd repo.
   */
  public void initRepo( String repository )
    throws SVNException
  {
    if ( !repoIsInit_ )
    {
      // for DAV (over http and https)
      DAVRepositoryFactory.setup();
      // for SVN (over svn and svn+ssh)
      SVNRepositoryFactoryImpl.setup();
      // Working copy storage (default is file system).
      FSRepositoryFactory.setup();
      svnURL_ = SVNURL.parseURIDecoded(repository);

      repoIsInit_ = true;
    }
    repository_ = SVNRepositoryFactory.create( svnURL_ );

  }


  /**
   *  Retrieves the file from the repo and returns it as a String. It can be
   *  used to return a text based file for viewing. The parameters describe the
   *  file, revision, and location in the repo to retrieve.
   *
   * @param  repo      The repo to use for the retrieval
   * @param  filePath  The repo sub path (including the filename) to get the
   *                   file from.
   * @param  rev       The revision number to retrieve.
   * @return           The fileContents as a String
   */
  public String getFileContents( String repo, String filePath, String rev )
  {
    String retVal = null;
    try
    {
      initRepo( repo );
      long revision = ISVNWorkspace.HEAD;
      try
      {
        revision = Long.parseLong( rev.trim() );
      }
      catch ( java.lang.NumberFormatException numEx )
      {
        revision = ISVNWorkspace.HEAD;
      }
      retVal = cat( filePath, revision );
    }
    catch ( SVNException e )
    {
      e.printStackTrace();
    }
    return retVal;
  }


  /**
   *  Retrieves the file from the repo and returns it as bytes. It can be
   *  used to return the raw bytes of a file. The parameters describe the
   *  file, revision, and location in the repo to retrieve.
   *
   * @param  repo      The repo to use for the retrieval
   * @param  filePath  The repo sub path (including the filename) to get the
   *                   file from.
   * @param  rev       The revision number to retrieve.
   * @return           The fileContents as a an array of bytes
   */
  public byte[] getFileBytes( String repo, String filePath, String rev )
  {
    byte[] retVal = null;
    try
    {
      initRepo( repo );
      long revision = ISVNWorkspace.HEAD;
      try
      {
        revision = Long.parseLong( rev.trim() );
      }
      catch ( java.lang.NumberFormatException numEx )
      {
        revision = ISVNWorkspace.HEAD;
      }
      retVal = catBytes( filePath, revision );
    }
    catch ( SVNException e )
    {
      e.printStackTrace();
    }
    return retVal;
  }


  /**
   *  Retrieves the file from the repo and returns it as bytes. It can be
   *  used to return the raw bytes of a file. The parameters describe the
   *  file, revision, and location in the repo to retrieve.
   *
   * @param  repo      The repo to use for the retrieval
   * @param  filePath  The repo sub path (including the filename) to get the
   *                   file from.
   * @param  rev       The revision number to retrieve.
   * @return           The fileContents as a an array of bytes
   * @throws           If one of the rev numbers is invalid (ie negative)
   */
  public byte[] getFileDiffBytes( String repo, String filePath, String rev , String rev2 )
    throws IllegalArgumentException, ClientException
  {
    byte[] retVal = null;
    String tmp = getFileDiff(repo, filePath, rev , rev2);
    if ( tmp!=null)
      retVal = tmp.getBytes();
    return retVal;
  }


  /**
   *  Retrieves the file from the repo and returns it as bytes. It can be
   *  used to return the raw bytes of a file. The parameters describe the
   *  file, revision, and location in the repo to retrieve.
   *
   * @param  repo      The repo to use for the retrieval
   * @param  filePath  The repo sub path (including the filename) to get the
   *                   file from.
   * @param  rev       The revision number to retrieve.
   * @return           The fileContents as a an array of bytes
   * @throws           If one of the rev numbers is invalid (ie negative)
   */
  public String getFileDiff( String repo, String filePath,
                                String rev , String rev2 )
  {
    String retVal = null;
    String rev1Str = null;
    String rev2Str = null;
    /*
       style can be:
         'n' for normal style
         'e' for ed editor style
         'c' for  context style
         'u' for unified style
    */
    char style = 'n';
    boolean reverse = style == 'e';
    StringWriter strOutWriter = new StringWriter();
    rev1Str = getFileContents(repo, filePath, rev);
    rev2Str = getFileContents(repo, filePath, rev2);
    String [] rev1Lines = rev1Str.split("[\r\n]");
    String [] rev2Lines = rev2Str.split("[\r\n]");

    // on with the diff
    Diff diff = new Diff(rev1Lines,rev2Lines);
    Diff.change script = diff.diff_2( reverse );
    if ( script == null )
    {
      strOutWriter.write("No differences\n");
      //System.err.println( "No differences" );
    }
    else
    {
      DiffPrint.Base p;
      switch ( style )
      {
        case 'e':
          p = new DiffPrint.EdPrint( rev1Lines,rev2Lines);
          break;
        case 'c':
          p = new DiffPrint.ContextPrint( rev1Lines,rev2Lines );
          break;
        case 'u':
          p = new DiffPrint.UnifiedPrint( rev1Lines,rev2Lines );
          break;
        default:
          p = new DiffPrint.NormalPrint( rev1Lines,rev2Lines );
      }
      p.setOutput(strOutWriter);
      //p.print_header( filePath+" rev:"+rev, filePath+" rev:"+rev2 );
      p.print_script( script );
    }

    return strOutWriter.toString();
  }


    /**
   *  Retrieves the file from the repo and returns it as bytes. It can be
   *  used to return the raw bytes of a file. The parameters describe the
   *  file, revision, and location in the repo to retrieve.
   *
   * @param  repo      The repo to use for the retrieval
   * @param  filePath  The repo sub path (including the filename) to get the
   *                   file from.
   * @param  rev       The revision number to retrieve.
   * @return           The fileContents as a an array of bytes
   * @throws           If one of the rev numbers is invalid (ie negative)
   */
  public String getSvnFileDiff( String repo, String filePath, String rev , String rev2 )
throws IllegalArgumentException, ClientException
  {
    String retVal = null;
    try
    {
      initRepo( repo );
      long revision = ISVNWorkspace.HEAD;
      long revision2 = ISVNWorkspace.HEAD;
      try
      {
        revision = Long.parseLong( rev.trim() );
        revision2 = Long.parseLong( rev2.trim() );
        SVNClient svnClient = new SVNClient();
        StringWriter strOutWriter = new StringWriter();
        Revision.Number revNumber = new Revision.Number(revision);
        Revision.Number revNumber2 = new Revision.Number(revision2);
        System.out.println("Calling svnClient.diff");
        //diff(java.lang.String,org.tigris.subversion.javahl.Revision,
        //     java.lang.String,org.tigris.subversion.javahl.Revision,java.lang.String,boolean)
        //svnClient.diff("/tmp/svn",filePath,revNumber,revNumber2,strOutWriter);
        retVal = svnClient.toString();
      }
      catch ( java.lang.NumberFormatException numEx )
      {
        revision = ISVNWorkspace.HEAD;
        revision2 = ISVNWorkspace.HEAD;
      }
      //retVal = catBytes( filePath, revision );
    }
    catch ( SVNException e )
    {
      e.printStackTrace();
    }
    return retVal;
  }


  /**
   *  Provides basic URL encoding of a String. It simply does some char
   *  replacements... changes &lt; to &amp;lt;  and &gt; to &amp;gt; as well as
   *  others.
   *
   * @param  bytes  A String to do the conversion.
   * @return        The URL encoded string.
   */
  public String encodeString( String bytes )
  {
    String retVal = "";
    for ( int i = 0; i < bytes.length(); i++ )
    {
      char ch = bytes.charAt( i );

      if ( ch == '<' )
      {
        retVal += "&lt;";
      }
      else if ( ch == '>' )
      {
        retVal += "&gt;";
      }
      else if ( ch == '&' )
      {
        retVal += "&amp;";
      }
      else
      {
        retVal += ch;
      }
    }
    return retVal;
  }


  /**
   *  Gets the fileRevision log for a file revision from the SVNRevisionProperty log.
   *
   * @param  rev       the rev to get the log entry for
   * @return           The fileRevisionEntries value
   */
  public String getRevisionPropertyValue( SVNFileRevision rev, String propertyName)
      throws SVNException
  {
    String retVal = "";

    if (rev != null)
    {

      Map properties = rev.getRevisionProperties().asMap();
      if (false)
      {
        Object [] keys = properties.keySet().toArray();
        for (int i = 0; i < properties.size(); i++)
        {
          //System.out.println(""+rev.getRevision()+" RevProp "+keys[i]+"="+properties.get(keys[i]));
          if ((keys[i].toString()).trim().equals(propertyName))
          {
            retVal = properties.get(keys[i]).toString();
            System.out.println("!!!!");
          }
        }
      }
      if (properties.containsKey(propertyName))
      {
        //System.out.println(""+rev.getRevision()+" RevProp "+propertyName+"="+properties.get(propertyName));
        retVal = properties.get(propertyName).toString();
      }
    }
    return retVal;
  }


  /**
   *  Convienience method to get the fileRevision log for a file revision from the
   *  SVNRevisionProperties. It simply calls getRevisionPropertyValue with the
   *  propertyName 'log'.
   *
   * @param  rev       the rev to get the log entry for
   * @return           The fileRevisionEntries value
   */
  public String getFileRevisionLog( SVNFileRevision rev )
  {
    String retVal = "";
    try
    {
      retVal = getRevisionPropertyValue(rev, "svn:"+"log");
    }
    catch (SVNException svnEx)
    {

    }
    return retVal;
  }


  /**
   *  Convienience method to get the fileRevision date for a file revision from the
   *  SVNRevisionProperties. It simply calls getRevisionPropertyValue with the
   *  propertyName 'date'.
   *
   * @param  rev       the rev to get the log entry for
   * @return           The fileRevisionEntries value
   */
  public String getFileRevisionDate( SVNFileRevision rev )
  {
    String retVal = "";
    try
    {
      retVal = getRevisionPropertyValue(rev, "svn:"+"date");
    }
    catch (SVNException svnEx)
    {

    }
    return retVal;
  }


  /**
   *  Convienience method to get the fileRevision author for a file revision from the
   *  SVNRevisionProperties. It simply calls getRevisionPropertyValue with the
   *  propertyName 'author'.
   *
   * @param  rev       the rev to get the log entry for
   * @return           The fileRevisionEntries value
   */
  public String getFileRevisionAuthor( SVNFileRevision rev )
  {
    String retVal = "";
    try
    {
      retVal = getRevisionPropertyValue(rev, "svn:"+"author");
    }
    catch (SVNException svnEx)
    {

    }
    return retVal;
  }


  /**
   *  Gets the fileRevisionEntries for a file in a sorted TreeMap and puts it in the class.
   *
   * @param  repo      the repo to query
   * @param  filePath  the file to get
   * @return           The fileRevisionEntries value
   */
  public TreeMap getFileRevisionEntries( String repo, String filePath )
  {
    FileRevHandler fileRevHandler = new FileRevHandler();
    try
    {
      initRepo( repo );
      long latestRevision = repository_.getLatestRevision();
      repository_.getFileRevisions( filePath, 0, latestRevision, fileRevHandler  );
    }
    catch ( SVNException e )
    {
      //e.printStackTrace();
      try
      {
        repoIsInit_ = false;
        initRepo( repo );
        long latestRevision = repository_.getLatestRevision();
        repository_.getFileRevisions( filePath, 0, latestRevision, fileRevHandler  );
      }
      catch ( SVNException e2 )
      {
        e2.printStackTrace();
      }
    }
    return fileRevHandler.getFileRevHashTree();
  }


  /**
   *  Gets the file Log Entries for a file in a sorted TreeMap.
   *
   * @param  repo      the repo to query
   * @param  filePath  the file to get
   * @return           The log Entries
   */
  public TreeMap getFileLogEntries( String repo, String filePath )
  {
    try
    {
      initRepo( repo );
      String[] targetPaths = {filePath};
      long latestRevision = repository_.getLatestRevision();
      revLogHashTree_ = new TreeMap();
      repository_.log( targetPaths, 0L, latestRevision, true, true, new RevLogHandler() );
    }
    catch ( SVNException e )
    {
      e.printStackTrace();
    }
    return revLogHashTree_;
  }


  /**
   *  Internal helper method to do a cat on a repo file and return it as a
   *  String.
   *
   * @param  path              The file path to get the cat
   * @param  revNumber         the rev to get
   * @return                   Description of the Return Value
   * @exception  SVNException  Description of the Exception
   */
  private String cat( String path, long revNumber )
    throws SVNException
  {
    return new String( catBytes( path, revNumber ) );
  }


  /**
   *  Internal helper method to do a cat on a repo file and return it as raw
   *  bytes.
   *
   * @param  path              Description of the Parameter
   * @param  revNumber         Description of the Parameter
   * @return                   Description of the Return Value
   * @exception  SVNException  Description of the Exception
   */
  private byte[] catBytes( String path, long revNumber )
    throws SVNException
  {
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    repository_.getFile( path, revNumber, null, bos );
    return bos.toByteArray();
  }



  /**
   *  This Method Returns the right MIME type for a particular format <p>
   *
   *
   *
   * @param  format  Description of the Parameter
   * @return         String MIMEtype
   */
  public static String getMimeType( String format )
  {
    if ( format.equalsIgnoreCase( "pdf" ) )
    {//check the out type
      return "application/pdf";
    }
    else if ( format.equalsIgnoreCase( "audio_basic" ) ||
              format.toLowerCase().endsWith("au") )
    {
      return "audio/basic";
    }
    else if ( format.equalsIgnoreCase( "audio_wav" ) ||
              format.toLowerCase().endsWith("wav") )
    {
      return "audio/wav";
    }
    else if ( format.equalsIgnoreCase( "audio_vorbis" ) ||
              format.toLowerCase().endsWith("ogg") )
    {
      return "application/x-ogg";
    }
    else if ( format.equalsIgnoreCase( "image_gif" ) ||
              format.toLowerCase().endsWith("gif") )
    {
      return "image/gif";
    }
    else if ( format.equalsIgnoreCase( "image_jpeg" ) ||
              format.toLowerCase().endsWith("jpg") ||
              format.toLowerCase().endsWith("jpeg") )
    {
      return "image/jpeg";
    }
    else if ( format.equalsIgnoreCase( "image_bmp" ) ||
              format.toLowerCase().endsWith("bmp") )
    {
      return "image/bmp";
    }
    else if ( format.equalsIgnoreCase( "image_x-png" ) ||
              format.toLowerCase().endsWith("png") )
    {
      return "image/x-png";
    }
    else if ( format.equalsIgnoreCase( "msdownload" ) ||
              format.toLowerCase().endsWith("ms") )
    {
      return "application/x-msdownload";
    }
    else if ( format.equalsIgnoreCase( "video_avi" ) ||
              format.toLowerCase().endsWith("avi") )
    {
      return "video/avi";
    }
    else if ( format.equalsIgnoreCase( "video_mpeg" ) ||
              format.toLowerCase().endsWith("mpg") )
    {
      return "video/mpeg";
    }
    else if ( format.equalsIgnoreCase( "html" ) ||
              format.toLowerCase().endsWith("html") )
    {
      return "text/html";
    }
    else if ( format.equalsIgnoreCase( "xml" ) ||
              format.toLowerCase().endsWith("xml") )
    {
      return "text/xml";
    }
    else
    {
      return null;
    }
  }

  /** Main method to do a quick debug check. This class in made to help the jsps and astroVersion servlet. **/
  public static void main(String[] args)
  {
    int retVal = 0;
    if (args.length >4)
    {
      String repository = args[0];
      String dir = args[1];
      String file = args[2];
      String rev = args[3];
      String rev2 = args[4];
      AstroVersion instance = new AstroVersion();
      try
      {
        String revCat = instance.getFileDiff(repository, dir+file, rev, rev2 );
        String encodedStr = instance.encodeString(revCat);
        System.out.println("Results:");
        System.out.println("        "+repository+" "+dir+file+" "+rev+" "+rev2 );
        System.out.println(encodedStr);
      }
      catch (Exception clEx)
      {
        System.out.println("Error:");
        clEx.printStackTrace();
      }
    }
    else
      System.out.println("Wrong number of args.");

  }


  /**
   *  A event handler class to do somehting when the log events come in during
   *  a log command.
   *
   */
  private class RevLogHandler implements ISVNLogEntryHandler
  {
    /**
     *  Handles the log entry.
     *
     * @param  logEntry  spec'd by the interface
     */
    public void handleLogEntry( SVNLogEntry logEntry )
    {
      long revision = logEntry.getRevision();
      String logMessage = logEntry.getMessage();
      revLogHashTree_.put( new Long( revision ), logEntry );
    }
  }


  /**
   *  A event handler class to do somehting when the file revision events come in during
   *  a getFileRevisions command.
   *
   */
  private class FileRevHandler implements ISVNFileRevisionHandler
  {
    TreeMap fileRevHashTree = new TreeMap();

    /**
     *  Handles the rev, implemented for the ISVNFileRevisionHandler interface
     *
     * @param  logEntry  spec'd by the interface
     */
    public void openRevision(SVNFileRevision fileRevision)
    {
      long revision = fileRevision.getRevision();
      this.fileRevHashTree.put( new Long( revision ), fileRevision );
    }

    /**
     *  Does NOTHING, implemented for the ISVNFileRevisionHandler interface
     *
     * @param  token  spec'd by the interface
     */
    public void closeRevision(String token)
    {
    }


    /**
    *  Collects a next delta chunk, implemented for the ISVNFileRevisionHandler interface
    *
    * @param  path - a file path relative to the edit root directory  spec'd by the interface
    * @param  diffWindow - a next diff window   spec'd by the interface
    */
    public OutputStream textDeltaChunk(String path,
                                       SVNDiffWindow diffWindow)
    {
      OutputStream retVal = new ByteArrayOutputStream();

      return retVal;
    }


    /**
     *  Does NOTHING, implemented for the ISVNFileRevisionHandler interface
     *
     */
    public void applyTextDelta(String path, String baseChecksum)
    {
    }


    /**
     *  Does NOTHING, implemented for the ISVNFileRevisionHandler interface
     *
     */
    public void textDeltaEnd(java.lang.String path)
    {
    }


    public TreeMap getFileRevHashTree()
    {
      return fileRevHashTree;
    }
  }
}
/*
 *  AstroVersion.java
 *  $Id: AstroVersion.java 576 2012-11-19 00:30:11Z tgutwin $
 */