/*
 * GeoTools java GIS tookit (c) The Centre for Computational Geography 2002
 *
 * This library is free software; you can redistribute it and/or modify it under the terms
 * of the GNU Lesser General Public License as published by the Free Software Foundation version 2.1
 */

package uk.ac.leeds.ccg.geotools;
import uk.ac.leeds.ccg.geotools.classification.*;
import java.awt.*;
import java.util.*;
import java.io.*;
import java.net.*;

/**
 * Unlike RampShaders, DiscreteShaders have a set number of categories.
 * This class is the base from which percentile, quantile and look-up
 * are extended.
 * Their biggest distinction will come from the way they produce keys.
 * This shader is constructed using a set of ranges, colours and names
 * to be used as the classifications.  These can either be supplied in a
 * key file referenced via a URL or as a set of three vectors.
 *
 * $Log: DiscreteShader.java,v $
 * Revision 1.14  2002/03/09 20:05:21  loxnard
 * Fixed JavaDoc comments.
 *
 *
 * @author James Macgill
 * @author Ian Turton
 * @version $Revision: 1.14 $ $Date: 2002/03/09 20:05:21 $
 * @since before 0.8.0
 */
public class DiscreteShader extends uk.ac.leeds.ccg.geotools.SimpleShader {
    /**
     * Holds the keys for each item.
     */    
    protected Vector keys = new Vector();
    /**
     * Default constructor.  Should only be used by subclasses.
     * TODO: make protected?
     */    
    public DiscreteShader(){
        //only for use by descendents
    }
    /**
     * Constructs a DiscreteShader which allows almost total control over the classifications used when
     * shading.<p>
     * The key file format is as follows:
     * integer,'#XXXXXX','description'<P>
     * Note: the quote marks are necessary.<BR>
     * The integer will be checked against any values passed into getColor.  The description
     * will be used to label the key, and #XXXXXX is a hexidecimal
     * colour code.<P>
     * e.g.<p>
     * 1,'#ff3333',A-Roads<br>
     * 2,'#993333',B-Roads<br>
     * 3,'#ffff33',C-Roads<br>
     * 4,'#cccccc',Unclassified<p>
     * If a - is used in the value column, then a range is assumed.<p>
     * e.g.<p>
     * 0-49,'#0000ff',Cold<br>
     * 50-100,'#ff0000',Hot<br>
     *
     * TODO: Bug?  How are negative values handled in ranges?
     * @param keyFile A URL reference to a key file.
     * @throws IOException Thrown if any errors occur during the reading of the file.
     */
    
    public DiscreteShader(URL keyFile) throws IOException{
        Reader reader = new InputStreamReader(keyFile.openStream());
        StreamTokenizer st = new StreamTokenizer(reader);
        st.whitespaceChars(',',',');
        st.wordChars('-','-');
        st.wordChars('*','*');
        st.wordChars(' ',' ');
        st.parseNumbers();
        int token;
        int code;
        Color color;
        String name;
        Bin value;
        
        token = st.nextToken();
        while(token!=st.TT_EOF){
            if(st.sval!=null) {
                //System.out.println("Using Range key");
                String range = st.sval;
                int split = range.indexOf('-');
                String low = range.substring(0, split);
                String high = range.substring(split+1,range.length());
                //System.out.println("range "+range);
                int a,b;
                if(low.equals("*")){
                    a = Integer.MIN_VALUE;
                }
                else{
                    a = (new Integer(low)).intValue();
                }
                if(high.equals("*")){
                    b = Integer.MAX_VALUE;
                }
                else{
                    b = (new Integer(high)).intValue();
                }
                value = new Bin(a,b);
            }
            else {
                code=(int)st.nval;
                //value = new Bin(code,code+Double.MIN_VALUE);
                value = new Bin(code,code+0.5);
            }
            st.nextToken();
            //System.out.println("ds "+st.sval);
            color = Color.decode(st.sval);
            st.nextToken();
            name = st.sval;
            token = st.nextToken();
            RangeItem k = new RangeItem(value,color,name);
            keys.addElement(k);
            //  System.out.println(k);
        }
    }
    
    /**
     * An alternative constructor for building a DiscreteShader that does not rely on
     * the use of a key file.  Instead, the values, colours and descriptions are supplied in the
     * form of three vectors.
     * @param values A vector of Integer objects which represent the value for each classification.
     * @param colours A vector of Color objects which represent the colour for each classification.
     * @param descriptions A vector of Strings with which to label each of the classifications.
     */
    public DiscreteShader(Vector values,Vector colours,Vector descriptions){
        Bin value;
        int code;
        for(int i=0;i<values.size();i++){
            code=((Integer)values.elementAt(i)).intValue();
            value = new Bin(code,code+Double.MIN_VALUE);
            RangeItem k = new RangeItem(value,
            (Color)colours.elementAt(i),(String)descriptions.elementAt(i));
            keys.addElement(k);
        }
    }
    /**
     * Returns the key for this shader.
     * @return A key object.
     */    
    public Key getKey(){
        if(key==null){
            key = new LUTKey(this);
            key.addMouseListener(new Clicked());
        }
        
        return key;
    }
    
