/*
    * Copyright 2007-2008 Volker Fritzsch
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *     http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License. 
   */
  package motejx.extensions.nunchuk;
  
  import java.awt.Point;
  
  import javax.swing.event.EventListenerList;
  
  import motej.AbstractExtension;
  import motej.Mote;
  import motej.event.AccelerometerEvent;
  import motej.event.AccelerometerListener;
  import motej.event.DataEvent;
  import motej.event.DataListener;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * 
   * <p>
   * 
   * @author <a href="mailto:vfritzsch@users.sourceforge.net">Volker Fritzsch</a>
   */
  public class Nunchuk extends AbstractExtension implements DataListener {
  
  	private EventListenerList listenerList = new EventListenerList();
  
  	private Mote mote;
  
  	private Logger log = LoggerFactory.getLogger(Nunchuk.class);
  
  	private NunchukCalibrationData calibrationData;
  
  	/**
  	 * @param listener
  	 */
  	public void addAccelerometerListener(AccelerometerListener<Nunchuk> listener) {
  		listenerList.add(AccelerometerListener.class, listener);
  	}
  
  	/**
  	 * @param listener
  	 */
  	public void addAnalogStickListener(AnalogStickListener listener) {
  		listenerList.add(AnalogStickListener.class, listener);
  	}
  
  	/**
  	 * @param listener
  	 */
  	public void addNunchukButtonListener(NunchukButtonListener listener) {
  		listenerList.add(NunchukButtonListener.class, listener);
  	}
  
  	/*
  	 * (non-Javadoc)
  	 * 
  	 * @see motej.event.DataListener#dataRead(motej.event.DataEvent)
  	 */
  	public void dataRead(DataEvent evt) {
  		if (calibrationData == null && evt.getError() == 0
  				&& evt.getAddress()[0] == 0x00
  				&& (evt.getAddress()[1] & 0xff) == 0x30
  				&& evt.getPayload().length == 0x0f) {
  
  			log.debug("Calibration Data received.");
  
  			byte[] payload = evt.getPayload();
  
  			calibrationData = new NunchukCalibrationData();
  			calibrationData.setZeroForceX(payload[0] & 0xff);
  			calibrationData.setZeroForceY(payload[1] & 0xff);
  			calibrationData.setZeroForceZ(payload[2] & 0xff);
  			calibrationData.setGravityForceX(payload[4] & 0xff);
  			calibrationData.setGravityForceY(payload[5] & 0xff);
  			calibrationData.setGravityForceZ(payload[6] & 0xff);
  			calibrationData.setMinimumAnalogPoint(new Point(payload[9] & 0xff,
  					payload[12] & 0xff));
  			calibrationData.setMaximumAnalogPoint(new Point(payload[8] & 0xff,
  					payload[11] & 0xff));
  			calibrationData.setCenterAnalogPoint(new Point(payload[10] & 0xff,
  					payload[13] & 0xff));
  		}
  	}
  
 	/**
 	 * @param data
 	 */
 	@SuppressWarnings("unchecked")
 	protected void fireAccelerometerEvent(byte[] data) {
 		AccelerometerListener<Nunchuk>[] listeners = listenerList
 				.getListeners(AccelerometerListener.class);
 		if (listeners.length == 0) {
 			return;
 		}
 
 		// remark: I am currently ignoring the LSB as I do with the LSB of the
 		// calibration data.
 		// if someone comes up with reliable data, we'll add it, i promise.
 		int ax = ((data[2] & 0xff)); // << 2) ^ (data[5] & 0x0c);
 		int ay = ((data[3] & 0xff)); // << 2) ^ (data[5] & 0x30);
 		int az = ((data[4] & 0xff)); // << 2) ^ (data[5] & 0xc0);
 		AccelerometerEvent<Nunchuk> evt = new AccelerometerEvent<Nunchuk>(this,
 				ax, ay, az);
 		for (AccelerometerListener<Nunchuk> l : listeners) {
 			l.accelerometerChanged(evt);
 		}
 	}
 
 	protected void fireAnalogStickEvent(byte[] data) {
 		AnalogStickListener[] listeners = listenerList
 				.getListeners(AnalogStickListener.class);
 		if (listeners.length == 0) {
 			return;
 		}
 
 		int sx = data[0] & 0xff;
 		int sy = data[1] & 0xff;
 		AnalogStickEvent evt = new AnalogStickEvent(this, new Point(sx & 0xff,
 				sy & 0xff));
 		for (AnalogStickListener l : listeners) {
 			l.analogStickChanged(evt);
 		}
 	}
 
 	protected void fireButtonEvent(byte[] data) {
 		NunchukButtonListener[] listeners = listenerList
 				.getListeners(NunchukButtonListener.class);
 		if (listeners.length == 0) {
 			return;
 		}
 
 		// we invert the original data as the wiimote returns
 		// button pressed as nil and thats not that useable.
 		int modifiers = (data[5] & 0x03) ^ 0x03;
 
 		NunchukButtonEvent evt = new NunchukButtonEvent(this, modifiers);
 		for (NunchukButtonListener l : listeners) {
 			l.buttonPressed(evt);
 		}
 	}
 
 	/**
 	 * @return
 	 */
 	public NunchukCalibrationData getCalibrationData() {
 		return calibrationData;
 	}
 
 	/**
 	 * @return
 	 */
 	public Mote getMote() {
 		return mote;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see motej.Extension#initialize()
 	 */
 	public void initialize() {
 		mote.addDataListener(this);
 		
 		// initialize
 		mote.writeRegisters(new byte[] { (byte) 0xa4, 0x00, 0x40}, new byte[] { 0x00 });
 		
 		// request calibration data
 		mote.readRegisters(new byte[] { (byte) 0xa4, 0x00, 0x30 }, new byte[] {
 				0x00, 0x0f });
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see motej.Extension#parseExtensionData(byte[])
 	 */
 	public void parseExtensionData(byte[] extensionData) {
 		decrypt(extensionData);
 		fireAnalogStickEvent(extensionData);
 		fireAccelerometerEvent(extensionData);
 		fireButtonEvent(extensionData);
 	}
 
 	/**
 	 * @param listener
 	 */
 	public void removeAccelerometerListener(
 			AccelerometerListener<Nunchuk> listener) {
 		listenerList.remove(AccelerometerListener.class, listener);
 	}
 
 	/**
 	 * @param listener
 	 */
 	public void removeAnalogStickListener(AnalogStickListener listener) {
 		listenerList.remove(AnalogStickListener.class, listener);
 	}
 
 	/**
 	 * @param listener
 	 */
 	public void removeNunchukButtonListener(NunchukButtonListener listener) {
 		listenerList.remove(NunchukButtonListener.class, listener);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see motej.Extension#setMote(motej.Mote)
 	 */
 	public void setMote(Mote mote) {
 		this.mote = mote;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see java.lang.Object#toString()
 	 */
 	@Override
 	public String toString() {
 		return "Nunchuk";
 	}
 }