/*** DataSetColorModel.java - part of the MirkE (say murky) application for colormetric analysis emphesizing
   kinetics.
   
   Created by: Scott Menor on 21 July, 2004.
   
   Copyright (c) 2004 Arizona State University - Cancer Research Institute. All rights reserved.
   
   MirkE 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 2 of the License, or
  (at your option) any later version.
  
  MirkE 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 MirkE; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  US
  */
  
  package edu.asu.cri.MirkE.gui;
  
  import java.util.*;
  import java.awt.*;
  import java.awt.color.*;
  import edu.asu.cri.MirkE.exceptions.MirkEApplicationException;
  import edu.asu.cri.MirkE.exceptions.MirkEFileNotFoundException;
  import edu.asu.cri.MirkE.exceptions.MirkESystemException;
  import java.io.*;
  import java.beans.*;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import edu.asu.cri.MirkE.*;
  
  /***
  
  @author Scott Menor
  @version 0.3.0, 2 februrary, 2004
  */
  
  public class DataSetColorModel {
  	static Map wavelengthToCIE_XYZ = null;
  	static ICC_ColorSpace rgbSpace;
  
  	 /***
       * Logger
       * */
      private static final Log log = LogFactory.getLog(DataSetColorModel.class);
  
  	/***
  		@param mirke
  	 @param query HQL query
  
  	 @return color
  	 */
  	public static java.awt.Color toColor(MirkE mirke,
  								String query) {
  		// TODO - implement
  		return null;
  	}
  
  	/***
  	 * @param mirke
  	 * @param observableToMinValueMap
  	 * @param observableToMeanValueMap
  	 * @param observableToMaxValueMap
  	 * @return color
  	 * @throws MirkEApplicationException
  	 */
  	public static java.awt.Color toColor(MirkE mirke,
  								Map observableToMinValueMap,
  								Map observableToMeanValueMap,
  								Map observableToMaxValueMap) throws MirkESystemException {
  
  		// TODO - pick a color based on the representation and linear/log scale (for now, ignoring them)
  
  		// TODO - properly add/subtract emission/absorbsion in XYZ space for each observation
  
  		Color color = Color.white;
  
  		Set observableToMeanValueMapSet = observableToMeanValueMap.entrySet();
  		Iterator observableToMeanValueSetIterator = observableToMeanValueMapSet.iterator();
  		while (observableToMeanValueSetIterator.hasNext()) {
  			Map.Entry observableToMeanValueEntry = (Map.Entry)observableToMeanValueSetIterator.next();
  
  			String observableName = observableToMeanValueEntry.getKey().toString();
  
  			//String observableType = observableName.substring(0, 1);
  			String wavelengthString = observableName.substring(2, observableName.indexOf("nm"));
  
  			Integer wavelength = new Integer(wavelengthString);
  
  			double minValue  = ((Double)observableToMinValueMap.get(observableName)).doubleValue();
  			double meanValue = ((Double)observableToMeanValueEntry.getValue()).doubleValue();
  			double maxValue  = ((Double)observableToMaxValueMap.get(observableName)).doubleValue();
  
 			// TODO - get a wavelength number from the observable 
 			//(would be nice to use a Unit class that stores units and measured values separately rather than String 
 			//(just worried about doubling the number of database accesses))
 
 			if (maxValue - minValue != 0) {
 				try {
 				color = wavelengthToColor(wavelength,
 										  (meanValue-minValue)/(maxValue - minValue));
 				} catch(MirkEFileNotFoundException nf){
 				    
 				   throw new MirkESystemException(true);
 				    
 				    	
 				}catch(MirkEApplicationException ex){
 				    
 				    throw new MirkESystemException(true);
 				
 			}
 			}
 		}
 		return color;
 	}
 
 	/***
 
 	 @return wavelengthToCIE_XYZ <code>Map</code> from wavelength in nm to a <code>Vector</code> containing components of a corresponding CIE_XYZ color
 	 */
 
 public static Map getWavelengthToCIE_XYZ() throws  MirkEFileNotFoundException {
     	XMLDecoder decoder = null;
        	// this will allow the executable jar to run
     
    // 	File file = new File("//mirke//configuration","wavelengthToCIE_XYZ.xml");
     	File file = new File("configuration", "wavelengthToCIE_XYZ.xml");
 		if (wavelengthToCIE_XYZ == null) {
 			try{
 			   	decoder = new XMLDecoder(new FileInputStream(file)); // TODO - remove hard-coded filename
 			}catch (FileNotFoundException fn){
 
 			    throw new MirkEFileNotFoundException((Throwable)fn);
 			}catch(IOException io){
 			    
 			    io.printStackTrace();
 			}
 				
 				wavelengthToCIE_XYZ = (HashMap)decoder.readObject();
 				decoder.close();
 				// couldn't read wavelengthToCIE_XYZ from the source file; 
 				//TODO - recover gracefully, if possible p				System.err.println(e);
 		}
 
 		return wavelengthToCIE_XYZ;
 	}
 
 	/*** Default constructor
 		*/
 	public DataSetColorModel() {}
 	/***
 	 * @param wavelength
 	 * @return CIE XYZ components corresponding to a specific <code>wavelength<code> of monochromatic light at a standard intensity
      */
 	public static float[] wavelengthToCIE_XYZcomponents(Integer wavelength) throws MirkEApplicationException,  MirkEFileNotFoundException {
 
 
 		Vector CIE_XYZcomponentsFromWavelength = (Vector)getWavelengthToCIE_XYZ().get(wavelength);
 
 		float[] CIE_XYZcomponents = new float[CIE_XYZcomponentsFromWavelength.size()];
 		for (int i=0;i<CIE_XYZcomponentsFromWavelength.size();i++) {
 			CIE_XYZcomponents[i] = ((Float)CIE_XYZcomponentsFromWavelength.elementAt(i)).floatValue();
 		}
 
 		return CIE_XYZcomponents;
 	}
 
 	/*** Convert from a wavelength of monochromatic light to an approximate Color
 
 		@param wavelength an <code>double</code> wavelength (in nm)
 		@param alpha The alpha channel component of the returned <code>Color</code>
 
 		@return color
 	 * @throws MirkEApplicationException
 		*/
  	public static Color wavelengthToColor(double wavelength,
 										  double alpha) throws MirkEApplicationException ,MirkEFileNotFoundException{
  		return wavelengthToColor(new Integer((int)Math.round(wavelength)),
  								 (float)alpha);
 	}
 
 	/*** Convert from a wavelength of monochromatic light to an approximate Color
 
 		@param wavelength an <code>Integer</code> wavelength (in nm)
 		@param alpha The alpha channel component of the returned <code>Color</code>
 
 		@return color
 	 * @throws MirkEApplicationException
 		*/
 	public static Color wavelengthToColor(Integer wavelength,
 										  double alpha) throws MirkEApplicationException, MirkEFileNotFoundException {
 		return wavelengthToColor(wavelength,
 								 (float)alpha);
 	}
 
 	/*** Convert from XYZ values to a Color
 
 		@param xyzValues
 
 		@return color
 	 * @throws MirkEApplicationException
 		*/
 	public static Color xyzToColor(float[] xyzValues) throws MirkEApplicationException{
 		return xyzToColor(xyzValues, 1.0f);
 	}
 
 	/*** Convert from XYZ values to a Color
 	 *
 	 *@param xyzValues
 	 * @param alpha
 	 *
 	 * @return color
 	 * @throws MirkEApplicationException
 	 */
 	public static Color xyzToColor(float[] xyzValues,
 								   float alpha) throws MirkEApplicationException{
 
 		if (rgbSpace == null) {
 			rgbSpace = new ICC_ColorSpace(ICC_Profile.getInstance(ICC_ColorSpace.CS_sRGB));
 		}
 
 		// don't try to make a color with parameters outside of the allowed range
 		if (alpha > 1) {
 			alpha = 1f;
 
 		} else if (alpha < 0) {
 			alpha = 0f;
 		}
 
 		Color color = new Color(rgbSpace,
 								rgbSpace.fromCIEXYZ(xyzValues),
 								alpha);
 		return color;
 	}
 
 	/*** Convert from a wavelength of monochromatic light to an approximate Color
 	 *
 	 * @param wavelength an <code>Integer</code> wavelength (in nm)
 	 * @param alpha The alpha channel component of the returned <code>Color</code>
 	 *
 	 * @return color
 	 * @throws MirkEApplicationException
 	 */
 	public static Color wavelengthToColor(Integer wavelength,
 										  float alpha)
 	throws MirkEApplicationException, MirkEFileNotFoundException
 	{
 
 		// ensure that alpha is in the interval [0, 1]
 		if (alpha < 0) {
 			alpha = 0f;
 		} else if (alpha > 1) {
 			alpha = 1f;
 		}
 
 		return xyzToColor(wavelengthToCIE_XYZcomponents(wavelength), alpha);
 		}
 
 	/***
      * @param observableToMeanValueMap
 	 * @return a representative <code>Color</code> for the observable
 	 * @throws MirkEApplicationException
 	 */
 	public static Color observableToMeanValueMapToColor(Map observableToMeanValueMap)
 	throws MirkEApplicationException ,MirkEFileNotFoundException{
 		Set entrySet = observableToMeanValueMap.entrySet();
 		float floatValue = 0;//TODO - remove
 
 			Iterator entrySetIterator = entrySet.iterator();
 			while (entrySetIterator.hasNext()) {
 				Map.Entry entry = (Map.Entry)entrySetIterator.next();
 
 				//String observable = (String)entry.getKey();
 				Double value = (Double)entry.getValue();
 				floatValue = (float)value.doubleValue();
 			}
 
 			// TODO - implement
 			return wavelengthToColor((600),
 									 (float).5*floatValue);
 	}
 
 	/*** Simple conversion from an array of floats to a Vector
 
 		@param values
 
 		@return vector
 		*/
 	public static Vector toVector(float[] values) {
 		Vector vector = new Vector();
 
 		for (int i=0;i<values.length;i++) {
 			vector.add(i, new Float(values[i]));
 		}
 
 		return vector;
 	}
 }