/*
    * Copyright (c) 2007 Creative Sphere Limited.
    * All rights reserved. This program and the accompanying materials
    * are made available under the terms of the Eclipse Public License v1.0
    * which accompanies this distribution, and is available at
    * http://www.eclipse.org/legal/epl-v10.html
    *
    * Contributors:
    *
   *   Creative Sphere - initial API and implementation
   *
   */
  package org.abstracthorizon.aequo.util;
  
  import java.awt.Component;
  import java.awt.Font;
  import java.awt.FontMetrics;
  import java.io.File;
  
  /**
   * String utilities
   * 
   * @author Daniel Sendula
   */
  public class StringUtils {
  
      /**
       * Returns file size of given long integer
       * @param size file size
       * @return string representation of file size.
       */
      public static String normaliseSize(long size) {
          if (size < 1024) {
              return Long.toString(size);
          } else if (size < (1024 * 1024)) {
              return Long.toString(size / 1024) + "kB";
          } else if (size < (1024 * 1024 * 1024)) {
              return Long.toString(size / (1024 * 1024)) + "MB";
          } else if (size < (1024 * 1024 * 1024 * 1024)) {
              return Long.toString(size / (1024 * 1024 * 1024)) + "GB";
          } else {
              return Long.toString(size / (1024 * 1024 * 1024 * 1024)) + "TB";
          }
      }
  
      /**
       * Calculates title when two files are compared
       * @param parent parent component font metrics to be taken from
       * @param width width of space for the title
       * @param leftFile left file 
       * @param rightFile right file
       * @param titleFont font to be used
       * @return string
       */
      public static String calculateTitle(Component parent, int width, File leftFile, File rightFile, Font titleFont) {
          String left = leftFile.getAbsolutePath();
          String right = rightFile.getAbsolutePath();
          return calculateTitle(parent, width, left, right, titleFont);
      }
      
      /**
       * Calculates title when two files are compared
       * @param parent parent component font metrics to be taken from
       * @param width width of space for the title
       * @param left left file name
       * @param right right file name
       * @param titleFont font to be used
       * @return string
       */
      public static String calculateTitle(Component parent, int width, String left, String right, Font titleFont) {
          FontMetrics fontMetrics = parent.getFontMetrics(titleFont);
  
          String newTitle = left + " vs " + right;
          if (width > fontMetrics.stringWidth(newTitle)) {
              return newTitle;
          } else if (left.equals(right)) {
              return "Comparing with itself: " + left;
          } else {
              return calculateShortestTitle(left, right);
          }
      }
      
      /**
       * Calculates shortest title when two files are compared
       * @param left left file name
       * @param right right file name
       * @return string
       */
      public static String calculateShortestTitle(String left, String right) {
          int start = 0;
          if (left.startsWith(right)) {
              char s = File.separatorChar;
              int i = right.lastIndexOf(s);
              if (i >= 0) {
                  return "..." + left.substring(i) + " vs ..." + right.substring(i);
              } else {
                  return left + " vs " + right;
              }
          }
         
         if (right.startsWith(left)) {
             char s = File.separatorChar;
             int i = left.lastIndexOf(s);
             if (i >= 0) {
                 return "..." + left.substring(i) + " vs ..." + right.substring(i);
             } else {
                 return left + " vs " + right;
             }
         }
         
         while ((start < left.length()) && (start < right.length()) && (left.charAt(start) == right.charAt(start))) {
             start++;
         }
         int end = 0;
         int leftEnd = left.length() - 1;
         int rightEnd = right.length() - 1;
         // TODO
         while ((leftEnd >= 0) && (rightEnd >= 0) && (left.charAt(leftEnd) == right.charAt(rightEnd))) {
             end++;
             leftEnd--;
             rightEnd--;
         }
         StringBuffer nt = new StringBuffer();
         if (start > 0) {
             nt.append("...");
         }
         nt.append(extractPath(left, start, leftEnd));
         if (leftEnd < left.length() - 1) {
             nt.append("...");
         }
         nt.append(" vs ");
         if (start > 0) {
             nt.append("...");
         }
         nt.append(extractPath(right, start, rightEnd));
         if (rightEnd < right.length() - 1) {
             nt.append("...");
         }
         return nt.toString();
     }
     
     /**
      * Extracts the path from given string and between two indexes
      * @param str string
      * @param start start index
      * @param end end index
      * @return path
      */
     protected static String extractPath(String str, int start, int end) {
         char s = File.separatorChar;
         while ((start > 0) && (str.charAt(start - 1) != s)) {
             start = start - 1;
         }
         while ((end < str.length()) && (str.charAt(end) != s)) {
             end = end + 1;
         }
         if (start <= end) {
             return str.substring(start, end);
         } else {
             return "";
         }
     }
     
     /**
      * Removes all whitespace from the string
      * @param s string
      * @return new string without the whitespace
      */
     public static String collapseWhitespace(String s) {
         StringBuffer result = new StringBuffer(s.length());
         int l = s.length();
         boolean whitespace = false;
         for (int i = 0; i < l; i++) {
             char c = s.charAt(i);
             if (Character.isWhitespace(c)) {
                 if (!whitespace) {
                     result.append(c);
                     whitespace = true;
                 }
             } else {
                 result.append(c);
                 whitespace = false;
             }
         }
         return result.toString();
     }
     
     /**
      * Removes all whitespace from the string
      * @param s string
      * @return new string without the whitespace
      */
     public static String removeWhitespaceX(String s) {
         StringBuffer result = new StringBuffer(s.length());
         int l = s.length();
         for (int i = 0; i < l; i++) {
             char c = s.charAt(i);
             if (!Character.isWhitespace(c)) {
                 result.append(c);
             }
         }
         return result.toString();
     }
 }