/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of CosyBeans.
    *
    * CosyBeans 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, either version 3 of the License, or
    * (at your option) any later version.
   *
   * CosyBeans 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 CosyBeans.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.gui.displayers;
  
  import java.io.IOException;
  import java.io.ObjectStreamException;
  import java.io.Serializable;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  /**
   * DisplayerParameters holds various properties of some displayed value. These
   * properties can be anything that specify a displayable value (Color, name etc)
   * and should also hold information about remote connection that displayed value
   * is referred to. DisplayerParameters is a serializable object.
   * 
   * @author Jaka Bobnar, Cosylab
   * 
   */
  public class DisplayerParameters implements Serializable {
  
  	private static final long serialVersionUID = 794831250607895558L;
  	protected String name;
  	transient protected String[] names;
  	transient protected Map<String, Object> values;
  
  	/**
  	 * Creates new instance of DisplayerParameters.
  	 */
  	public DisplayerParameters(String name) {
  		this(name, 10);
  	}
  
  	/**
  	 * Creates new instance of DisplayerParameters.
  	 */
  	public DisplayerParameters(String name, int size) {
  		this.name = name;
  		values = new HashMap<String, Object>(size);
  	}
  
  	/**
  	 * Creates new instance of DisplayerParameters.
  	 */
  	protected DisplayerParameters(String name, List<String> names, List values) {
  		this.name = name;
  		this.values = new HashMap<String, Object>(names.size());
  		for (int i = 0; i < names.size(); i++) {
  			this.values.put(names.get(i), values.get(i));
  		}
  	}
  
  	/**
  	 * Creates new instance of DisplayerParameters.
  	 */
  	protected DisplayerParameters(String name, String[] names, Object[] values) {
  		this.name = name;
  		this.values = new HashMap<String, Object>(names.length);
  		for (int i = 0; i < names.length; i++) {
  			this.values.put(names[i], values[i]);
  		}
  	}
  
  	protected DisplayerParameters(String name, int size, double min,
  			double max, String units, String format) {
  		this(name, size);
  		values.put(Displayer.C_MINIMUM, min);
  		values.put(Displayer.C_MAXIMUM, max);
  		values.put(Displayer.C_UNITS, units);
  		values.put(Displayer.C_FORMAT,format);
  	}
  
  	protected DisplayerParameters(String name, int size, DoubleDisplayer disp) {
  		this(name, size, disp.getMinimum(), disp.getMaximum(), disp.getUnits(),
  				disp.getFormat());
  	}
  	
  	/**
  	 * Constructs new DisplayerParameters with the given name. The rest
  	 * of the parameters will be extracted from the displayer.
 	 * 
 	 * @param name the name paramete
 	 * @param disp source of parameters
 	 */
 	public DisplayerParameters(String name, DoubleDisplayer disp) {
 		this(name, 4, disp.getMinimum(), disp.getMaximum(), disp.getUnits(),
 				disp.getFormat());
 	}
 
 	/**
 	 * Constructs new DisplayerParameters with the given values.
 	 * 
 	 * @param name
 	 * @param min
 	 * @param max
 	 * @param units
 	 * @param format
 	 */
 	public DisplayerParameters(String name, double min, double max,
 			String units, String format) {
 		this(name, 4, min, max, units, format);
 	}
 
 	/**
 	 * Constructs new DisplayerParameters with the given name and values
 	 * listed in the Map.
 	 * 
 	 * @param name the name parameter
 	 * @param values optional parameters
 	 */
 	public DisplayerParameters(String name, Map<String, Object> values) {
 		this(name);
 		this.values.putAll(values);
 	}
 
 	/**
 	 * Adds a parameter with the given name.
 	 * 
 	 * @param name the name of the parameter
 	 * @param value the parameter
 	 * @return previous value under the given name
 	 */
 	public Object addParameter(String name, Object value) {
 		names=null;
 		return values.put(name, value);
 	}
 
 	/**
 	 * Puts a parameter under the given name. This method does not trigger
 	 * refresh of the parameters names.
 	 * 
 	 * @param name the name of the parameter
 	 * @param value the replacement parameter
 	 * @return the previous parameter under the given name
 	 */
 	public Object putParameter(String name, Object value) {
 		return values.put(name, value);
 	}
 
 	/**
 	 * Returns the parameter under the given name.
 	 * 
 	 * @param name the name of the parameter
 	 * @return the parameter
 	 */
 	public Object getParameter(String name) {
 		return values.get(name);
 	}
 
 	/**
 	 * Returns the name.
 	 * 
 	 * @return Returns the name.
 	 */
 	public String getName() {
 		return name;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see java.lang.Object#toString()
 	 */
 	@Override
 	public String toString() {
 		String[] n= getNames();
 		
 		StringBuilder s = new StringBuilder(32 * n.length);
 		s.append(name);
 		s.append("::{ ");
 		if (0 < n.length) {
 			s.append(n[0]);
 			s.append("=");
 			s.append(values.get(n[0]));
 		}
 		for (int i = 1; i < n.length; i++) {
 			s.append(", ");
 			s.append(n[i]);
 			s.append("=");
 			s.append(values.get(n[i]));
 		}
 		s.append('}');
 		return s.toString();
 	}
 
 	/**
 	 * @return the format
 	 */
 	public String getFormat() {
 		return (String)values.get(Displayer.C_FORMAT);
 	}
 
 	/**
 	 * @return the maximum
 	 */
 	public double getMaximum() {
 		return getDouble(Displayer.C_MAXIMUM);
 	}
 
 	/**
 	 * @return the minimum
 	 */
 	public double getMinimum() {
 		return getDouble(Displayer.C_MINIMUM);
 	}
 
 	protected double getDouble(String name) {
 		Object o = values.get(name);
 		if (o instanceof Number) {
 			return ((Number)o).doubleValue();
 		}
 		return Double.NaN;
 	}
 
 	protected int getInt(String name) {
 		Object o = values.get(name);
 		if (o instanceof Number) {
 			return ((Number)o).intValue();
 		}
 		return 0;
 	}
 	
 	protected boolean getBool(String name) {
 		Object o= values.get(name);
 		return (o instanceof Boolean) && ((Boolean)o).booleanValue();
 	}
 
 	/**
 	 * @return the units
 	 */
 	public String getUnits() {
 		return (String)values.get(Displayer.C_UNITS);
 	}
 
 	/**
 	 * Returns the names of all parameters.
 	 * 
 	 * @return
 	 */
 	public String[] getNames() {
 		if (names!=null) {
 			return names;
 		}
 		names= values.keySet().toArray(new String[values.size()]);
 		Arrays.sort(names);
 		return names;
 	}
 
 	/**
 	 * Returns the values of all parameters
 	 * @return
 	 */
 	public Object[] getValues() {
 		String[] n= getNames();
 		Object[] o= new Object[values.size()];
 		for (int i = 0; i < o.length; i++) {
 			o[i]=values.get(n[i]);
 		}
 		return o;
 	}
 
 	/**
 	 * Returns the number of all parameters.
 	 * 
 	 * @return
 	 */
 	public int count() {
 		return values.size();
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see java.lang.Object#equals(java.lang.Object)
 	 */
 	@Override
 	public boolean equals(Object o) {
 		if (!(o instanceof DisplayerParameters))
 			return false;
 		DisplayerParameters p = (DisplayerParameters)o;
 		Object[] val = p.getValues();
 		String[] names = p.getNames();
 		return (Arrays.equals(val, getValues()) && Arrays.equals(names,
 				getNames()));
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see java.lang.Object#hashCode()
 	 */
 	@Override
 	public int hashCode() {
 		return toString().hashCode();
 	}
 	
 	private void writeObject(java.io.ObjectOutputStream out) throws IOException {
 		out.defaultWriteObject();
 		String[] n= getNames();
 		Object[] o= getValues();
 		out.writeObject(n);
 		out.writeObject(o);
 	}
 	private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
 		in.defaultReadObject();
 		String[] n= (String[])in.readObject();
 		Object[] o= (Object[])in.readObject();
 		 
 		values= new HashMap<String, Object>(n.length);
 		for (int i = 0; i < o.length; i++) {
 			values.put(n[i], o[i]);
 		}
 	}
 	@SuppressWarnings("unused")
 	private void readObjectNoData() throws ObjectStreamException {
 		values= new HashMap<String, Object>(0);
 	}
 }
 
 /* __oOo__ */