    /**
     * Gets a descriptive name for this shader type.
     * @return A String containing a description.
     */
    public String getName(){
        return "Discrete Shader";
    }
    
    /**
     * Returns the colour associated with the specified value.
     * @param value The value to look up a colour for.
     * @return The colour found.
     */    
    public Color getColor(double value) {
        if(value == missingCode){return missingColor;}
        for(Enumeration e = keys.elements();e.hasMoreElements();){
            RangeItem key = (RangeItem)e.nextElement();
            if(key.contains(value)){return key.color;}
        }
        return missingColor;
        
    }
    
    /**
     * Helper class which specifies a range of values, a colour and a label.
     */    
    public class RangeItem{
        Bin code;
        Color color;
        String name;
        
        /**
         * Constructs a new RangeItem with specified number range, colour and label.
         * @param bin The number range.
         * @param color The colour to use.
         * @param name A label.
         */        
        public RangeItem(Bin bin,Color color,String name){
            this.code = bin;
            this.color = color;
            this.name = name;
        }
        
        /**
         * Returns all the elements in the RangeItem.
         * @return A String which fully describes this RangeItem.
         */        
        public String toString(){
            return ("Code: "+code+" Color: "+color+" Name: "+name);
        }
        /**
         * Tests if the specified value lies within the number range used by this RangeItem.
         * @param v The value to test.
         * @return True if the value is within range.
         */        
        public boolean contains(double v){
            return code.contains(v);
        }
        
        
        
    }
    
    
    
    /**
     * Customized key class for displaying RangeItem, colour and labels.
     */    
    public class LUTKey extends Key{
        
        LUTKey(Shader s){
            super(s);
        //    System.out.println("Key Request");
            setLayout(new GridLayout(keys.size(),1));
            for(Enumeration e = keys.elements();e.hasMoreElements();){
                RangeItem item = (RangeItem)e.nextElement();
                /*System.out.println("Building keybox ");
                System.out.println("Item "+item);
                System.out.println("Code "+item.code);
                System.out.println(item.code.getLowerInclusion());
                System.out.println(item.name);*/
                KeyBox box=null;
               // System.out.println("Key type is "+s.getKeyStyle());
                switch(s.getKeyStyle()){
                    case Shader.BOX:
                        box = new KeyBox(s,item.code.getLowerInclusion(),item.name);
                        System.out.println("Box Key");
                        break;
                    case Shader.POINT:
                        box = new PointKeyBox(s,item.code.getLowerInclusion(),item.name);
                        System.out.println("Point Key");
                        break;
                    case Shader.LINE:
                        box = new LineKeyBox(s,item.code.getLowerInclusion(),item.name);
                        System.out.println("Line Key");
                        break;
                    default:
                        box = new KeyBox(s,item.code.getLowerInclusion(),item.name);
                }
                
                
                
                //KeyBox box = new KeyBox(s,item.code.getLowerInclusion(),item.name);
                add(box);
            }
            
        }
        /**
         * Updates the key to reflect any changes in the shader which it
         * is attached to.
         **/
        public synchronized void updateKey(){
            removeAll();
            setLayout(new GridLayout(keys.size(),1));
            for(Enumeration e = keys.elements();e.hasMoreElements();){
                RangeItem item = (RangeItem)e.nextElement();
                //System.out.println("Code "+item.code.min+" "+item.name);
                KeyBox box;
                switch(shader.getKeyStyle()){
                    case Shader.BOX:
                        box = new KeyBox(shader,item.code.getLowerInclusion(),item.name);
                        System.out.println("Box Key");
                        break;
                    case Shader.POINT:
                        box = new PointKeyBox(shader,item.code.getLowerInclusion(),item.name);
                        System.out.println("Point Key");
                        break;
                    case Shader.LINE:
                        box = new LineKeyBox(shader,item.code.getLowerInclusion(),item.name);
                        System.out.println("Line Key");
                        break;
                    default:
                        box = new KeyBox(shader,item.code.getLowerInclusion(),item.name);
                }
                //KeyBox box = new KeyBox(shader,item.code.getLowerInclusion(),item.name);
                add(box);
            }
            updateLabels();
            this.resize(this.getPreferredSize());
            invalidate();
            validate();
            repaint();
        }
        
    }
    
    
    
}