package javacodebook.core.stringtools;

import java.util.Random;
/**
 * Eine Reihe von Methoden, die man immer mal gebrauchen
 * kann, die aber in der Klasse String nicht enthalten sind.
 * @author Mark Donnermeyer
 */
public class StringToolbox {
    
    // Diese Zeichen werden zur Erzeugung von
    // Zufalls-Zeichen genutzt
    private static char[][] RANDOM_STR = {
        { 'a', 'e', 'i', 'o', 'u'},
        { 'b', 'd', 'f', 'g', 'k', 'l',
          'm', 'n', 'p', 'r', 's', 't', 'w' }
    };

    private static Random RAND = 
                    new Random(System.currentTimeMillis());
    
    public static String alignLeft(String str, int width) {
        str = str.trim();
        int len = str.length();
        
        // Text breiter als erlaubt -> abschneiden
        if (len > width && width >= 3)
            return str.substring(0, width-3) + "...";
        
        if (len > width)
            return "...".substring(0, width);
        
        
        StringBuffer align;
        align = new StringBuffer(create(width, ' '));
        align.replace(0, str.length(), str);
        return align.toString();
    }
    
    public static String alignCenter(String str, int width) {
        str = str.trim();
        int len = str.length();
        
        // Text breiter als erlaubt -> hinten abschneiden
        if (len > width)
            return alignLeft(str, width);
        
        StringBuffer align = null;
        align = new StringBuffer(create(width, ' '));
        int start = (width - len)/2;
        int end = start + len;
        align.replace(start, end, str);
        return align.toString();
    }
    
    public static String alignRight(String str, int width) {
        str = str.trim();
        
        int len = str.length();
        
        // Text breiter als erlaubt -> hinten abschneiden
        if (len > width)
            return alignLeft(str, width);
        
        StringBuffer align = null;
        align = new StringBuffer(create(width, ' '));
        align.replace(width - str.length(), width, str);
        return align.toString();
    }
    
    /**
     * Erzeugt einen neuen String mit einer vorgegebenen
     * Länge und gefüllt mit dem Zeichen fill
     */
    public static String create(int len, char fill) {
        char []buf = new char[len];
        for (int i=0; i<len; i++)
            buf[i] = fill;
        
        return new String(buf);
    }
    
    /**
     * Erzeugt einen neuen String, bei dem alle Teilstrings
     * "oldStr" durch Teilstrings "newStr" ersetzt wurden.
     */
    public static String replace(String text,
                            String oldStr, String newStr) {
                                
        // Evtl. können wir uns die ganze Arbeit sparen.
        if (text == null || oldStr == null)
            return text;
        
        // Sicherstellen, dass nicht am Ende 'null' im
        // String steht.
        if (newStr == null)
            newStr = "";
        
        int oldLen = oldStr.length();
        int start  = 0;
        int end    = text.indexOf(oldStr);
        StringBuffer tmp = new StringBuffer();
        
        // Solange etwas gefunden wird, müssen aus was
        // ersetzt werden
        while (end >= 0) {
            tmp.append(text.substring(start, end));
            tmp.append(newStr);
            start = end + oldLen;
            end = text.indexOf(oldStr, end+oldLen);
        }
        
        // Zum Schluss den letzten Rest des alten Strings
        // an den neuen hängen (Wenn es noch einen Rest
        // zum dranhängen gibt)
        tmp.append(text.substring(start));
        
        return tmp.toString();
    }
    
    /**
     * Erzeugt einen lesbaren String in der angegebenen
     * Laenge. Der Inhalt besteht aus zufällig ausgewählten
     * Zeichen. Es werden NICHT alle Zeichen des Alphabetes
     * genutzt!
     */
    public static String randomWord(int length) {
        char[] res = new char[length];
        int toggle=1, max=0;
        
        for (int i=0; i<length; i++) {
            max = RANDOM_STR[toggle].length;
            res[i] = RANDOM_STR[toggle][RAND.nextInt(max)];
            toggle = 1-toggle;
        }
        
        return new String(res);
    }
    
    
    /**
     * Gibt den String zurueck, wobei der erste Buchstabe
     * des Strings in einen Großbuchstaben verwandelt wurde.
     */
    public static String capital(String string) {
        if (string == null || string.length() == 0)
            return string;
        else if (string.length() == 1)
            return string.toUpperCase();
        else
            return string.substring(0, 1).toUpperCase() 
                                    + string.substring(1);
    }
}