/*
    * 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.adapters;
  
  import java.awt.Component;
  import java.awt.GridBagConstraints;
  import java.awt.GridBagLayout;
  import java.awt.Insets;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.beans.PropertyVetoException;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  
  import javax.swing.JButton;
  import javax.swing.JDialog;
  import javax.swing.JFrame;
  import javax.swing.JLabel;
  import javax.swing.JPanel;
  
  import com.cosylab.gui.components.NumberField;
  
  
  /**
   * A utility class for Converter manipulation.
   * 
   * @author Jaka Bobnar, Cosylab
   *
   */
  public class ConverterUtilities {
  	
  	protected static class CustomizerDialog extends JDialog {
  		
  		private static final long serialVersionUID = 1L;
  		
  		private JButton okButton = null, cancelButton = null;
  		private JPanel panel;
  		private JPanel contentPanel;
  		private HashMap<String, NumberField> fields = new HashMap<String, NumberField>();
  		private HashMap<String, Number> result;
  		private JLabel functionLabel;
  		private boolean okPressed = false;
  				
  		public CustomizerDialog() {
  			setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
  			setModal(true);
  			setResizable(false);
  			setSize(400, 300);
  			setContentPane(getContentPanel());
  //			addWindowListener(new WindowAdapter(){
  //				@Override
  //				public void windowClosing(WindowEvent e) {
  //					result = new HashMap<String, Number>();
  //					Iterator<String> it = fields.keySet().iterator();
  //					String key;
  //					while(it.hasNext()) {
  //						key = it.next();
  //						result.put(key, fields.get(key).getValue());
  //					}
  //				}
  //			});
  			pack();
  		}
  		
  		private JPanel getContentPanel() {
  			if (contentPanel == null) {
  				contentPanel = new JPanel(new GridBagLayout());
  				contentPanel.add(getPanel(), new GridBagConstraints(0, 0, 2, 1, 1, 1, GridBagConstraints.CENTER, GridBagConstraints.HORIZONTAL, new Insets(11, 11, 3, 11), 0, 0));
  				
  				JPanel buttonPanel = new JPanel(new GridBagLayout());
  				okButton = new JButton("OK");
  				okButton.addActionListener(new ActionListener(){
  					public void actionPerformed(ActionEvent e) {
  						result = new HashMap<String, Number>();
  						Iterator<String> it = fields.keySet().iterator();
  						String key;
  						while(it.hasNext()) {
  							key = it.next();
  							result.put(key, fields.get(key).getValue());
  						}
  						okPressed = true;
 						dispose();
 					}
 				});
 				contentPanel.add(getFunctionLabel(), new GridBagConstraints(0, 1, 2, 1, 0, 0, GridBagConstraints.WEST, GridBagConstraints.NONE, new Insets(5, 11, 5, 12), 0, 0));
 				
 				buttonPanel.add(okButton, new GridBagConstraints(0, 0, 1, 1, 1, 0, GridBagConstraints.EAST, GridBagConstraints.NONE, new Insets(0, 0, 0, 2), 0, 0));
 				cancelButton = new JButton("Cancel");
 				cancelButton.addActionListener(new ActionListener(){
 					public void actionPerformed(ActionEvent e) {
 						okPressed = false;
 						dispose();
 					}
 				});
 				buttonPanel.add(cancelButton, new GridBagConstraints(1, 0, 1, 1, 1, 0, GridBagConstraints.EAST, GridBagConstraints.NONE, new Insets(0, 2, 0, 0), 0, 0));
 				
 				contentPanel.add(buttonPanel, new GridBagConstraints(0,2,2,1,1,0,GridBagConstraints.EAST, GridBagConstraints.NONE,new Insets(11,11,11,12),0,0));
 			}
 			return contentPanel;
 		}
 		
 		private JPanel getPanel() {
 			if (panel == null) {
 				panel = new JPanel(new GridBagLayout());
 			}
 			return panel;
 		}
 		
 		private JLabel getFunctionLabel(){
 			if (functionLabel == null) {
 				functionLabel = new JLabel();
 			}
 
 			return functionLabel;
 		}
 		
 		private void setFunctionLabelText(Converter c){
 			if (c instanceof IdentityConverter){
 				getFunctionLabel().setText("<OUTPUT> = <INPUT>");
 			}else if (c instanceof MultiplierConverter){
 				getFunctionLabel().setText("<OUTPUT> = Factor * <INPUT>");
 			}else if (c instanceof LinearConverter){
 				getFunctionLabel().setText("<OUTPUT> = Factor * <INPUT> + Shift");
 			}else if (c instanceof PotentialConverter){
 				getFunctionLabel().setText("<OUTPUT> = <INPUT> ^ Exponent");
 			}else if (c instanceof ExponentialConverter){
 				getFunctionLabel().setText("<OUTPUT> = Base ^ <INPUT>");
 			}else if (c instanceof LogarithmicConverter){
 				getFunctionLabel().setText("<OUTPUT> = log_Base(<INPUT>)");
 			}
 		}
 		
 		public void initialize(String[] names) {
 			panel.removeAll();
 			fields.clear();
 			for (int i = 0; i < names.length; i++) {
 				getPanel().add(new JLabel(names[i] + ": "), new GridBagConstraints(0, i, 1, 1, 0.3, 0, GridBagConstraints.WEST, GridBagConstraints.HORIZONTAL, new Insets(1, 0, 1, 0), 0, 0));
 				NumberField field = new NumberField();
 				fields.put(names[i],field);
 				getPanel().add(field, new GridBagConstraints(1, i, 1, 1, 1, 0, GridBagConstraints.EAST, GridBagConstraints.HORIZONTAL, new Insets(1, 0, 1, 0), 0, 0));
 			}
 			setSize(350, 120+names.length*30);
 		}
 		
 		public HashMap<String, Number> showDialog(Map<String, Number> initialValues) {
 			Iterator<String> it = initialValues.keySet().iterator();
 			String key;
 			NumberField field;
 			while(it.hasNext()) {
 				key = it.next();
 				field = fields.get(key);
 				field.setValue(initialValues.get(key));
 				fields.put(key, field);
 			}
 			setVisible(true);
 			return result;
 		}
 		
 		@Override
 		public void setVisible(boolean b) {
 			okPressed = false;
 			super.setVisible(b);
 		}
 		
 		public boolean isOKPressed() {
 			return okPressed;
 		}
 	}
 	
 	
 	protected static HashMap<Converter, CustomizerDialog> cache = new HashMap<Converter, CustomizerDialog>();
 	
 	/**
 	 * Shows a dialog window with converter editor.
 	 * 
 	 * @param parent parent of the dialog
 	 * @param converter converter to be edited
 	 * @return returns true if editing was confirmed or false if it was cancelled
 	 */
 	public static boolean showEditorDialog(Component parent, Converter converter) {
 		CustomizerDialog dialog = cache.remove(converter);
 		if (dialog == null) {
 			dialog = new CustomizerDialog();
 			dialog.initialize(getFieldNames(converter));
 			dialog.setFunctionLabelText(converter);
 		}
 		cache.put(converter, dialog);
 		dialog.setLocationRelativeTo(parent);
 		dialog.setTitle(converter.getName() + " Converter Editor");
 		HashMap<String, Number> map = dialog.showDialog(extractInitialValues(converter));
 		if (dialog.isOKPressed()) {
 			dispatchValues(converter, map);
 			return true;
 		}
 		return false;
 	}
 	
 	/**
 	 * Obtains initial values of converter's fields. Method returns a map of all fields
 	 * with their corresponding values. The name of the field (the key in the map) should
 	 * be the same as returned by getFieldNames(Converter) method.
 	 * 
 	 * @param converter
 	 * @return
 	 */
 	protected static Map<String, Number> extractInitialValues(Converter converter) {
 		HashMap<String, Number> map = new HashMap<String, Number>();
 		if (converter instanceof LinearConverter) {
 			map.put("Factor", ((LinearConverter)converter).getMultiplicationFactor());
 			map.put("Shift", ((LinearConverter)converter).getShift());
 		} else if (converter instanceof MultiplierConverter) {
 			map.put("Factor", ((MultiplierConverter)converter).getMultiplicationFactor());
 		} else if (converter instanceof LogarithmicConverter) {
 			map.put("Base", ((LogarithmicConverter)converter).getBase());
 		} else if (converter instanceof ExponentialConverter) {
 			map.put("Base", ((ExponentialConverter)converter).getBase()); 
 		} else if (converter instanceof PotentialConverter){
 			map.put("Exponent", ((PotentialConverter)converter).getExponent());
 		}
 		return map;
 	}
 	
 	/**
 	 * Sets the converter's fields with new values obtained from the editor dialog.
 	 * 
 	 * @param converter
 	 * @param values
 	 */
 	protected static void dispatchValues(Converter converter, Map<String, Number> values) {
 		if (values == null) values = extractInitialValues(converter);
 		if (converter instanceof LinearConverter) {
 			((LinearConverter)converter).setMultiplicationFactor(values.get("Factor").doubleValue());
 			((LinearConverter)converter).setShift(values.get("Shift").doubleValue());
 		} else if (converter instanceof MultiplierConverter) {
 			((MultiplierConverter)converter).setMultiplicationFactor(values.get("Factor").doubleValue());
 		} else if (converter instanceof LogarithmicConverter) {
 			((LogarithmicConverter)converter).setBase(values.get("Base").doubleValue());
 		} else if (converter instanceof ExponentialConverter) {
 			((ExponentialConverter)converter).setBase(values.get("Base").doubleValue()); 
 		} else if (converter instanceof PotentialConverter){
 			((PotentialConverter)converter).setExponent(values.get("Exponent").doubleValue());
 		}
 		
 	}
 	
 	/**
 	 * Returns the names of the fields that will be visible in the dialog.
 	 * 
 	 * @param converter
 	 * @return
 	 */
 	protected static String[] getFieldNames(Converter converter) {
 		if (converter instanceof LinearConverter) {
 			return new String[]{"Factor", "Shift"};
 		} else if (converter instanceof MultiplierConverter) {
 			return new String[]{"Factor"};
 		} else if (converter instanceof LogarithmicConverter) {
 			return new String[]{"Base"};
 		} else if (converter instanceof ExponentialConverter) {
 			return new String[]{"Base"};
 		} else if (converter instanceof PotentialConverter){
 			return new String[]{"Exponent"};
 		} else 
 			return new String[]{};
 	}
 	
 	/**
 	 * Checks if converter is editable.
 	 * 
 	 * @param converter
 	 * @return true if editable
 	 */
 	public static boolean isEditable(Converter converter) {
 		return (converter instanceof LinearConverter || 
 				converter instanceof MultiplierConverter ||
 				converter instanceof PotentialConverter ||
 				converter instanceof LogarithmicConverter ||
 				converter instanceof ExponentialConverter);
 	}
 	
 	/**
 	 * Composes a function from the given chain of converters. Parameter value is the input
 	 * value that converter transforms. If converter does f(x) this method should
 	 * give a string representing the f(value).
 	 * 
 	 * @param chain
 	 * @param value
 	 * @return
 	 */
 	public static String composeFunctionString(ConverterChain chain, String value) {
 		Converter[] converters = chain.getConverters();
 		for (Converter c : converters) {
 			value = composeFunctionString(c, value);
 		}
 		return value;
 	}
 	
 	/**
 	 * Composes a function from the given converter. Parameter value is the input
 	 * value that converter transforms. If converter does f(x) this method should
 	 * give a string representing the f(value).
 	 * 
 	 * @param converter
 	 * @param value
 	 * @return
 	 */
 	public static String composeFunctionString(Converter converter, String value) {
 		boolean valueStartsWithBracket = false;
 		if (value != null && value.startsWith("(")) {
 			valueStartsWithBracket = true;
 		}
 		if (converter instanceof ConverterChain) {
 			return composeFunctionString((ConverterChain)converter, value);
 		} else if (converter instanceof LinearConverter) {
 			LinearConverter c = (LinearConverter)converter;
 			//String multi = "", sign = "", shift = "";
 			StringBuilder s= new StringBuilder(256);
 			if (c.getMultiplicationFactor() == -1 ) {
 				s.append('-');
 			} else if (c.getMultiplicationFactor() != 1) {
 				s.append(c.getMultiplicationFactor());
 				s.append(" * ");
 			}
 			
 			s.append('(');
 			if (!valueStartsWithBracket) {
 				s.append(' ');
 			}
 			s.append(value);
 			s.append(')');
 
 			if (c.getShift() > 0){
 				s.append(" + ");
 				s.append(c.getShift());
 			}
 			else if (c.getShift() < 0){
 				s.append(" - ");
 				s.append(-c.getShift());
 			}
 			return s.toString();
 		} else if (converter instanceof MultiplierConverter) {
 			MultiplierConverter c = (MultiplierConverter)converter;
 			StringBuilder s= new StringBuilder(256);
 			//String multi = "";
 			if (c.getMultiplicationFactor() == -1 ) {
 				s.append("- ");
 			} else if (c.getMultiplicationFactor() != 1) { 
 				s.append(c.getMultiplicationFactor());
 				s.append(" * ");
 			}
 			s.append('(');
 			if (!valueStartsWithBracket) {
 				s.append(' ');
 			}
 			s.append(value);
 			s.append(')');
 			return s.toString();
 		} else if (converter instanceof ExponentialConverter) {
 			return ((ExponentialConverter)converter).getBase() + "^(" + (valueStartsWithBracket?"":" ") + value + ")"; 
 		} else if (converter instanceof LogarithmicConverter) {
 			LogarithmicConverter c = (LogarithmicConverter)converter;
 			return  "log_" + (c.getBase() == Math.E ? "e" : String.valueOf(c.getBase())) + "(" + (valueStartsWithBracket?"":" ") + value + ")";
 		} else if (converter instanceof PotentialConverter){
 			return "(" + (valueStartsWithBracket?"":" ") + value + ")^" + ((PotentialConverter)converter).getExponent();
 		}
 		else return "(" + (valueStartsWithBracket?"":" ") +value+")";
 	}
 	
 	/**
 	 * Constructs an initialization string used by PropertyEditor.
 	 * @param converter
 	 * @return
 	 */
 	public static String getInitializationString(Converter converter) {
 		if (converter instanceof ConverterChain) {
 			Converter[] conv = ((ConverterChain)converter).getConverters();
 			StringBuffer buffer = new StringBuffer("new " + ConverterChain.class.getName() + "(new " +Converter.class.getName() + "[]{");
 			for (Converter c : conv) {
 				buffer.append(getInitStringInternal(c) + ",");
 			}
 			buffer = new StringBuffer(buffer.substring(0, buffer.length()-1));
 			buffer.append("})");
 			return buffer.substring(0);
 		} else {
 			return getInitStringInternal(converter);
 		}
 	}
 	
 	private static String getInitStringInternal(Converter converter) {
 		StringBuffer str = new StringBuffer("new ");
 		str.append(converter.getClass().getName() + "(");
 		if (converter instanceof LinearConverter) {
 			str.append(((LinearConverter)converter).getMultiplicationFactor() + "," + ((LinearConverter)converter).getShift());
 		} else if (converter instanceof MultiplierConverter) {
 			str.append(((MultiplierConverter)converter).getMultiplicationFactor());
 		} else if (converter instanceof LogarithmicConverter) {
 			str.append(((LogarithmicConverter)converter).getBase());
 		} else if (converter instanceof PotentialConverter) {
 			str.append(((PotentialConverter)converter).getExponent());
 		}
 		str.append(")");
 		return str.substring(0);
 	}
 	
 	/**
 	 * Constructs a converter from a string. The given string is expected to be the same
 	 * as converter.toString() would return.
 	 * 
 	 * @param converterToString
 	 * @return
 	 */
 	public static Converter getConverterFromString(String converterToString) {
 		String[] parameters = converterToString.split(":");
 		if (converterToString.startsWith(MultiplierConverter.SHORT_NAME)) {
 			return new MultiplierConverter(Double.parseDouble(parameters[1].trim()));
 		} else if (converterToString.startsWith(LinearConverter.SHORT_NAME)) {
 			return new LinearConverter(Double.parseDouble(parameters[1].trim()),Double.parseDouble(parameters[2].trim()));
 		} else if (converterToString.startsWith(LogarithmicConverter.SHORT_NAME)) {
 			return new LogarithmicConverter(Double.parseDouble(parameters[1].trim()));
 		} else if (converterToString.startsWith(ExponentialConverter.SHORT_NAME)) {
 			return new ExponentialConverter(Double.parseDouble(parameters[1].trim()));
 		} else if(converterToString.startsWith(PotentialConverter.SHORT_NAME)){
 			return new PotentialConverter(Double.parseDouble(parameters[1].trim()));
 		} else 
 			return new IdentityConverter();
 	}
 	
 	public static void main(String[] args) throws PropertyVetoException {
 		ConverterChain ch = new ConverterChain(new Converter[]{new LogarithmicConverter(5), new LinearConverter(4,3)});
 		System.out.println(getInitializationString(ch));
 	}
 	
 	
 }