/*

  * #%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.commands;

 import java.util.List;

 import java.util.Map;

 import com.google.common.collect.Lists;

 import com.google.common.collect.Maps;

 /**

  * An aggregated status result. This class gives easy access to the

  * files of different status types and will in particular parse added

  * and copied files correctly.

  */

 public class StatusResult {

     private List<String> modified = Lists.newArrayList();

     private List<String> added = Lists.newArrayList();

     private List<String> removed = Lists.newArrayList();

     private List<String> clean = Lists.newArrayList();

     private List<String> missing = Lists.newArrayList();

     private List<String> unknown = Lists.newArrayList();

     private List<String> ignored = Lists.newArrayList();

     // Map from new name to old name

     private Map<String, String> copied = Maps.newHashMap();

     /**

      * @return files with status M

      */

     public List<String> getModified() {

         return modified;

     }

     /**

      * List of added files. Files that has been copied is <em>not</em>

      * in this List, even though 'hg status' reports them with status

      * A. Instead they are in {@code copied}.

      * <p>

      * If the <tt>--copies</tt> flag isn't set the status command does

      * not report origin, and this List will also include copied

      * files.

      * 

      * @return files with status A

      */

     public List<String> getAdded() {

         return added;

     }

     /**

      * @return Files with status R

      */

     public List<String> getRemoved() {

         return removed;

     }

     /**

      * @return files with status C

      */

     public List<String> getClean() {

         return clean;

     }

     /**

      * @return files with status !

      */

     public List<String> getMissing() {

         return missing;

     }

     /**

      * @return files with status ?

      */

     public List<String> getUnknown() {

         return unknown;

     }

     /**

      * @return files with status I

      */

     public List<String> getIgnored() {

         return ignored;

     }

     /**

      * Mapping copied files. The key is the new name and value is

      * origin.

      * 

      * @return map from new name to origin for copied files.

      */

     public Map<String, String> getCopied() {

         return copied;

     }

     void addLine(StatusLine current) {

         String fileName = current.getFileName();

         switch (current.getType()) {

         case ADDED:

             this.added.add(fileName);

             break;

         case CLEAN:

             this.clean.add(fileName);

             break;

         case IGNORED:

             this.ignored.add(fileName);

             break;

         case MISSING:

             this.missing.add(fileName);

             break;

         case MODIFIED:

             this.modified.add(fileName);

             break;

         case ORIGIN:

             // The previous line is ADDED. It should be removed,

             // and replaced with a mapping in copied

             String newName = this.added.remove(this.added.size() - 1);

             this.copied.put(newName, fileName);

             break;

         case REMOVED:

             this.removed.add(fileName);

             break;

         case UNKNOWN:

             this.unknown.add(fileName);

             break;

         default:

             throw new IllegalStateException("Unhandled StatusLine type: " + current.getType());

         }

     }

     @Override

     public String toString() {

         StringBuilder s = new StringBuilder("status(");

         toStringHelper(s, this.modified, "modified");

         toStringHelper(s, this.added, "added");

         toStringHelper(s, this.removed, "removed");

         toStringHelper(s, this.unknown, "unknown");

         toStringHelper(s, this.missing, "missing");

         toStringHelper(s, this.ignored, "ignored");

         toStringHelper(s, this.clean, "clean");

         s.append(")");

         return s.toString();

     }

     private void toStringHelper(StringBuilder s, List<String> coll, String name) {

         int size = coll.size();

         if (size == 0) {

             return;

         }

         s.append('[');

         if (size > 5) {

             s.append(size).append(" files");

         } else {

             char sep = '=';

             s.append(name);

             for (String e : coll) {

                 s.append(sep).append(e);

                 sep = ',';

             }

         }

         s.append(']');

     }

 }