/**
 *   analizzatore di testo
 *
 *  @autor Adriano Luchetta
 *  @version 31-Ott-2005
 *  @version 21-Ott-2005
 *  @version 6-Nov-2004
 *  @version 31-Ott-2003

*/
import java.util.Scanner;

public class AnalizzatoreDiTesto
{
   //parte privata
   private String[] testo;
   private int testoSize;

   /**
      costruttore di un analizzatore di testo vuoto
   */
   public AnalizzatoreDiTesto()
   {
      testo = new String[1];
      testoSize = 0;
   }

   /**
      verifica se il testo e' vuoto
      @return true se l'analizzatore non contiene testo, false altrimenti
   */
   public boolean vuoto()
   {
      return testoSize == 0;
   }

   /**
      aggiunge una stringa in coda al testo.
      Il metodo ritorna se String stringa e' uguale a null.
      @param stringa la parola da aggiungere
   */
   public void aggiungi(String stringa)
   {
      if (stringa == null)
         return;

      //array dinamico
      if (testoSize >= testo.length)
      {
         String[] nuovoTesto = new String[2 * testo.length];
         for (int i = 0; i < testo.length; i++)
            nuovoTesto[i] = testo[i];
         testo = nuovoTesto;
      }

      //inserimento della parola e aggiornamento del contatore delle parole
      testo[testoSize] = stringa;
      testoSize++;
   }
   
   /**
      conta il numero di stringhe nel testo
      @return il numero delle parole
   */
   public int conta()
   {
      return testoSize;
   }

   /**
      separa le stringhe del testo in parole. Crea un nuovo oggetto di classe
      AnalizzatoreDiTesto in cui tutte le parole sono separate
      @return un analizzatore di testo in cui tutte le parole sono separate
   */
   public AnalizzatoreDiTesto separa()
   {
      //nuovo oggetto di classe AnalizzatoreDiTesto
      AnalizzatoreDiTesto tmpTesto = new AnalizzatoreDiTesto();

      //inserimento delle parole nel nuovo Analizzatore di Testo
      for (int i = 0; i < testoSize; i++)
      {
         Scanner st = new Scanner(testo[i]);

         while (st.hasNext())
            tmpTesto.aggiungi(st.next());
      }

      //restituisce l'analizzatore di testo
      return  tmpTesto;
   }

   /**
      elimina una stringa dal testo.
      Se la stringa compare piu' volte vengono eliminate tutte le occorrenze.
      Il metodo lancia IllegalArgumentException se String parola vale null.
      Attenzione: si devono scandire tutte le stringhe del testo perche'
      la parola da cancellare puo' comparire piu' volte nel testo.
      NB: il metodo modifica il parametro implicito
      @param stringa stringa da eliminare
      @return un analizzatore di testo privo della stringa da cancellare
      @throws IllegalArgumentException
   */
   public AnalizzatoreDiTesto elimina(String stringa)
   {
      if (stringa == null)
         throw new IllegalArgumentException();

      //Elimina la stringa
      for (int i = 0; i < testoSize; i++)
      {
         if (testo[i].equals(stringa))
         {
           //ricompatta l'array
           for (int j = i; j < testoSize - 1; j++)
              testo[j] = testo[j + 1];
              
           testoSize--;
         }
      }

      AnalizzatoreDiTesto tmpTesto = copia();

      //restituisce l'oggetto
      return tmpTesto;
   }

   /**
      calcola quante volte una stringa compare nel testo
      @param stringa la stringa di cui calcola l'occorrenza
      @return quante volte stringa compare nel testo
      @throws IllegalArgumentException
   */
   public int frequenza(String stringa)
   {
      if (stringa == null)
         throw new IllegalArgumentException();

      int cont = 0;
   	
      for (int i = 0; i < testoSize; i++)
         if (testo[i].equals(stringa))
            cont++;
   	 
      return cont;
   }
   
   /**
      ritorna la stringa che compare piu' volte nel testo (frequenza massima).
      Se piu' stringhe hanno frequenza massima, ne ritorna una qualsiasi.
      Se il testo è vuoto ritorna null.
      @return una delle stringhe con frequenza massima
   */
   public String frequenzaMax()
   {
      String max = testo[0];

      for (int i = 0; i < testoSize; i++)
         if ( frequenza(testo[i]) > frequenza(max))
            max = testo[i];
            
      return max;
   }

   /**
      restituisce la prima stringa del testo in ordine lessicografico.
      Se il testo è vuoto ritorna null.
      @return prima stringa in ordine lessicografico
   */
   public String minimo()
   {
      String minStr = testo[0];
   	
      for (int i = 0; i < testoSize; i++)
         if (testo[i].compareTo(minStr) < 0)
            minStr = testo[i];

      return minStr;
   }
   
   /**
      restituisce l'ultima stringa del testo in ordine lessicografico.
      Se il testo è vuoto ritorne null.
      @return ultima parola in ordine lessicografico
   */
   public String massimo()
   {
      String maxStr = testo[0];
   	
      for (int i = 0; i < testoSize; i++)
         if (testo[i].compareTo(maxStr) > 0)
            maxStr = testo[i];
   	
      return maxStr;
   }

   /**
      trasforma in stringa il testo. Viene inserito un carattere di nuova riga (\n)
      fra le stringhe.
      Se il testo è vuoto ritorna la stringa vuota "".
      @return stringa contenente il testo
   */
   public String toString()
   {
      String str = "";
      for (int i = 0; i < testoSize; i++)
         str = str + testo[i] + "\n";

      return str;
   }

   /**
      cancella i caratteri non alfabetici dalle parole del testo.
      Ad esempo elimina la punteggiatura, i numeri, le parentesi.
      Usa il metodo java.lang.Character.isLetter(char c)
      @return un analizzatore di testo dove il testo e' privo di punteggiatura
   */
   public AnalizzatoreDiTesto soloLettere()
   {
      AnalizzatoreDiTesto tmpTesto = new AnalizzatoreDiTesto();

      for (int i = 0; i < testoSize; i++)
      {
         String tmpStr = "";
         for (int j = 0; j < testo[i].length(); j++)
         {
            char c = testo[i].charAt(j);
            if (Character.isLetter(c))
               tmpStr = tmpStr + c;
         }
         if (tmpStr.length() != 0)
            tmpTesto.aggiungi(tmpStr);
      }

      // restituisce il nuovo analizzatore di testo
      return tmpTesto;
   }
   
   /**
      trasforma nel testo i caratteri maiuscoli in minuscoli.
      @return un analizzatore di testo con caratteri minuscoli al posto di maiuscoli
   */
   public AnalizzatoreDiTesto minuscolo()
   {
      AnalizzatoreDiTesto tmpTesto = new AnalizzatoreDiTesto();

      for (int i = 0; i < testoSize; i++)
         tmpTesto.aggiungi(testo[i].toLowerCase());

      return tmpTesto;
   }
   
   /**
      crea una copia dell'oggetto AnalizzatoreDiTesto.
      @return riferimento alla copia
   */
   public AnalizzatoreDiTesto copia()
   {
      AnalizzatoreDiTesto tmpTesto = new AnalizzatoreDiTesto();
   	
      for (int i = 0; i < testoSize; i++)
         tmpTesto.aggiungi(testo[i]);
   	   
      return tmpTesto;
   }
}