package common.utility;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.StringTokenizer;

/**
 * Classe di utilita&grave; per la gestione e la formattazione
 * delle stringhe.
 *
 * @author olienr
 */
public class StringUtilities {

	/**
	 * Splitta il testo in tante righe di lunghezza <tt>maxRowLen</tt>.
	 * Il testo viene diviso inizialmente per i singoli token
	 * secondo le politiche della classe <tt>StringTokenizer</tt>.
	 * Se una parola supera la lunghezza massima viene messa tutta
	 * sulla stessa riga.
	 * Se il testo ? vuoto il metodo ritorna un array di stringhe
	 * contenente solo la stringa vuota.
	 *
	 * @param testo - testo da splittare
	 * @param maxRowLen - lunghezza massima consentita
	 * @return - array di stringhe concatenate di lunghezza massima <tt>maxRowLen</tt>
	 */
	public static String[] split(String testo, int maxRowLen) {

		List<String> righe = new ArrayList<String>();
		StringTokenizer testoTkn = new StringTokenizer(testo);

		String primoTkn;
		/* se vuoto torno array stringa con un elemento: "" */
		if (!empty(testo)){
			primoTkn = testoTkn.nextToken();
		}
		else {
			return new String [] {""};
		}

		int i = 0;
		righe.add(i, primoTkn);

		String tmp;
		String oldToken;
		while (testoTkn.hasMoreTokens()) {
			tmp = testoTkn.nextToken();
			oldToken = righe.get(i);
			if ((oldToken + " " + tmp).length() > maxRowLen) {
				i++;
				righe.add(i, tmp);
			}
			else {
				/*
				 * non shifta elemento come add, ma
				 * lo rimuove e lo inserisce.
				 */
				righe.set(i, oldToken + " " + tmp);
			}
		}

		return righe.toArray(new String[righe.size()]);
	}

	/**
	 * Verifica se una string e&grave; vuota o non esiste
	 *
	 * @param la stringa da contrllare
	 * @return true se la stringa e&grave; vuota o non esiste
	 */
	public static boolean empty(String value) {
		return (value == null || value.length() == 0);
	}
	
	public static boolean empty(String value, boolean trim) {
		String _value = value != null ? value : "";
		_value = trim ? _value.trim() : _value;
		return _value.length() == 0;
		 
	}

	/**
	 * Ritorna una stringa con la prima lettera maiuscola
	 * @param value
	 * @return
	 */
	public static String capitalize(String value) {
		if( empty(value) ) return value;
		String firstLetter = value.substring(0,1);
	    String remainder   = value.substring(1);
	    return firstLetter.toUpperCase() + remainder;
	}
	

	
/*FILLER STRING*/	
	public enum FillerPosition {FILL_LEFT, FILL_RIGHT}
	/**
	 * Filla una stringa <code>value</code>, di default a dx, per una lunghezza pari a <code>length</code> 
	 * usando il carattere <code>filler</code>
	 * @param value
	 * @param length
	 * @param filler
	 * @return
	 */
	public static String fillString(String value, final int length, final char filler){
		return fillString(value, length, filler, FillerPosition.FILL_RIGHT);
	}
	/**
	 * Filla una stringa <code>value</code> per una lunghezza pari a <code>length</code> 
	 * usando il carattere <code>filler</code>
	 * @param value
	 * @param length
	 * @param filler
	 * @param position indica se fillare a destra o a sinistra del valore
	 * @return
	 */
	public static String fillString(String value, final int length, final char filler, final FillerPosition position){
		if (value.length() >= length) 
			return value;
		char[] valoreIniziale = value.toCharArray();
		char[] valoreFinale = new char[length];
		Arrays.fill(valoreFinale, filler);
		
		int startPosFill = 0;
		if (position == FillerPosition.FILL_LEFT){
			startPosFill = valoreFinale.length -  valoreIniziale.length;
		}
		
		for (int i = 0; i < valoreIniziale.length; i++){
			valoreFinale[startPosFill + i] = valoreIniziale[i];
		}
		
		return new String(valoreFinale);
	}

	/**
	 * Converte una lista di stringhe separando i singoli elementi
	 * con un separatore. 
	 * @param lista di stinghe
	 * @param token il separatore
	 * @return
	 */
	public static String convertiInRiga(List<String> lista, String separatore) {
		StringBuffer buf = new StringBuffer();
		Iterator<String> i = lista.iterator();
		boolean hasNext = i.hasNext();
		while (hasNext) {
			String o = i.next();
			buf.append(o);
			hasNext = i.hasNext();
			if (hasNext)
				buf.append(separatore);
		}
		return buf.toString();
	}

	/**
	 * Resitituisce la parte pi? a sinistra di una stringa, controllando di non eccedere 
	 * la capienza massima di caratteri
	 * 
	 * Simone 02.09.2008
	 * @param string
	 * @param maxlen
	 * @return
	 */
	public static String leftString(String string, int maxlen){
		
		int max = string.length() >= maxlen ? maxlen : string.length(); 
		
		return string.substring(0,max);
	}

	public static String onlyNum(String s) {
		return s.replaceAll("[^0-9.,]+","");
	}
}
