/**
 * Copyright 2001 Sun Microsystems, Inc.
 * 
 * See the file "license.terms" for information on usage and
 * redistribution of this file, and for a DISCLAIMER OF ALL 
 * WARRANTIES.
 */
package com.sun.speech.freetts.util;

import java.io.PrintWriter;
import java.net.URL;
import java.io.FileInputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.nio.ByteBuffer;
import java.io.InputStream;
import java.io.IOException;

/**
 * Provides a set of generic utilities used by freetts.
 */
public class Utilities {

    /**
     * Avoid construction.
     */
    private Utilities() {
    }

    /**
     * Returns a string with the given number of
     * spaces.
     *
     * @param padding the number of spaces in the string
     *
     * @return a string of length 'padding' containg only the SPACE
     * char.
     */
    public static String pad(int padding) {
	if (padding > 0) {
	    StringBuffer sb = new StringBuffer(padding);
	    for (int i = 0; i < padding; i++) {
		sb.append(' ');
	    }
	    return sb.toString();
	 } else {
	     return "";
	 }
    }

    /**
     * Pads with spaces or truncates the given string to guarantee that it is
     * exactly the desired length.
     *
     * @param string the string to be padded
     * @param minLength the desired length of the string
     *
     * @return a string of length conntaining string
     * padded with whitespace or truncated
     */
    public static String pad(String string, int minLength) {
	String result = string;
	int pad = minLength - string.length();
	if (pad > 0) {
	    result =  string + pad(minLength - string.length());
	} else if (pad < 0) {
	    result = string.substring(0, minLength);
	}
	return result;
    }

    /**
     * Removes all instances of the specified character from the given String.
     *
     * @param  fromString  the String to delete characters from
     * @param  charToDelete  the character to delete from the given String
     *
     * @return  a String with all instances of the specified char deleted
     */
    public static String deleteChar(String fromString, char charToDelete) {
	StringBuffer buffer = new StringBuffer(fromString.length());
	for (int i = 0; i < fromString.length(); i++) {
	    if (fromString.charAt(i) != charToDelete) {
		buffer.append(fromString.charAt(i));
	    }
	}
	return new String(buffer);
    }
    
    /**
     * Dumps padded text. This is a simple tool for helping dump text 
     * with padding to a Writer.
     *
     * @param pw the stream to send the output
     * @param padding the number of spaces in the string
     * @param string the string to output
     */
    public static void dump(PrintWriter pw, int padding, String string) {
	pw.print(pad(padding));
	pw.println(string);
    }

    /**
     * Returns an input stream for the given URL. If the URL
     * is pointing to a local file, returns a file input stream
     * suitable for MemoryMapped IO, otherwise, returns a buffered
     * input stream.
     *
     * @param url the url to open as a stream
     * @return the stream associated with the URL
     *
     * @throws IOException if there is trouble creating the stream
     */
    public static InputStream getInputStream(URL url) throws IOException {
	if (url.getProtocol().equals("file")) {
	    return new FileInputStream(url.getFile());
	} else {
	    return url.openStream();
	}
    }

    /**
     * Outputs a string to the given stream.
     *
     * @param dos the stream
     * @param s the string to output
     *
     * @throws IOException if an I/O error occurs
     */
    public static void outString(DataOutputStream dos, String s) 
			throws IOException {
	dos.writeShort((short) s.length());
	for (int i = 0; i < s.length(); i++) {
	    dos.writeChar(s.charAt(i));
	}
    }

    /**
     * Inputs a string from a DataInputStream.
     *
     * @param dis the stream
     *
     * @return  the string 
     *
     * @throws IOException if an I/O error occurs
     */
    public static String getString(DataInputStream dis) throws IOException {
	int size = dis.readShort();
	char[] charBuffer = new char[size];
	for (int i = 0; i < size; i++) {
	    charBuffer[i] = dis.readChar();
	}
	return new String(charBuffer, 0, size);
    }

    /**
     * Inputs a string from a ByteBuffer.
     *
     * @param bb the input byte buffer
     *
     * @return  the string 
     *
     * @throws IOException if an I/O error occurs
     */
    public static String getString(ByteBuffer bb) throws IOException {
	int size = bb.getShort();
	char[] charBuffer = new char[size];
	for (int i = 0; i < size; i++) {
	    charBuffer[i] = bb.getChar();
	}
	return new String(charBuffer, 0, size);
    }


    /**
     * Gets a property by name and returns its value. If the property
     * cannot be found, the default is returned
     *
     * @param name the name of the property
     *
     * @param defaultValue the default value to use if the property
     * cannot be found.
     *
     * @return the string value for the property, or the defaultValue if 
     *  the property cannot be found
     */
    public static String getProperty(String name, String defaultValue) {
	String value;
	try {
	    value = System.getProperty(name, defaultValue);
	} catch (SecurityException se) {
	    value = defaultValue;
	}
	return value;
    }

    /**
     * Gets a boolean property by name. 
     *
     * @param name the name of the property
     *
     * @return  If there is no property with the specified name, or 
     *  if the specified name is empty or null, then false is returned. 
     *  otherwise the boolean value of the property is returned
     *
     */
    public static boolean getBoolean(String name) {
	boolean value;
	try {
	    value = Boolean.getBoolean(name);
	} catch (SecurityException se) {
	    value = false;
	}
	return value;
    }

    /**
     * Gets a long property by name. 
     *
     * @param name the name of the property
     *
     * @param defaultValue the default value to use if the property
     * cannot be found.
     *
     * @return the long value for the property, or the defaultValue if 
     *  the property cannot be found
     *
     */
    public static Long getLong(String name, long defaultValue) {
	Long value;
	try {
	    value = Long.getLong(name, defaultValue);
	} catch (SecurityException se) {
	    value = new Long(defaultValue);
	}
	return value;
    }

    /**
     * Gets an Integer property by name. 
     *
     * @param name the name of the property
     *
     * @param defaultValue the default value to use if the property
     * cannot be found.
     *
     * @return the Integer value for the property, or the defaultValue if 
     *  the property cannot be found
     *
     */
    public static Integer getInteger(String name, int defaultValue) {
	Integer value;
	try {
	    value = Integer.getInteger(name, defaultValue);
	} catch (SecurityException se) {
	    value = new Integer(defaultValue);
	}
	return value;
    }
    
}

  
