/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of CosyBeans-Common.
    *
    * CosyBeans-Common 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-Common 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-Common.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.gui.components;
  
  import java.awt.BorderLayout;
  import java.awt.Color;
  import java.awt.Dimension;
  import java.awt.event.MouseAdapter;
  import java.awt.event.MouseEvent;
  import java.awt.event.ComponentAdapter;
  
  
  import java.awt.Container;
  import java.awt.event.ComponentEvent;
  
  import javax.swing.JFrame;
  import javax.swing.JLabel;
  import javax.swing.SwingUtilities;
  
  
  import com.cosylab.gui.components.ledder.BitDescriptor;
  import com.cosylab.gui.components.ledder.BitmaskField;
  import com.cosylab.gui.components.ledder.Led;
  import com.cosylab.gui.components.util.ColorHelper;
  
  
  
  public class Ledder extends javax.swing.JPanel{
  
  	private static final long serialVersionUID = 1L;
  	/**
  	 * @param
  	 */
  	private int columns=0;
  	private BitmaskField bitmask;
  	private boolean isEditable=false;
  	private Led[] leds=null;
  	private boolean reverseLedsOrder=false;
  	private static JLabel maskNotSet;
  	public Ledder(){
  		super();
  		setBackground(ColorHelper.getCosyControl());
  		addComponentListener(new ResizeListener());
  	
  		maskNotSet = new JLabel(" < Ledder is empty, mask is 0 >");
  		maskNotSet.setHorizontalAlignment(JLabel.CENTER);
  	
  	}
  	
  	public static void main(String[] args) {
  		final Ledder ledder = new Ledder();
  		final long mask= Integer.MAX_VALUE;
  	
  		//ledder.setColumns(5);
  		BitDescriptor bd= new BitDescriptor() {
  			
  			public Color getColorWhenOff(int index) {
  				return Color.YELLOW;
  			}
  		
  			public Color getColorWhenOn(int index) {
  				return Color.BLACK;
  			}
  		
  			public String getDescription(int index) {
  				return "D"+index;
  			}
  		
  		};
  		ledder.setEditable(true);
  		ledder.setBits(2);
  		ledder.setMask(mask);
  		ledder.setModel(bd);
  /*		ledder.setReverseLedsOrder(false);
  		for(int i=0; i<ledder.leds.length; i++){
  			ledder.leds[i].setText("Test"+i);
  		}
  */	
  		
  		/*
  		ledder.addPropertyChangeListener("bits", new PropertyChangeListener() {
  			public void propertyChange(PropertyChangeEvent evt) {
 				System.out.println("BITS "+evt.getNewValue()+ " "+ledder.getBits());
 			}
 		});
 		*/
 		
 		JFrame f = new JFrame();            
 		f.setSize(new Dimension(200,200));
 	
 	
 		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 		Container con = f.getContentPane();
 		con.add(ledder);
 		f.setVisible(true);
 		/*
 		new Thread() {
 			public void run() {
 				while(true) {
 					ledder.setBits((long)(Math.random()*mask));
 					try {
 						sleep(100);
 					} catch (Exception e) {
 						// TODO: handle exception
 					}
 				} 
 			};
 		}.start();
 		*/
 	}
 	
 	
 	private final class ResizeListener extends ComponentAdapter {
 		/**
 		 * @param e ComponentEvent
 		 * @see java.awt.event.ComponentListener#componentResized(ComponentEvent)
 		 */
 		public final void componentResized(ComponentEvent e) {
 	
 		
 			if(Ledder.this.isMaskSet())
 				Ledder.this.updateLayout();
 			else{
 				Ledder.this.updateNoMaskLayout();
 				
 			}
 		}
 	}
 
 	
 
 	private BitmaskField getBitmask() {
 		if (bitmask == null) {
 			bitmask = new BitmaskField();
 		}
 
 		return bitmask;
 	}
 
 	/**
 	 * returns if ledder is editable
 	 * @return
 	 */
 	public  boolean isEditable(){
 	    return isEditable;
 	}
 	
 	/**
 	 * sets the ledder to editable mode (user can by clicking sets the new value...)
 	 * @param editable
 	 */
 	public void setEditable(boolean editable){
 	    isEditable=editable;
 	    // TODO invoke in runnable
 	   SwingUtilities.invokeLater(new Runnable(){
 		   public void run(){
 			   if(leds != null){
 	    			for(int i=0; i<leds.length;i++){
 	    				leds[i].setEditable(isEditable);
 	    			}
 			   }
 		   }
 	   });
 	    
 	}
 	
 	
 	
 	
 	
 	/**
 	 * The binary representation of returned long value defines the status of the leds.
 	 * Example:
 	 * long = 11 -> binary = 1011
 	 *                      leds     = XX0X
 	 * 
 	 * The last value in binary representation sets ON/OFF the first led, etc.
 	 *  
 	 * @return long 
 	 */
 	public long getBits() {
 		return getBitmask().getBits();
 	}
 
 	public long getBitCount(){
 		return getBitmask().getBitCount();
 	}
 	
 	/**
 	 * @return long
 	 */
 	public long getMask() {
 		return getBitmask().getMask();
 	}
 
 	/**
 	 * @return Dimension
 	 */
 	public Dimension getMinimumSize() {
 		return getLayout().minimumLayoutSize(this);
 	}
 
 	/**
 	 * @return BitDescriptor
 	 */
 	public BitDescriptor getModel() {
 		return getBitmask().getBitDescriptor();
 	}
 
 	/**
 	 * @param value long
 	 */
 	public synchronized void setBits(long value) {
 			long oldBits = getBits();
 			getBitmask().setBits(value);
 			firePropertyChange("bits", oldBits, value);
 			updateLeds();
 	}
 
 	
 	private void _updateLeds(){
 		
 		long l = getBitmask().getCompactValue();
 			if(leds != null){
 				for(int i=0; i<leds.length; i++) {
 					leds[i].setOn( (l & 1) == 1);
 					l >>= 1;
 				}
 			}
 	}
 	
 	private void updateLeds(){
 		SwingUtilities.invokeLater(new Runnable(){
 			public void run(){
 				_updateLeds();
 	
 			}});		
 	}
 	
 
 	/**
 	 * @param value long
 	 */
 	public void setMask(long value) {
 		long currentValue = getBitmask().getMask();
 		
 		if (currentValue == value) {
 			return;
 		}
 		
 		else if(value== 0){
 			updateNoMaskLayout();
 			getBitmask().setMask(value);
 			firePropertyChange("mask", currentValue, value);
 			
 		}
 		else{
 		
 			getBitmask().setMask(value);
 			firePropertyChange("mask", currentValue, value);
 			setLeds();
 			//the isEditable value has now an value
 			setEditable(isEditable);
 			updateLayout();
 		}
 	}
 
 	/**
 	 * @param model BitDescriptor
 	 */
 	public void setModel(BitDescriptor model) {
 
 		getBitmask().setBitDescriptor(model);
 		setLeds();
 		
 	}
 
 	/**
 	 * Sets the number of culmns. Value larger than 0 indicates, the component 
 	 * should display leds in specified number of columns. Value of 0 indicates
 	 * no preference and the component will distribute the leds in an optimal 
 	 * way.
 	 * 
 	 * @param numberOfColumns int
 	 */
 	public void setColumns(int col) {
 		columns=col;
 	}
 	
 	public int getColumns() {
 		return columns;
 	}
 	
 	private boolean isMaskSet() {
 		return getMask()>0;
 	}
 	
 	public boolean isReverseLedsOrder() {
 		return reverseLedsOrder;
 	}
 	
 	public void setReverseLedsOrder(boolean b) {
 		if(b == reverseLedsOrder) {
 			return;
 		}
 			
 		boolean oldValue = reverseLedsOrder;	
 		reverseLedsOrder = b;
 		firePropertyChange("reverseLedsOrder", oldValue, b);
 		setLeds();
 	}
 	
 	
 	private void updateLayout(){
 		SwingUtilities.invokeLater(new Runnable(){
 			public void run(){
 				
 				_updateLayout();
 				_updateLeds();
 		}});
 
 	}
 
 	private void _updateLayout(){
 		
 		if(getColumns()> 0){
 			if(leds != null){
 				setLayout(new java.awt.GridLayout(0,columns));
 			}
 		}	
 	
 		else{
 			if(leds != null){
 				int maxw = 0;
 				int maxh = 0;
 				for (int i = 0; i < leds.length; i++) {
 				
 					Dimension d = leds[i].getPreferredSize();
 					maxw = Math.max(maxw, d.width);
 					maxh = Math.max(maxh, d.height);
 				}
 				int nCols = (int)Math.ceil(1.0*getWidth() / maxw);
 				nCols = Math.max(1, nCols);
 				int nRows = leds.length / nCols +1;
 				setLayout(new java.awt.GridLayout(nRows, nCols));
 		
 				repaint();
 				doLayout();
 			}
 		}
 	}
 	
 	
 	private void _updateNoMaskLayout(){
 		
 				removeAll();
 				setLayout(new BorderLayout());
 				add(maskNotSet);
 				doLayout();
 				repaint();
 				
 		
 	}
 	
 	private void updateNoMaskLayout(){
 		SwingUtilities.invokeLater(new Runnable(){
 			public void run(){
 				_updateNoMaskLayout();
 			}
 		});
 	} 
 	
 	private void checkBits(int ledindex){
 	    long bits = getBits();
 	    boolean isLedAllreadyOn=false;
 	    for(int i=0;i<ledindex;i++){
 	        bits  =bits >> 1;
 	    }
 	    if(bits%2==1){
 	        isLedAllreadyOn = true;
 	    }
 	  
 	    if(isLedAllreadyOn==leds[ledindex].isOn()){
 	        //do nothing...
 	    }else  {
 	        /*
 	         * setBits to new value,depending on bit(led) , that has changed... 1 or 0!!!
 	         */
 	        long addValueToBits=1;
 	        long oldValue=getBits();
 	        for (int i=0;i<ledindex;i++){
 	               addValueToBits*=2;
         	}
 	        if(isLedAllreadyOn){
 	            getBitmask().setBits(getBits()-addValueToBits);
 	        }else{
 	            getBitmask().setBits(getBits()+addValueToBits);
 	        }
 	        firePropertyChange("bits",oldValue,getBits());
 	    }
 	    
 	}
 	
 	private void _updateBits(){
 		
 	    if(isEditable){
             for(int i=0;i<leds.length;i++){
             	checkBits(i);
             }
         }
 
 	}
 	
 
 	
 	private void updateBits() {
 		//Thread.dumpStack();
 		SwingUtilities.invokeLater(new Runnable() {
 			public void run() {
 				_updateBits();
 			}
 		});
 	}
 
 	private void setLeds(){
 		SwingUtilities.invokeLater(new Runnable(){
 			public void run(){
 				_setLeds();
 			}
 		});
 	}
 		
 	private void _setLeds(){
 		BitDescriptor lm = getModel();
 		int ledCount = getBitmask().getBitCount();
 		leds = new Led[ledCount];
 		
 		//creating and adding mouse listener to leds
 		for(int i=0; i<ledCount; i++){
 			leds[i]=new Led(
 				lm.getDescription(i),
 				lm.getColorWhenOn(i),
 				lm.getColorWhenOff(i));
 			leds[i].setEditable(isEditable);
 			//adding mouse listener to all leds
 			leds[i].addMouseListener(new MouseAdapter(){
 			public void mouseClicked(MouseEvent e){
 				if(SwingUtilities.isLeftMouseButton(e)){	
 					updateBits();
 				}
 			}});
 		}
 		Led[] l= leds;
 
 		if(getComponents() != null)
 			removeAll();
 		
 		//adding leds to ledder if not reverse order
 		if(!isReverseLedsOrder()) {
 			for(int i=0; i<l.length; i++){
 				add(l[i]);
 			}
 		}else{
 			for (int i = l.length-1; i >= 0; i--) 
 				add(l[i]);
 		}
 	
 		
 		repaint();
 		updateLayout();
 	}
 }