/*
    * #%L
    * JavaHg
    * %%
    * Copyright (C) 2011 aragost Trifork ag
    * %%
    * Permission is hereby granted, free of charge, to any person obtaining a copy
    * of this software and associated documentation files (the "Software"), to deal
    * in the Software without restriction, including without limitation the rights
   * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   * copies of the Software, and to permit persons to whom the Software is
   * furnished to do so, subject to the following conditions:
   * 
   * The above copyright notice and this permission notice shall be included in
   * all copies or substantial portions of the Software.
   * 
   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   * THE SOFTWARE.
   * #L%
   */
  package com.aragost.javahg;
  
  import java.io.IOException;
  import java.util.List;
  import java.util.Map;
  
  import com.aragost.javahg.commands.LogCommand;
  import com.aragost.javahg.commands.StatusCommand;
  import com.aragost.javahg.commands.StatusResult;
  import com.aragost.javahg.internals.GenericLogCommand;
  import com.aragost.javahg.internals.HgInputStream;
  import com.aragost.javahg.internals.RuntimeIOException;
  import com.aragost.javahg.internals.Utils;
  import com.google.common.annotations.VisibleForTesting;
  import com.google.common.base.Function;
  import com.google.common.collect.ImmutableList;
  import com.google.common.collect.ImmutableMap;
  import com.google.common.collect.Lists;
  import com.google.common.collect.Maps;
  import com.google.common.collect.ImmutableList.Builder;
  
  /**
   * Represent data for a single changeset.
   * <p>
   * A Changeset object can be created just with the node id. The
   * actually data will be loaded on demand when it is accessed
   */
  public class Changeset {
  
      /**
       * Character sequence that indicate the begin and end of the
       * changeset in the command output.
       * <p>
       * This pattern is written by the CHANGESET_STYLE_PATH
       */
      private static final byte[] CHANGESET_PATTERN = Utils.randomBytes();
  
      /**
       * Style file used among other with the log command to read
       * changesets.
       * <p>
       * The style is parsed by the createFromInputStream() method.
       */
      public static final String CHANGESET_STYLE_PATH = Utils.resourceAsFile("/styles/changesets.style",
              ImmutableMap.of("pattern", CHANGESET_PATTERN)).getPath();
      
      public static final String CHANGESET_EAGER_STYLE_PATH = Utils.resourceAsFile("/styles/changesets-eager.style",
              ImmutableMap.of("pattern", CHANGESET_PATTERN)).getPath();
  
      /**
       * The id for the null changeset
       */
      public static final String NULL_ID = "0000000000000000000000000000000000000000";
  
      private final String node;
      private final Repository repository;
  
      /**
       * The actual data for the Changeset
       */
      protected ChangesetData data;
      
      /**
       * The actual file data for the Changeset
       */
      protected ChangesetFileData fileData;
  
      /**
       * Mercurial's extra data. Lazy loaded.
       */
      private Extra extra;
  
      /**
       * Use {@link Repository#changeset(String)} to create Changesets
      * 
      * @param repository
      */
     public Changeset(Repository repository, String node) {
         this.repository = repository;
         this.node = node;
     }
 
     private static Changeset createFromInputStream(Repository repository, HgInputStream in, boolean eager) throws IOException {
         byte[] node = in.next(40);
         String nodeString = new String(node);
         int revision = in.revisionUpTo('\n');
         Changeset cset = repository.changeset(nodeString);
         String user = in.textUpTo('\n');
         DateTime timestamp = in.dateTimeUpTo('\n');
         String branch = in.textUpTo('\n');
         in.upTo(':');
         String p1 = in.nextAsText(40);
         in.upTo(':');
         String p2 = in.nextAsText(40);
         in.mustMatch(' '); // skip space part of {parents}
         Changeset parent1 = repository.changeset(p1);
         Changeset parent2 = repository.changeset(p2);
         
         // read files
         if ( eager ){
           Builder<String> addedBuilder = ImmutableList.builder();
           Builder<String> modifiedBuilder = ImmutableList.builder();
           Builder<String> deletedBuilder = ImmutableList.builder();
 
           String line = in.textUpTo('\n');
           while ( line.length() > 0 ) {
             if ( line.startsWith("a ") ){
               addedBuilder.add( line.substring(2) );
             } else if ( line.startsWith("m ") ){
               modifiedBuilder.add( line.substring(2) );
             } else if ( line.startsWith("d ")){
               deletedBuilder.add( line.substring(2) );
             }
             line = in.textUpTo('\n');
           }
           
           ChangesetFileData fileData = cset.fileData;
           if (fileData == null){
             fileData = new ChangesetFileData(addedBuilder.build(), modifiedBuilder.build(), deletedBuilder.build());
             cset.fileData = fileData;
           }
         }
         String message = in.textUpTo('\0');
 
         if (cset == null) {
             // Revision -1:000000000000
             return null;
         }
 
         ChangesetData data = cset.data;
         if (data == null) {
             data = new ChangesetData(revision, user, timestamp, branch, parent1, parent2, 
                        message);
             cset.data = data;
         } else if (revision != data.revision) {
             // Handle revision specially because revision is not part of the node
             data.revision = revision;
         }
         return cset;
     }
 
     /**
      * This method is an alias for {@link #readListFromStream(Repository, HgInputStream, boolean)} 
      * with the eager parameter set to false.
      * 
      * @param repository
      * @param in
      * @return 
      */
     public static List<Changeset> readListFromStream(Repository repository, HgInputStream in) {
       return readListFromStream(repository, in, false);
     }
 
     /**
      * Read the rest of the content of the stream and return a List of
      * the Changeset found there.
      * <p>
      * Be aware the this method will read everything from the stream,
      * what is after the changesets will simply be discarded.
      * 
      * @param repository
      * @param in
      * @param eager
      * @return
      */
     public static List<Changeset> readListFromStream(Repository repository, HgInputStream in, boolean eager) {
         List<Changeset> changesets = Lists.newArrayList();
         try {
             boolean found = in.find(CHANGESET_PATTERN);
             if (found) {
                 while (!in.match(CHANGESET_PATTERN)) {
                     Changeset cset = Changeset.createFromInputStream(repository, in, eager);
 
                     if (cset != null) {
                         changesets.add(cset);
                     }
                 }
             }
             // If the pattern is not found there is no changsets
         } catch (IOException e) {
             throw new RuntimeIOException(e);
         } finally {
            try {
               Utils.consumeAll(in);
            } catch (IOException e) {
               throw new RuntimeIOException(e);
            }
         }
         return changesets;
     }
 
     public String getNode() {
         return this.node;
     }
 
     public int getRevision() {
         ensureAllDataLoaded();
         return this.data.revision;
     }
 
     public String getUser() {
         ensureAllDataLoaded();
         return this.data.user;
     }
 
     public DateTime getTimestamp() {
         ensureAllDataLoaded();
         return this.data.timestamp;
     }
 
     public String getBranch() {
         ensureAllDataLoaded();
         return this.data.branch;
     }
 
     public Changeset getParent1() {
         ensureAllDataLoaded();
         return this.data.parent1;
     }
 
     public Changeset getParent2() {
         ensureAllDataLoaded();
         return this.data.parent2;
     }
 
     public String getMessage() {
         ensureAllDataLoaded();
         return this.data.message;
     }
     
     public List<String> getAddedFiles(){
         ensureFileDataLoaded();
         return this.fileData.addedFiles;
     }
     
     public List<String> getModifiedFiles(){
         ensureFileDataLoaded();
         return this.fileData.modifiedFiles;
     }
     
     public List<String> getDeletedFiles(){
         ensureFileDataLoaded();
         return this.fileData.deletedFiles;
     }
     
     private void loadFileData(){
       StatusResult result = new StatusCommand(repository).added().modified()
                                   .removed().change(this.node).execute();
       if ( result != null ){
         fileData = new ChangesetFileData(result.getAdded(), result.getModified(), 
                                          result.getRemoved());
       } else {
         throw new IllegalStateException("could not load file data from status");
       }
     }
     
     private void ensureFileDataLoaded(){
         if (this.fileData != null) {
           return;
         }
         loadFileData();
         if (this.fileData == null) {
             throw new IllegalStateException("could not load file data");
         }
     }
 
     private void ensureAllDataLoaded() {
         if (this.data != null) {
             return;
         }
         LogCommand.on(this.repository).rev(getNode()).execute();
         if (this.data == null) {
             throw new IllegalStateException("data was not loaded");
         }
     }
 
     @Deprecated
     public Phase readPhase() {
         return phase();
     }
 
     /**
      * 
      * @return the phase for this changeset.
      */
     public Phase phase() {
         Map<Changeset, Phase> phases = getRepository().phases(getNode());
         return phases.get(this);
     }
 
     /**
      * Return tags that is pointing the this changeset
      */
     public List<String> tags() {
         GenericLogCommand cmd = new GenericLogCommand(getRepository()).style("tags");
         cmd.rev(getNode());
         HgInputStream stream = cmd.stream();
         List<String> result = Lists.newArrayList();
         try {
             while (!stream.isEof()) {
                 String tag = stream.textUpTo(0);
                 if (!"tip".equals(tag)) {
                     result.add(tag);
                 }
             }
         } catch (IOException e) {
             throw new RuntimeIOException(e);
         } finally {
         	try {
 				stream.consumeAll();
 			} catch (IOException e) {
 				throw new RuntimeIOException(e);
 			}
         }
         return result;
     }
 
     /**
      * 
      * @return Mercurial's extra dictionary
      */
     public synchronized Extra getExtra() {
         if (this.extra == null) {
             GenericLogCommand cmd = new GenericLogCommand(getRepository()).style("extras");
             cmd.rev(getNode());
             this.extra = new Extra(cmd.stream());
         }
         return this.extra;
     }
 
     @Override
     public boolean equals(Object that) {
         if (that instanceof Changeset) {
             return equals((Changeset) that);
         } else {
             return false;
         }
     }
 
     public boolean equals(Changeset that) {
         if (this.repository != that.repository) {
             return false;
         }
         return this.getNode().equals(that.getNode());
     }
 
     @Override
     public int hashCode() {
         return getNode().hashCode();
     }
 
     @Override
     public String toString() {
         StringBuilder builder = new StringBuilder("changeset[");
         builder.append(this.data == null ? "?" : this.data.revision).append(':').append(this.node).append(']');
         return builder.toString();
     }
 
     @VisibleForTesting
     ChangesetData getData() {
         return this.data;
     }
     
     @VisibleForTesting
     ChangesetFileData getFileData(){
       return this.fileData;
     }
 
     Repository getRepository() {
         return repository;
     }
 
     private String decodeBytes(byte[] bytes) {
         return Utils.decodeBytes(bytes, getRepository().newDecoder());
     }
 
     /**
      * Class representing the extra dictionary Mercurial has for each
      * changeset.
      * <p>
      * The values can be binary data, but is typically strings. For
      * this reason there is accessor methods to access the values as
      * both byte array and String.
      */
     public class Extra {
 
         private final Map<String, byte[]> map;
 
         private Extra(HgInputStream stream) {
             try {
                 this.map = Maps.newHashMap();
                 // The value is binary data, node is used as delimiter
                 byte[] node = stream.upTo(0);
                 while (!stream.isEof()) {
                     String key = stream.textUpTo(0);
                     byte[] value = stream.upTo(node);
                     this.map.put(key, value);
                 }
             } catch (IOException e) {
                 throw new RuntimeIOException(e);
             } finally {
             	try {
 					stream.consumeAll();
 				} catch (IOException e) {
 					throw new RuntimeIOException(e);
 				}
             }
         }
 
         /**
          * @param key
          * @return The extra data for the key as a String
          */
         public String getString(String key) {
             byte[] bytes = getBytes(key);
             if (bytes == null) {
                 return null;
             } else {
                 return decodeBytes(bytes);
             }
         }
 
         /**
          * @param key
          * @return The extra data for the key as byte array
          */
         public byte[] getBytes(String key) {
             return map.get(key);
         }
 
         /**
          * @return a view on the extra data dictionary where values
          *         are Strings.
          */
         public Map<String, String> stringValuedMap() {
             Function<byte[], String> f = new Function<byte[], String>() {
                 public String apply(byte[] input) {
                     return decodeBytes(input);
                 }
             };
             return Maps.transformValues(this.map, f);
         }
 
         /**
          * @return a view on the extra data dictionary where values
          *         are byte arrays.
          */
         public Map<String, byte[]> byteArrayValuedMap() {
             return this.map;
         }
 
     }
 
 }
 
 
 class ChangesetFileData {
   
   public List<String> addedFiles;
   public List<String> modifiedFiles;
   public List<String> deletedFiles;
 
   public ChangesetFileData(List<String> addedFiles,
     List<String> modifiedFiles,
     List<String> deletedFiles)
   {
     this.addedFiles = addedFiles;
     this.modifiedFiles = modifiedFiles;
     this.deletedFiles = deletedFiles;
   }
   
 }
 class ChangesetData {
     public int revision;
     public String user;
     public DateTime timestamp;
     public String branch;
     public Changeset parent1;
     public Changeset parent2;
     public String message;
 
     public ChangesetData(int revision, String user, DateTime timestamp, String branch, Changeset parent1,
             Changeset parent2, String message) {
         this.revision = revision;
         this.user = user;
         this.timestamp = timestamp;
         this.branch = branch;
         this.parent1 = parent1;
         this.parent2 = parent2;
         this.message = message;
     }
 }