/*
    * The Apache Software License, Version 1.1
    *
    * Copyright (c) 1999, 2000 The Apache Software Foundation.  All rights
    * reserved.
    *
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions
    * are met:
   *
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * 3. The end-user documentation included with the redistribution, if
   *    any, must include the following acknowlegement:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowlegement may appear in the software itself,
   *    if and wherever such third-party acknowlegements normally appear.
   *
   * 4. The names "The Jakarta Project", "Ant", and "Apache Software
   *    Foundation" must not be used to endorse or promote products derived
   *    from this software without prior written permission. For written
   *    permission, please contact apache@apache.org.
   *
   * 5. Products derived from this software may not be called "Apache"
   *    nor may "Apache" appear in their names without prior written
   *    permission of the Apache Group.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
   * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   * ====================================================================
   *
   * This software consists of voluntary contributions made by many
   * individuals on behalf of the Apache Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  
  package org.apache.tools.ant.taskdefs.optional.clearcase;
  
  import org.apache.tools.ant.BuildException;
  import org.apache.tools.ant.Project;
  import org.apache.tools.ant.taskdefs.Echo;
  import org.apache.tools.ant.taskdefs.Execute;
  import org.apache.tools.ant.taskdefs.LoadFile;
  import org.apache.tools.ant.taskdefs.PumpStreamHandler;
  import org.apache.tools.ant.taskdefs.optional.clearcase.ClearCase;
  import org.apache.tools.ant.types.Commandline;
  import org.apache.tools.ant.util.FileUtils;
  import org.w3c.dom.*;
  
  import javax.xml.parsers.DocumentBuilderFactory;
  import java.io.*;
  import java.text.ParseException;
  import java.text.SimpleDateFormat;
  import java.util.Date;
  import java.util.Random;
  import java.util.StringTokenizer;
  import java.util.Vector;
  
  /***
   * The aim of this task is to generate a ClearCase change log report under the XML format, just like
   * <code>CVSChangeLog</code> does it.
   * <p/>
   * Has been tested under Windows NT V4.0 SP6 and ClearCase 2002.05.00.
   * </p>
   *
   * @taskname CCChangeLog
   * @author Edouard Mercier
   * @version 1.0 : 2004.04.25
   */
  public class CCChangeLog
          extends ClearCase
  {
  
    private String _from_date;
  
    /***
     * Sets the date the history begins from. The format is the one expected by the ClearCase <code>lshistory -since</code>
     * option (in French, <code>01-mars-04</code> is OK for instance).
     *
     * @optional start_date if not set, the history is taken from the beginning of the source history
     */
   public void setFromDate(String start_date)
   {
       _from_date = start_date;
   }
 
   private String _from_label;
 
   /***
    * Enables to tell from which label the change log will be generated.
    *
    * @optional from_label if not set, the history is taken from the beginning of the source history
    */
   public void setFromLabel(String from_label)
   {
       _from_label = from_label;
   }
 
   private File _destination_file = new File("CCChangeLog.xml");
 
   /***
    * Sets the output file for the XML log.
    */
   public void setDestfile(File destination_file)
   {
       _destination_file = destination_file;
   }
 
   /***
    * The file that will contain the log of the ClearCase command execution.
    */
   private File temporary_file;
 
   /***
    * Checks that the input parameters are OK.
    *
    * @throws BuildException if some parameters are not OK
    */
   private void checkParameters()
           throws BuildException
   {
   }
 
   /***
    * The method that actually perform the ClearCase change history job.
    *
    * @throws BuildException if some unexpected error occured
    */
   public void execute()
           throws BuildException
   {
       checkParameters();
 
       File lstype_log_file = performLsType();
       analyzeLsType(lstype_log_file);
 
       File lshistory_log_file = performLsHistory();
 
       temporary_file = FileUtils.newFileUtils().createTempFile("ccchangelog", ".xml", null);
       temporary_file.deleteOnExit();
 
       //Now, we create an XML log file that will contain the CC changes, via Ant native tasks
       {
           Echo echo = new Echo();
           echo.setProject(getProject());
           echo.setFile(temporary_file);
           echo.setMessage("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?><events>");
           echo.execute();
       }
       String value = null;
       /*{
           LoadFile load_file = new LoadFile();
           load_file.setProject(getProject());
           load_file.setSrcFile(lshistory_log_file);
           final String dummy_property = "DUMMY_PROPERTY" + Math.abs(new Random().nextInt());
           load_file.setProperty(dummy_property);
           load_file.execute();
           value = getProject().getProperty(dummy_property);
       }*/
       {
           value = "";
           FileReader file_reader = null;
           BufferedReader buffered_reader = null;
           try
           {
               file_reader = new FileReader(lshistory_log_file);
               buffered_reader = new BufferedReader(file_reader);
               try
               {
                   String line = null;
                   while ((line = buffered_reader.readLine()) != null)
                   {
                       value += line + "\n";
                   }
               }
               catch (IOException io_exception)
               {
                   throw new BuildException("Internal error while reading file '" +
                           lshistory_log_file.getAbsolutePath() + "'", io_exception, location);
               }
           }
           catch (FileNotFoundException file_not_found_exception)
           {
               throw new BuildException("Internal error while reading file '" +
                       lshistory_log_file.getAbsolutePath() + "'", file_not_found_exception, location);
           }
           finally
           {
               if (buffered_reader != null)
               {
                   try
                   {
                       buffered_reader.close();
                   }
                   catch (IOException io_exception)
                   {
                       // Does not matter
                   }
               }
               if (file_reader != null)
               {
                   try
                   {
                       file_reader.close();
                   }
                   catch (IOException io_exception)
                   {
                       // Does not matter
                   }
               }
           }
       }
       if (value == null)
       {
           throw new BuildException("There was an internal error while reading the temporary file '" +
                   lshistory_log_file.getAbsolutePath() + "'", location);
       }
       {
           Echo echo = new Echo();
           echo.setProject(getProject());
           echo.setFile(temporary_file);
           echo.setAppend(true);
           echo.setMessage(value);
           echo.execute();
       }
       {
           Echo echo = new Echo();
           echo.setProject(getProject());
           echo.setFile(temporary_file);
           echo.setAppend(true);
           echo.setMessage("</events>");
           echo.execute();
       }
 
       // Now that the XML file has been generated, we can handle it
       CCEntry[] entry_array = analyzeLsHistory(temporary_file);
       dumpChangeLog(entry_array);
   }
 
   /***
    * The 'lshistory' command
    */
   public static final String COMMAND_LSHISTORY = "lshistory";
 
   /***
    * The 'lstype' command
    */
   public static final String COMMAND_LSTYPE = "lstype";
 
   /***
    * The way ClearCase expresses the date format.
    */
   private final SimpleDateFormat clearCaseDateFormat = new SimpleDateFormat("yyyyMMdd.HHmmss");
 
   /***
    * Performs the call to 'lstype' and outputs the result in the provided file.
    *
    * @return the file into which the log of the CC command execution should be output
    */
   private File performLsType()
   {
       log("We perform a 'lstype' call in order to determine the existing labels", Project.MSG_VERBOSE);
       File temporary_log_file = FileUtils.newFileUtils().createTempFile("ccchangelog_lstype", ".log", null);
       temporary_log_file.deleteOnExit();
       ArgumentProvider argument_provider = new ArgumentProvider()
       {
           public void provideAdditionalArguments(Commandline command_line)
           {
               command_line.createArgument().setLine("-kind lbtype");
           }
       };
       performCCCommand(temporary_log_file, COMMAND_LSTYPE, argument_provider, "%Nd | %n\n");
       return temporary_log_file;
   }
 
   private void analyzeLsType(File log_file)
   {
       log("We now analyze the result of the ClearCase '" + COMMAND_LSTYPE + "' call", Project.MSG_VERBOSE);
       SimpleDateFormat clearcase_date_format = new SimpleDateFormat("dd-MMMM-yy");
       try
       {
           FileReader file_reader = new FileReader(log_file);
           BufferedReader buffered_reader = new BufferedReader(file_reader);
           try
           {
               String line = null;
               while ((line = buffered_reader.readLine()) != null)
               {
                   StringTokenizer tokenizer = new StringTokenizer(line, "|");
                   String timestamp = ((String) tokenizer.nextElement()).trim();
                   Date date = null;
                   try
                   {
                       date = clearCaseDateFormat.parse(timestamp);
                   }
                   catch (ParseException parse_exception)
                   {
                       log(parse_exception.getMessage(), Project.MSG_ERR);
                       throw new BuildException("Parsing of the ClearCase date '" + timestamp +
                               "' failed during the 'lstype' command log analyzis", parse_exception, location);
                   }
                   String label = ((String) tokenizer.nextElement()).trim();
                   log("Found the label '" + label + "' created '" + date + "'", Project.MSG_VERBOSE);
                   if (label.equals(_from_label) == true)
                   {
                       _from_date = clearcase_date_format.format(date);
                       log("Found the date of the label '" + label + "' and its creation date is '" + _from_date +
                               "': this start date will be used", Project.MSG_INFO);
                   }
               }
           }
           catch (IOException io_exception)
           {
               throw new BuildException("Could not analyze the log of the ClearCase command", io_exception, location);
           }
       }
       catch (FileNotFoundException file_not_found_exception)
       {
           // Should not happen, given the algorithm
       }
   }
 
   /***
    * The XML element that is used internally.
    */
   private final String XML_EVENT = "event";
 
   /***
    * Performs the call to 'lshistory' and outputs the result in the provided file.
    *
    * @return the file into which the log of the CC command execution should be output
    */
   private File performLsHistory()
   {
       log("We perform a 'lshistory' call in order to be able to build the ClearCase change log", Project.MSG_VERBOSE);
       File temporary_log_file = FileUtils.newFileUtils().createTempFile("ccchangelog_lshistory", ".log", null);
       temporary_log_file.deleteOnExit();
       ArgumentProvider argument_provider = new ArgumentProvider()
       {
           public void provideAdditionalArguments(Commandline command_line)
           {
               command_line.createArgument().setValue("-minor");
               command_line.createArgument().setValue("-recurse");
               command_line.createArgument().setLine("-since " + _from_date);
               command_line.createArgument().setValue(getViewPath());
           }
       };
       // The format is very important
       String format = "<" + XML_EVENT + "><a>%a</a><c><![CDATA[%c]]></c><d>%Nd</d><e>%e</e><f>%f</f><h>%h</h><i>%e</i>" +
               "<l>%l</l><m>%m</m><n>%n</n>" +
               "<o>%o</o><p>%p</p><u>%u</u></" + XML_EVENT + ">\n";
       performCCCommand(temporary_log_file, COMMAND_LSHISTORY, argument_provider, format);
       return temporary_log_file;
   }
 
   /***
    * This defines a ClearCase change event.
    */
   private static class CCEntry
   {
       Date timeStamp;
       String user;
       String comment;
       int type = UNKNOWN;
       String resource;
       public String eventName;
 
       final static int UNKNOWN = -1;
       final static int CREATE_VERSION = 1;
       final static int CREATE_BRANCH = 2;
       final static int CREATE_CHECKOUT = 3;
       final static int CREATE_LABEL = 4;
   }
 
   /***
    * Analyzes the log file resulting from the CC 'lshistory' command execution,
    * and a bit modified in order to be under the XML format.
    *
    * @param log_file
    */
   private CCEntry[] analyzeLsHistory(File log_file)
   {
       log("We now analyze the result of the ClearCase '" + COMMAND_LSHISTORY + "' call", Project.MSG_VERBOSE);
       Vector entry_vector = new Vector();
       Document document = null;
       try
       {
           document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(log_file);
       }
       catch (Exception exception)
       {
           throw new BuildException("Cannot analyze the log of the ClearCase command", exception, location);
       }
       NodeList node_list = document.getDocumentElement().getElementsByTagName(XML_EVENT);
       for (int index = 0; index < node_list.getLength(); index++)
       {
           Node node = node_list.item(index);
           CCEntry entry = new CCEntry();
           entry_vector.add(entry);
           NodeList child_node_list = node.getChildNodes();
           for (int child_index = 0; child_index < child_node_list.getLength(); child_index++)
           {
               Node child_node = child_node_list.item(child_index);
               String value = null;
               if (child_node.getChildNodes().item(0) != null)
               {
                   if (child_node.getChildNodes().item(0).getNodeType() == Node.TEXT_NODE)
                   {
                       value = ((Text) child_node.getChildNodes().item(0)).getData();
                   }
                   else if (child_node.getChildNodes().item(0).getNodeType() == Node.CDATA_SECTION_NODE)
                   {
                       value = ((CDATASection) child_node.getChildNodes().item(0)).getData();
                   }
               }
               if (child_node.getNodeName().equals("c") == true)
               {
                   entry.comment = value;
 
               }
               else if (child_node.getNodeName().equals("d"))
               {
                   try
                   {
                       entry.timeStamp = clearCaseDateFormat.parse(value);
                   }
                   catch (ParseException parse_exception)
                   {
                       throw new BuildException("Parsing of a ClearCase event failed", parse_exception, location);
                   }
               }
               else if (child_node.getNodeName().equals("u") == true)
               {
                   entry.user = value;
               }
               else if (child_node.getNodeName().equals("n") == true)
               {
                   entry.resource = value;
               }
               else if (child_node.getNodeName().equals("e") == true)
               {
                   entry.eventName = value;
               }
           }
       }
       CCEntry[] entry_array = new CCEntry[entry_vector.size()];
       entry_vector.toArray(entry_array);
       return entry_array;
   }
 
   /***
    * Analyzes the log file resulting from the CC command execution.
    * <p/>
    * Has been tested under Windows NTV4.0 SP6 and ClearCase 2002.05.00.
    * </p>
    *
    * @param log_file
    */
   private CCEntry[] analyzeLsHistoryOld(File log_file)
   {
       log("We now analyze the result of the ClearCase '" + COMMAND_LSHISTORY + "' call", Project.MSG_VERBOSE);
       Vector entry_vector = new Vector();
       try
       {
           FileReader file_reader = new FileReader(log_file);
           BufferedReader buffered_reader = new BufferedReader(file_reader);
           try
           {
               String line = buffered_reader.readLine();
               while (line != null)
               {
                   log("Line read:" + line, Project.MSG_DEBUG);
                   log("We first read the timestamp and the ClearCase user on the first line", Project.MSG_DEBUG);
                   StringTokenizer timestamp_tokenizer = new StringTokenizer(line, " ");
                   String timestamp = (String) timestamp_tokenizer.nextElement();
                   Date date = null;
                   try
                   {
                       date = clearCaseDateFormat.parse(timestamp);
                   }
                   catch (ParseException parse_exception)
                   {
                       throw new BuildException("Parsing of a ClearCase event failed", parse_exception, location);
                   }
                   CCEntry entry = new CCEntry();
                   entry.timeStamp = date;
                   entry_vector.add(entry);
                   String user = line.substring(timestamp.length()).trim();
                   entry.user = user;
                   log("Then, the second line displays the ClearCase action", Project.MSG_DEBUG);
                   line = buffered_reader.readLine();
                   if (isNewEvent(line))
                   {
                       continue;
                   }
                   // This line should indicate the type of event
                   if (line.indexOf("create version") != -1 || line.indexOf("create directory version") != -1)
                   {
                       entry.type = CCEntry.CREATE_VERSION;
                   }
                   else if (line.indexOf("create branch") != -1)
                   {
                       entry.type = CCEntry.CREATE_BRANCH;
                   }
                   else if (line.indexOf("checkout version") != -1)
                   {
                       entry.type = CCEntry.CREATE_CHECKOUT;
                   }
                   else if (line.indexOf("make label") != -1)
                   {
                       entry.type = CCEntry.CREATE_LABEL;
                   }
                   // If we have identified the type of event, we should be able to analyze the resource it applies on
                   if (entry.type != CCEntry.UNKNOWN)
                   {
                       StringTokenizer resource_tokenizer = new StringTokenizer(line, "\"");
                       resource_tokenizer.nextElement();
                       entry.resource = (String) resource_tokenizer.nextElement();
                   }
                   line = buffered_reader.readLine().trim();
                   if (isNewEvent(line))
                   {
                       continue;
                   }
                   if (line.startsWith("\"") == true)
                   {
                       log("We have reached the ClearCase comment", Project.MSG_DEBUG);
                       String comment = "";
                       line = line.substring(1);
                       boolean add_cr = false;
                       while (true)
                       {
                           if (line.endsWith("\"") == true)
                           {
                               comment += ((add_cr == true) ? "\n" : "") + line.substring(0, line.length() - 1);
                               break;
                           }
                           comment += ((add_cr == true) ? "\n" : "") + line;
                           add_cr = true;
                           line = buffered_reader.readLine().trim();
                       }
                       entry.comment = comment;
                   }
                   // At last, we read the next line
                   line = buffered_reader.readLine();
               }
           }
           catch (IOException io_exception)
           {
               throw new BuildException("Could not analyze the log of the ClearCase command", io_exception, location);
           }
       }
       catch (FileNotFoundException file_not_found_exception)
       {
           // Should not happen, given the algorithm
       }
       CCEntry[] entry_array = new CCEntry[entry_vector.size()];
       entry_vector.toArray(entry_array);
       return entry_array;
   }
 
   /***
    * @param line the raw line to analyze
    * @return whether the given raw line corresponds to a new ClearCase event within the log file
    */
   private boolean isNewEvent(String line)
   {
       StringTokenizer timestamp_tokenizer = new StringTokenizer(line, " ");
       try
       {
           clearCaseDateFormat.parse((String) timestamp_tokenizer.nextElement());
       }
       catch (ParseException parse_exception)
       {
           // This means that this is not a line that begins a new ClearCase event description
           return false;
       }
       return true;
   }
 
   /***
    * Dumps into a file the result of the ClearCase change log analyzis.
    *
    * @param entry_array all ClearCase change events
    */
   private void dumpChangeLog(CCEntry[] entry_array)
           throws BuildException
   {
       log("We dump the ClearCase change log", Project.MSG_VERBOSE);
       FileOutputStream output = null;
       try
       {
           output = new FileOutputStream(_destination_file);
           PrintWriter writer = new PrintWriter(new OutputStreamWriter(output, "ISO-8859-1"));
           writer.println("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>");
           writer.println("<changelog>");
           SimpleDateFormat date_format = new SimpleDateFormat("yyyy-MM-dd");
           SimpleDateFormat time_format = new SimpleDateFormat("HH:mm");
           for (int index = 0; index < entry_array.length; index++)
           {
               CCEntry entry = entry_array[index];
               log("Handling the ClearCase event performed '" + entry.timeStamp + "' by '" + entry.user + "'", Project.MSG_VERBOSE);
               writer.println("\t<entry>");
               writer.println("\t\t<event>" + entry.eventName + "</event>");
               if (entry.timeStamp != null)
               {
                   writer.println("\t\t<date>" + date_format.format(entry.timeStamp) + "</date>");
                   writer.println("\t\t<time>" + time_format.format(entry.timeStamp) + "</time>");
               }
               writer.println("\t\t<author>" + entry.user + "</author>");
               if (entry.resource != null)
               {
                   writer.println("\t\t<file>");
                   writer.println("\t\t\t<name>" + entry.resource + "</name>");
                   writer.println("\t\t</file>");
               }
               if (entry.comment != null)
               {
                   writer.println("\t\t<msg><![CDATA[" + entry.comment + "]]></msg>");
               }
               writer.println("\t</entry>");
           }
           writer.println("</changelog>");
           writer.flush();
           writer.close();
       }
       catch (final UnsupportedEncodingException unsupported_encoding_exception)
       {
           throw new BuildException("Does not support the encoding", unsupported_encoding_exception, location);
       }
       catch (final IOException io_exception)
       {
           throw new BuildException("Error while generating report", io_exception, location);
       }
       finally
       {
           if (output != null)
           {
               try
               {
                   output.close();
               }
               catch (final IOException io_exception)
               {
                   // Does not matter
               }
           }
       }
   }
 
   /***
    * An interface designed in order to provide additional arguments to the ClearCase command execution.
    */
   interface ArgumentProvider
   {
       /***
        * Enables to provide additional arguments to the provided command-line.
        *
        * @param command_line the command line additional arguments will be added to
        */
       void provideAdditionalArguments(Commandline command_line);
   }
 
   private void performCCCommand(File log_file, String clearcase_command, ArgumentProvider argument_provider, String format)
           throws BuildException
   {
       // We define the command line to be executed
       Commandline command_line = new Commandline();
       // Defaults the viewpath to the Ant project 'basedir' if it is not specified
       if (getViewPath() == null)
       {
           setViewPath(getProject().getBaseDir().getPath());
       }
       command_line.setExecutable(getClearToolCommand());
       command_line.createArgument().setValue(clearcase_command);
       // We handle the format
       log("The format used in order to extract the information from ClearCase is '" + format + "'", Project.MSG_VERBOSE);
       command_line.createArgument().setLine("-fmt \"" + format + "\"");
       // We use the additional arguments that the client needs
       argument_provider.provideAdditionalArguments(command_line);
       // Now, we run the command
       int result = run(command_line, log_file);
       if (result == Execute.INVALID || result != 0)
       {
           String msg = "Failed executing: " + command_line.toString();
           throw new BuildException(msg, location);
       }
   }
 
   /***
    * Runs the ClearCase command via the provided command line, and outputs the log into the provided log file.
    */
   protected int run(Commandline command_line, File log_file)
           throws BuildException
   {
       try
       {
           Project project = getProject();
           final FileOutputStream output = new FileOutputStream(log_file.getPath(), false);
           //final PipedOutputStream output = new PipedOutputStream();
           //final OutputStream output_stream = new PrintStream(new BufferedOutputStream(output));
           Execute execute = new Execute(new PumpStreamHandler(output, output));
           execute.setAntRun(project);
           String execution_path = getViewPath();
           if (execution_path == null)
           {
               execution_path = project.getBaseDir().getPath();
           }
           execute.setWorkingDirectory(new File(execution_path));
           execute.setCommandline(command_line.getCommandline());
 
           /*new Thread(new Runnable()
           {
               public void run()
               {
                   try
                   {
                       PipedInputStream piped_input_stream = new PipedInputStream();
                       piped_input_stream.connect(output);
 
                       //output_stream.write(new byte[]{1, 2, 3});
                       int index = 0;
                   }
                   catch (IOException e)
                   {
                       e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
                   }
               }
           }).start();*/
 
           return execute.execute();
       }
       catch (java.io.IOException io_exception)
       {
           throw new BuildException(io_exception, location);
       }
   }
 
 }