/*
    *  XNap - A P2P framework and client.
    *
    *  See the file AUTHORS for copyright information.
    *
    *  This program is free software; you can redistribute it and/or modify
    *  it under the terms of the GNU General Public License as published by
    *  the Free Software Foundation.
    *
   *  This program is distributed in the hope that it will be useful,
   *  but WITHOUT ANY WARRANTY; without even the implied warranty of
   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   *  GNU General Public License for more details.
   *
   *  You should have received a copy of the GNU General Public License
   *  along with this program; if not, write to the Free Software
   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
  package org.xnap.gui.component;
  
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  
  import javax.swing.Box;
  import javax.swing.BoxLayout;
  import javax.swing.JComboBox;
  import javax.swing.*;
  
  import org.xnap.XNap;
  
  /***
   * This class provides a box with a combo box selector and a number input
   * field for a minimum value and maximum value.
   */
  public class RangeBox extends Box implements ActionListener {
  
      //--- Constant(s) ---
  
      //--- Data field(s) ---
  
      private JComboBox jcbCompare;
      private ValidatedTextField jtMinValue;
      private JLabel jlAnd;
      private ValidatedTextField jtMaxValue;
  	private JComponent unitComponent;
      
      //--- Constructor(s) ---
      
      /***
       * Constructs the range box.
       */
      public RangeBox() 
      {
  		super(BoxLayout.X_AXIS);
      
  		jcbCompare = new JComboBox();
  		jcbCompare.addItem(new CompareNotActive());
  		jcbCompare.addItem(new CompareAtLeast());
  		jcbCompare.addItem(new CompareEquals());
  		jcbCompare.addItem(new CompareAtBest());
  		jcbCompare.addItem(new CompareBetween());
  		jcbCompare.addActionListener(this);
  		add(jcbCompare);
  	    
  		jtMinValue 
  			= new ValidatedTextField("", 3, ValidatedTextField.NUMBERS_INT);
  		jtMinValue.setMinimumSize(jtMinValue.getPreferredSize());
  		jtMinValue.setVisible(false);
  		add(jtMinValue);
  
  		jlAnd = new JLabel(XNap.tr("and", 1));
  		jlAnd.setVisible(false);
  		add(jlAnd);
  
  		jtMaxValue 
  			= new ValidatedTextField("", 3, ValidatedTextField.NUMBERS_INT);
  		jtMaxValue.setMinimumSize(jtMaxValue.getPreferredSize());
  		jtMaxValue.setVisible(false);
  		add(jtMaxValue);
      }
  
      //--- Method(s) ---
      
      /***
       * Invoked when an item is selected.
       */
      public void actionPerformed(ActionEvent e) 
      {
  		getSelectedItem().selected();
  		jlAnd.setVisible(jtMinValue.isVisible() && jtMaxValue.isVisible());
  		if (unitComponent != null) {
  			unitComponent.setVisible
  				(jtMinValue.isVisible() || jtMaxValue.isVisible());
  		}
      }
  
      /***
       * Returns the max value.
 	 *
 	 * @return -1, if not set
      */
     public int getMaxValue()
     {
 		return getSelectedItem().getMaxValue();
     }
 
     /***
      * Returns the min value.
 	 *
 	 * @return -1, if not set
      */
     public int getMinValue()
     {
 		return getSelectedItem().getMinValue();
     }
 
 	public void setUnitComponent(JComponent unitComponent)
 	{
 		if (this.unitComponent != null) {
 			remove(unitComponent);
 		}
 
 		this.unitComponent = unitComponent;
 		if (this.unitComponent != null) {
 			this.unitComponent.setVisible
 				(jtMinValue.isVisible() || jtMaxValue.isVisible());
 			add(this.unitComponent);
 		}
 	}
 
     public void setValues(int min, int max)
     {
 		for (int i = 0; i < jcbCompare.getItemCount(); i++) {
 			AbstractCompareItem item
 				= (AbstractCompareItem)jcbCompare.getItemAt(i);
 			if (item.set(min, max)) {
 				item.selected();
 				return;
 			}
 		}
     }
 
     /***
      * Returns the currently selected compare item.
      */
     private AbstractCompareItem getSelectedItem() 
     {
 		return (AbstractCompareItem)jcbCompare.getSelectedItem();
     }
 
     //--- Inner Class(es) ---
 
     private abstract class AbstractCompareItem
     {
 	
 		public boolean needsMinValue;
 		public boolean needsMaxValue;
 
 		public AbstractCompareItem(boolean needsMinValue, boolean needsMaxValue)
 		{
 			this.needsMinValue = needsMinValue;
 			this.needsMaxValue = needsMaxValue;
 		}
 
 		public void selected()
 		{
 			jtMinValue.setVisible(needsMinValue);
 			jtMaxValue.setVisible(needsMaxValue);
 			RangeBox.this.validate();
 		}
 
 		public int getMaxValue()
 		{
 			return jtMaxValue.isVisible() ? jtMaxValue.getIntValue() : -1;
 		}
 
 		public int getMinValue()
 		{
 			return jtMinValue.isVisible() ? jtMinValue.getIntValue() : -1;
 		}
 
 		/***
 		 * Returns true, if using this compare type makes sense.
 		 */ 
 		public boolean set(int min, int max)
 		{
 			if ((min == -1 ^ needsMinValue) && (max == -1 ^ needsMaxValue)) {
 				jtMinValue.setText((needsMinValue) ? min + "" : "");
 				jtMaxValue.setText((needsMaxValue) ? max + "" : "");
 		
 				return true;
 			}
 
 			return false;
 		}
 	
     }
 
     private class CompareNotActive extends AbstractCompareItem
     {
 
 		public CompareNotActive()
 		{
 			super(false, false);
 		}
 
 		public String toString()
 		{
 			return "";
 		}
 
     }
 
     private class CompareAtLeast extends AbstractCompareItem
     {
 
 		public CompareAtLeast()
 		{
 			super(true, false);
 		}
 
 		public String toString()
 		{
 			return XNap.tr("at least");
 		}
 
     }
 
     private class CompareAtBest extends AbstractCompareItem
     {
 
 		public CompareAtBest()
 		{
 			super(false, true);
 		}
 	
 		public String toString()
 		{
 			return XNap.tr("at best");
 		}
 
     }
 
     private class CompareBetween extends AbstractCompareItem
     {
 
 		public CompareBetween()
 		{
 			super(true, true);
 		}
 
 		public String toString()
 		{
 			return XNap.tr("between");
 		}
 
 		public boolean set(int min, int max)
 		{
 			if ((min != -1) && (max != -1) && (max != min)) {
 				jtMinValue.setText(min + "");
 				jtMaxValue.setText(max + "");
 		
 				return true;
 			}
 
 			return false;
 		}
 
     }
 
     private class CompareEquals extends AbstractCompareItem
     {
 
 		public CompareEquals()
 		{
 			super(true, false);
 		}
 
 		public int getMaxValue()
 		{
 			return jtMinValue.getIntValue();
 		}
 
 		public int getMinValue()
 		{
 			return jtMinValue.getIntValue();
 		}
 
 		public String toString()
 		{
 			return XNap.tr("equals");
 		}
 
 		public boolean set(int min, int max)
 		{
 			if ((min != -1) && (max != -1) && (max == min)) {
 				jtMinValue.setText(min + "");
 				jtMaxValue.setText("");
 		
 				return true;
 			}
 
 			return false;
 		}
 
     }
 
 }