/**
 * An OSC (Open Sound Control) library for processing.
 *
 * (c) 2004-2012
 *
 * 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; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * This library 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
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General
 * Public License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA  02111-1307  USA
 * 
 * @author		Andreas Schlegel http://www.sojamo.de
 * @modified	12/23/2012
 * @version		0.9.9
 */

package oscP5;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Vector;

import netP5.AbstractTcpClient;
import netP5.Logger;
import netP5.NetAddress;
import netP5.NetAddressList;
import netP5.NetInfo;
import netP5.TcpClient;
import netP5.TcpPacket;
import netP5.TcpPacketListener;
import netP5.TcpServer;
import netP5.UdpPacketListener;

/**
 * oscP5 is an osc implementation for the programming environment processing.
 * osc is the acronym for open sound control, a network protocol developed at
 * cnmat, uc berkeley. open sound control is a protocol for communication among
 * computers, sound synthesizers, and other multimedia devices that is optimized
 * for modern networking technology and has been used in many application areas.
 * for further specifications and application implementations please visit the
 * official osc site.
 * 
 * @usage Application
 * @example oscP5sendReceive
 * @related OscProperties
 * @related OscMessage
 * @related OscBundle
 */

/**
 * TODO add better error message handling for oscEvents, see this post
 * http://forum.processing.org/topic/oscp5-major-problems-with-error-handling# 25080000000811163
 */
public class OscP5 implements UdpPacketListener, TcpPacketListener {

	/*
	 * @TODO implement polling option to avoid threading and synchronization
	 * issues. check email from tom lieber. look into mutex objects.
	 * http://www.google.com/search?hl=en&q=mutex+java&btnG=Search
	 */

	// protected ArrayList _myOscPlugList = new ArrayList();

	protected HashMap<String, ArrayList<OscPlug>> _myOscPlugMap = new HashMap<String, ArrayList<OscPlug>>();

	protected NetInfo _myNetInfo;

	private OscNetManager _myOscNetManager;

	protected final static int NONE = OscNetManager.NONE;

	public final static boolean ON = OscProperties.ON;

	public final static boolean OFF = OscProperties.OFF;

	/**
	 * a static variable used when creating an oscP5 instance with a sepcified network protocol.
	 */
	public final static int UDP = OscProperties.UDP;

	/**
	 * a static variable used when creating an oscP5 instance with a sepcified network protocol.
	 */
	public final static int MULTICAST = OscProperties.MULTICAST;

	/**
	 * a static variable used when creating an oscP5 instance with a sepcified network protocol.
	 */
	public final static int TCP = OscProperties.TCP;

	protected final Object parent;

	private OscProperties _myOscProperties;

	private Class<?> _myParentClass;

	private Method _myEventMethod;

	private Class<?> _myEventClass = OscMessage.class;

	private boolean isEventMethod;

	private boolean isBroadcast = false;

	private NetAddress _myBroadcastAddress;

	private boolean isOscIn = false;

	/**
	 * @invisible
	 */
	public static final String VERSION = "0.9.9";


	/**
	 * @param theParent Object
	 * @param theProperties OscProperties
	 * @usage Application
	 */
	public OscP5(final Object theParent, final OscProperties theProperties) {
		welcome();
		parent = theParent;

		registerDispose(parent);

		_myOscProperties = theProperties;
		_myOscNetManager = new OscNetManager();
		_myOscNetManager.start(_myOscProperties);
		if (_myOscProperties.networkProtocol() == OscProperties.TCP) {
			_myOscNetManager.addTcpListener(this);
		}
		else {
			_myOscNetManager.addUdpListener(this);
		}
		isEventMethod = checkEventMethod();
		if (_myOscProperties.networkProtocol() == OscProperties.MULTICAST) {
			Logger.printInfo("OscP5", "is joining a multicast group @ " + _myOscProperties.remoteAddress().address() + ":" + _myOscProperties.remoteAddress().port());
		}
		else {
			Logger.printInfo("OscP5", "is running. you (" + ip() + ") are listening @ port " + _myOscProperties.remoteAddress().port());
		}
	}


	/**
	 * @param theParent Object
	 * @param theAddress String
	 * @param thePort int
	 * @param theMode int
	 * @usage Application
	 */
	public OscP5(final Object theParent, final String theAddress, final int thePort, final int theMode) {
		welcome();
		parent = theParent;
		_myOscProperties = new OscProperties();

		registerDispose(parent);

		switch (theMode) {
		case (MULTICAST):
			_myOscProperties.setNetworkProtocol(MULTICAST);
			_myOscProperties.setRemoteAddress(theAddress, thePort);
			_myOscProperties.setListeningPort(thePort);
			_myOscNetManager = new OscNetManager();
			_myOscNetManager.start(_myOscProperties);
			_myOscNetManager.addUdpListener(this);
			Logger.printInfo("OscP5", "is joining a multicast group @ " + _myOscProperties.remoteAddress().address() + ":" + _myOscProperties.remoteAddress().port());
			break;
		case (UDP):
			_myOscProperties.setRemoteAddress(theAddress, thePort);
			initUDP(thePort);
			break;
		case (TCP):
			_myOscProperties.setNetworkProtocol(TCP);
			_myOscProperties.setRemoteAddress(theAddress, thePort);
			_myOscNetManager = new OscNetManager();
			_myOscNetManager.start(_myOscProperties);
			_myOscNetManager.addTcpListener(this);
			break;
		}
		isEventMethod = checkEventMethod();
	}


	public OscP5(final Object theParent, final int theReceiveAtPort, final int theMode) {
		welcome();
		parent = theParent;

		registerDispose(parent);

		_myOscProperties = new OscProperties();
		switch (theMode) {
		case (UDP):
			initUDP(theReceiveAtPort);
			break;
		case (TCP):
			_myOscProperties.setNetworkProtocol(TCP);
			_myOscProperties.setListeningPort(theReceiveAtPort);
			_myOscNetManager = new OscNetManager();
			_myOscNetManager.start(_myOscProperties);
			_myOscNetManager.addTcpListener(this);
			break;
		case (MULTICAST):
			Logger.printWarning("OscP5", "please specify a multicast address. use " + "OscP5(Object theObject, String theMulticastAddress, int thePort, int theMode)");
			break;
		}
		isEventMethod = checkEventMethod();
	}


	/**
	 * @param theParent Object
	 * @param theReceiveAtPort int
	 * @usage Application
	 */
	public OscP5(final Object theParent, final int theReceiveAtPort) {
		welcome();
		parent = theParent;

		registerDispose(parent);

		initUDP(theReceiveAtPort);
		isEventMethod = checkEventMethod();
	}


	private void welcome() {
		System.out.println("OscP5 " + VERSION + " " + "infos, comments, questions at http://www.sojamo.de/oscP5\n\n");
	}


	private void registerDispose(Object theObject) {
		try {
			Object parent = null;
			String child = "processing.core.PApplet";
			try {
				Class<?> childClass = Class.forName(child);
				Class<?> parentClass = Object.class;

				if (parentClass.isAssignableFrom(childClass)) {
					parent = childClass.newInstance();
					parent = theObject;
				}
			} catch (Exception e) {
				// System.out.println(e);
			}
			try {
				Method method = parent.getClass().getMethod("registerDispose", Object.class);
				try {
					method.invoke(parent, new Object[] { this });
				} catch (IllegalArgumentException e) {
					// System.out.println(e);
				} catch (IllegalAccessException e) {
					// System.out.println(e);
				} catch (InvocationTargetException e) {
					// System.out.println(e);
				}
			} catch (SecurityException e) {
				// System.out.println("fail (1) " + e);
			} catch (NoSuchMethodException e) {
				// System.out.println("fail (2) " + e);
			}
		} catch (NullPointerException e) {
			System.err.println("Register Dispose\n" + e);
		}
	}


	private void initUDP(final int theReceiveAtPort) {
		_myOscProperties = new OscProperties();
		_myOscProperties.setListeningPort(theReceiveAtPort);
		_myOscNetManager = new OscNetManager();
		_myOscNetManager.start(_myOscProperties);
		_myOscNetManager.addUdpListener(this);
		Logger.printInfo("OscP5", "is running. you (" + ip() + ") are listening @ port " + theReceiveAtPort);
	}


	/**
	 * check which eventMethod exists in the Object oscP5 was started from. this is necessary for
	 * backwards compatibility for oscP5 because the previous parameterType for the eventMethod was
	 * OscIn and is now OscMessage.
	 * 
	 * @return boolean
	 * @invisible
	 */
	private boolean checkEventMethod() {
		_myParentClass = parent.getClass();
		try {
			Method[] myMethods = _myParentClass.getDeclaredMethods();
			for (int i = 0; i < myMethods.length; i++) {
				if (myMethods[i].getName().indexOf(_myOscProperties.eventMethod()) != -1) {
					Class<?>[] myClasses = myMethods[i].getParameterTypes();
					if (myClasses.length == 1) {
						_myEventClass = myClasses[0];
						isOscIn = ((_myEventClass.toString()).indexOf("OscIn") != -1) ? true : false;
						break;
					}
				}
			}

		} catch (Throwable e) {
			System.err.println(e);
		}

		String tMethod = _myOscProperties.eventMethod();
		if (tMethod != null) {
			try {
				Class<?>[] tClass = { _myEventClass };
				_myEventMethod = _myParentClass.getDeclaredMethod(tMethod, tClass);
				_myEventMethod.setAccessible(true);
				return true;
			} catch (SecurityException e1) {
				// e1.printStackTrace();
				Logger.printWarning("OscP5.plug", "### security issues in OscP5.checkEventMethod(). (this occures when running in applet mode)");
			} catch (NoSuchMethodException e1) {
			}
		}
		// online fix, since an applet throws a security exception when calling
		// setAccessible(true);
		if (_myEventMethod != null) {
			return true;
		}
		return false;
	}


	/**
	 * get the current version of oscP5.
	 * 
	 * @return String
	 */
	public String version() {
		return VERSION;
	}


	/**
	 * @invisible
	 */
	public void dispose() {
		stop();
	}


	public void addListener(OscEventListener theListener) {
		_myOscProperties.listeners().add(theListener);
	}


	public void removeListener(OscEventListener theListener) {
		_myOscProperties.listeners().remove(theListener);
	}


	public Vector<OscEventListener> listeners() {
		return _myOscProperties.listeners();
	}


	/**
	 * osc messages can be automatically forwarded to a specific method of an object. the plug
	 * method can be used to by-pass parsing raw osc messages - this job is done for you with the
	 * plug mechanism. you can also use the following array-types int[], float[], String[]. (but
	 * only as on single parameter e.g. somemethod(int[] theArray) {} ).
	 * 
	 * @param theObject Object, can be any Object
	 * @param theMethodName String, the method name an osc message should be forwarded to
	 * @param theAddrPattern String, the address pattern of the osc message
	 * @param theTypeTag String
	 * @example oscP5plug
	 * @usage Application
	 */
	public void plug(final Object theObject, final String theMethodName, final String theAddrPattern, final String theTypeTag) {
		final OscPlug myOscPlug = new OscPlug();
		myOscPlug.plug(theObject, theMethodName, theAddrPattern, theTypeTag);
		// _myOscPlugList.add(myOscPlug);
		if (_myOscPlugMap.containsKey(theAddrPattern)) {
			_myOscPlugMap.get(theAddrPattern).add(myOscPlug);
		}
		else {
			ArrayList<OscPlug> myOscPlugList = new ArrayList<OscPlug>();
			myOscPlugList.add(myOscPlug);
			_myOscPlugMap.put(theAddrPattern, myOscPlugList);
		}
	}


	/**
	 * @param theObject Object, can be any Object
	 * @param theMethodName String, the method name an osc message should be forwarded to
	 * @param theAddrPattern String, the address pattern of the osc message
	 * @example oscP5plug
	 * @usage Application
	 */
	public void plug(final Object theObject, final String theMethodName, final String theAddrPattern) {
		final Class<?> myClass = theObject.getClass();
		final Method[] myMethods = myClass.getDeclaredMethods();
		Class<?>[] myParams = null;
		for (int i = 0; i < myMethods.length; i++) {
			String myTypetag = "";
			try {
				myMethods[i].setAccessible(true);
			} catch (Exception e) {
			}
			if ((myMethods[i].getName()).equals(theMethodName)) {
				myParams = myMethods[i].getParameterTypes();
				OscPlug myOscPlug = new OscPlug();
				for (int j = 0; j < myParams.length; j++) {
					myTypetag += myOscPlug.checkType(myParams[j].getName());
				}

				myOscPlug.plug(theObject, theMethodName, theAddrPattern, myTypetag);
				// _myOscPlugList.add(myOscPlug);
				if (_myOscPlugMap.containsKey(theAddrPattern)) {
					_myOscPlugMap.get(theAddrPattern).add(myOscPlug);
				}
				else {
					ArrayList<OscPlug> myOscPlugList = new ArrayList<OscPlug>();
					myOscPlugList.add(myOscPlug);
					_myOscPlugMap.put(theAddrPattern, myOscPlugList);
				}

			}
		}
	}


	private void handleSystemMessage(final OscMessage theOscMessage) {
		if (theOscMessage.addrPattern().startsWith("/sys/ping")) {
			send("/sys/pong", new Object[0], _myBroadcastAddress);
		}
		else if (theOscMessage.addrPattern().startsWith("/sys/register")) {
			if (theOscMessage.tcpConnection() != null) {
				if (theOscMessage.checkTypetag("s")) {
					theOscMessage.tcpConnection().setName(theOscMessage.get(0).stringValue());
				}
			}
		}
	}


	private void callMethod(final OscMessage theOscMessage) {

		if (theOscMessage.addrPattern().startsWith("/sys/")) {
			handleSystemMessage(theOscMessage);
			// finish this for oscbroadcaster
			// return;
		}

		// forward the message to all OscEventListeners
		for (int i = listeners().size() - 1; i >= 0; i--) {
			((OscEventListener) listeners().get(i)).oscEvent(theOscMessage);
		}

		/* check if the arguments can be forwarded as array */

		if (theOscMessage.isArray) {
			// for (int i = 0; i < _myOscPlugList.size(); i++) {
			// OscPlug myPlug = ((OscPlug) _myOscPlugList.get(i));
			// if (myPlug.isArray && myPlug.checkMethod(theOscMessage, true)) {
			// invoke(myPlug.getObject(), myPlug.getMethod(),
			// theOscMessage.argsAsArray());
			// }
			// }

			if (_myOscPlugMap.containsKey(theOscMessage.addrPattern())) {
				ArrayList<OscPlug> myOscPlugList = _myOscPlugMap.get(theOscMessage.addrPattern());
				for (int i = 0; i < myOscPlugList.size(); i++) {
					OscPlug myPlug = (OscPlug) myOscPlugList.get(i);
					if (myPlug.isArray && myPlug.checkMethod(theOscMessage, true)) {
						// Should we set the following here? The old code did
						// not:
						// theOscMessage.isPlugged = true;
						invoke(myPlug.getObject(), myPlug.getMethod(), theOscMessage.argsAsArray());
					}
				}
			}

		}
		/* check if there is a plug method for the current message */
		// for (int i = 0; i < _myOscPlugList.size(); i++) {
		// OscPlug myPlug = ((OscPlug) _myOscPlugList.get(i));
		// if (!myPlug.isArray && myPlug.checkMethod(theOscMessage, false)) {
		// theOscMessage.isPlugged = true;
		// invoke(myPlug.getObject(), myPlug.getMethod(), theOscMessage
		// .arguments());
		// }
		// }

		if (_myOscPlugMap.containsKey(theOscMessage.addrPattern())) {
			ArrayList<OscPlug> myOscPlugList = _myOscPlugMap.get(theOscMessage.addrPattern());
			for (int i = 0; i < myOscPlugList.size(); i++) {
				OscPlug myPlug = (OscPlug) myOscPlugList.get(i);
				if (!myPlug.isArray && myPlug.checkMethod(theOscMessage, false)) {
					theOscMessage.isPlugged = true;
					invoke(myPlug.getObject(), myPlug.getMethod(), theOscMessage.arguments());
				}
			}
		}

		/* if no plug method was detected, then use the default oscEvent mehtod */
		Logger.printDebug("OscP5.callMethod ", "" + isEventMethod);
		if (isEventMethod) {
			try {
				if (isOscIn) {
					invoke(parent, _myEventMethod, new Object[] { new OscIn(theOscMessage) });
					Logger.printDebug("OscP5.callMethod ", "invoking OscIn " + isEventMethod);
				}
				else {
					invoke(parent, _myEventMethod, new Object[] { theOscMessage });
					Logger.printDebug("OscP5.callMethod ", "invoking OscMessage " + isEventMethod);
				}
			} catch (ClassCastException e) {
				Logger.printError("OscHandler.callMethod", " ClassCastException." + e);
			}
		}
	}


	private void invoke(final Object theObject, final Method theMethod, final Object[] theArgs) {
		try {
			theMethod.invoke(theObject, theArgs);
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			Logger.printError("OscP5", "ERROR. an error occured while forwarding an OscMessage\n " + "to a method in your program. please check your code for any \n"
					+ "possible errors that might occur in the method where incoming\n " + "OscMessages are parsed e.g. check for casting errors, possible\n "
					+ "nullpointers, array overflows ... .\n" + "method in charge : " + theMethod.getName() + "  " + e);
		}
	}


	/**
	 * incoming osc messages from an udp socket are parsed, processed and forwarded to the parent.
	 * 
	 * @invisible
	 * @param thePacket DatagramPacket
	 * @param thePort int
	 */
	public void process(final DatagramPacket thePacket, final int thePort) {
		synchronized (this) {
			OscPacket p = OscPacket.parse(thePacket);
			if (p.isValid()) {
				if (p.type() == OscPacket.BUNDLE) {
					for (int i = 0; i < ((OscBundle) p).size(); i++) {
						callMethod(((OscBundle) p).getMessage(i));
					}
				}
				else {
					callMethod((OscMessage) p);
				}
			}
			notifyAll();
		}
	}


	/**
	 * @invisible
	 * @see netP5.TcpPacketListener#process(netP5.TcpPacket, int)
	 */
	public void process(final TcpPacket thePacket, final int thePort) {
		synchronized (this) {
			OscPacket p = OscPacket.parse(thePacket);
			if (p.isValid()) {
				if (p.type() == OscPacket.BUNDLE) {
					for (int i = 0; i < ((OscBundle) p).size(); i++) {
						callMethod(((OscBundle) p).getMessage(i));
					}
				}
				else {
					callMethod((OscMessage) p);
				}
			}
			notifyAll();
		}
	}


	/**
	 * @invisible
	 * @param theTcpClient AbstractTcpClient
	 */
	public void remove(AbstractTcpClient theTcpClient) {
	}


	/**
	 * @invisible
	 * @param theIndex int
	 */
	public void status(int theIndex) {
	}


	/**
	 * returns the current properties of oscP5.
	 * 
	 * @return OscProperties
	 * @related OscProperties
	 * @usage Application
	 */
	public OscProperties properties() {
		return _myOscProperties;
	}


	/**
	 * @invisible
	 * @return boolean
	 */
	public boolean isBroadcast() {
		return isBroadcast;
	}


	/**
	 * @return String
	 * @invisible
	 */
	public String ip() {
		return NetInfo.getHostAddress();
	}


	/**
	 * oscP5 has a logging mechanism which prints out processes, warnings and errors into the
	 * console window. e.g. turn off the error log with setLogStatus(Logger.ERROR, Logger.OFF);
	 * 
	 * @param theIndex int
	 * @param theValue int
	 * @usage Application
	 */
	public static void setLogStatus(final int theIndex, final int theValue) {
		Logger.set(theIndex, theValue);
	}


	/**
	 * @param theValue
	 */
	public static void setLogStatus(final int theValue) {
		for (int i = 0; i < Logger.ALL; i++) {
			Logger.set(i, theValue);
		}
	}


	/**
	 * set timeToLive of a multicast packet.
	 * 
	 * @param theTTL int
	 */
	public void setTimeToLive(int theTTL) {
		_myOscNetManager.setTimeToLive(theTTL);
	}


	/**
	 * @param theHost NetAddress
	 * @invisible
	 */
	public void disconnect(final NetAddress theHost) {
		if (theHost.isvalid() && theHost.name.length() > 1) {
			String myAddrPattern = "/sys/disconnect/" + theHost.name + "/" + theHost.port();
			send(myAddrPattern, new Object[0], theHost);
			isBroadcast = false;
			_myBroadcastAddress = null;
		}
	}


	/**
	 * @param theNetAddress NetAddress
	 * @param theName String
	 * @param theArguments String[]
	 * @invisible
	 */
	public void connect(final NetAddress theNetAddress, final String theName, final String[] theArguments) {
		if (theNetAddress.isvalid()) {
			_myBroadcastAddress = theNetAddress;
			_myBroadcastAddress.name = theName;
			String myAddrPattern = "/sys/connect/" + theName + "/" + _myOscProperties.listeningPort();
			send(myAddrPattern, theArguments, _myBroadcastAddress);
			isBroadcast = true;
		}
	}


	/**
	 * netinfo() returns an instance of a NetInfo Object from which you can get LAN and WAN
	 * information.
	 * 
	 * @return NetInfo
	 */
	public NetInfo netInfo() {
		return _myNetInfo;
	}


	/**
	 * return the instance of the running TCP server if in TCP mode.
	 * 
	 * @return TcpServer
	 */
	public TcpServer tcpServer() {
		return _myOscNetManager.tcpServer();
	}


	/**
	 * return the instance of the running TCP client if in TCP mode.
	 * 
	 * @return TcpClient
	 */
	public TcpClient tcpClient() {
		return _myOscNetManager.tcpClient();
	}


	/**
	 * you can send osc packets in many different ways. see below and use the send method that fits
	 * your needs.
	 * 
	 * 
	 * @param thePacket OscPacket
	 * @param theNetAddress NetAddress
	 * @usage Application
	 */
	public void send(final OscPacket thePacket, final NetAddress theNetAddress) {
		_myOscNetManager.send(thePacket, theNetAddress);
	}


	/**
	 * @param thePacket OscPacket
	 * @usage Application
	 * @example oscP5sendReceive
	 */
	public void send(final OscPacket thePacket) {
		_myOscNetManager.send(thePacket);
	}


	/**
	 * @param thePacket OscPacket
	 * @param theNetAddressList NetAddressList
	 * @usage Application
	 */
	public void send(final OscPacket thePacket, final NetAddressList theNetAddressList) {
		_myOscNetManager.send(thePacket, theNetAddressList);
	}


	/**
	 * @param theAddrPattern String
	 * @param theArguments Object[]
	 * @usage Application
	 */
	public void send(final String theAddrPattern, final Object[] theArguments) {
		_myOscNetManager.send(theAddrPattern, theArguments);
	}


	/**
	 * @param theAddrPattern String
	 * @param theArguments Object[]
	 * @param theNetAddressList NetAddressList
	 * @usage Application
	 */
	public void send(final String theAddrPattern, final Object[] theArguments, final NetAddressList theNetAddressList) {
		_myOscNetManager.send(theAddrPattern, theArguments, theNetAddressList);
	}


	/**
	 * @param theAddrPattern String
	 * @param theArguments Object[]
	 * @param theNetAddress NetAddress
	 * @usage Application
	 */
	public void send(final String theAddrPattern, final Object[] theArguments, final NetAddress theNetAddress) {
		_myOscNetManager.send(theAddrPattern, theArguments, theNetAddress);
	}


	/**
	 * @param theAddrPattern String
	 * @param theArguments Object[]
	 * @param theNetAddress NetAddress
	 * @usage Application
	 */
	public void send(final String theAddrPattern, final Object[] theArguments, final String theAddress, int thePort) {
		_myOscNetManager.send(theAddrPattern, theArguments, theAddress, thePort);
	}


	/**
	 * send to tcp client
	 * 
	 * @param thePacket OscPacket
	 * @param theClient TcpClient
	 */
	public void send(final OscPacket thePacket, final TcpClient theClient) {
		theClient.send(thePacket.getBytes());
	}


	/**
	 * @param theAddrPattern String
	 * @param theArguments Object[]
	 * @param theClient TcpClient
	 */
	public void send(final String theAddrPattern, final Object[] theArguments, final TcpClient theClient) {
		send(new OscMessage(theAddrPattern, theArguments), theClient);
	}


	/**
	 * the send method offers a lot of possibilities. have a look at the send documentation.
	 * 
	 * @param thePacket OscPacket
	 * @param theIpAddress String
	 * @param thePort int
	 * @usage Application
	 * @deprecated
	 */
	public void send(final OscPacket thePacket, final String theIpAddress, final int thePort) {
		_myOscNetManager.send(thePacket, theIpAddress, thePort);
	}


	/**
	 * stop oscP5 and close open Sockets.
	 */
	public void stop() {
		Logger.printDebug("OscP5.stop", "starting to stop oscP5.");
		_myOscNetManager.stop();
		Logger.printDebug("OscP5.stop", "stopping oscP5.");
	}


	/**
	 * a static method to send an OscMessage straight out of the box without having to instantiate
	 * oscP5.
	 * 
	 * @param theOscMessage OscMessage
	 * @param theNetAddress NetAddress
	 * @example oscP5flush
	 */
	public static void flush(final OscMessage theOscMessage, final NetAddress theNetAddress) {
		flush(theOscMessage.getBytes(), theNetAddress);
	}


	public static void flush(final OscPacket theOscPacket, final NetAddress theNetAddress) {
		flush(theOscPacket.getBytes(), theNetAddress);
	}


	public static void flush(final String theAddrPattern, final Object[] theArguments, final NetAddress theNetAddress) {
		flush((new OscMessage(theAddrPattern, theArguments)).getBytes(), theNetAddress);
	}


	public static void flush(final byte[] theBytes, final NetAddress theNetAddress) {
		DatagramSocket mySocket;
		try {
			mySocket = new DatagramSocket();

			DatagramPacket myPacket = new DatagramPacket(theBytes, theBytes.length, theNetAddress.inetaddress(), theNetAddress.port());
			mySocket.send(myPacket);
		} catch (SocketException e) {
			Logger.printError("OscP5.openSocket", "cant create socket " + e.getMessage());
		} catch (IOException e) {
			Logger.printError("OscP5.openSocket", "cant create multicastSocket " + e.getMessage());
		}
	}


	/*
	 * DEPRECATED methods and constructors.
	 */

	/**
	 * @param theBytes byte[]
	 * @param theAddress String
	 * @param thePort int
	 * @deprecated
	 */
	public static void flush(final byte[] theBytes, final String theAddress, final int thePort) {
		flush(theBytes, new NetAddress(theAddress, thePort));
	}


	/**
	 * @param theOscMessage OscMessage
	 * @param theAddress String
	 * @param thePort int
	 * @deprecated
	 */
	public static void flush(final OscMessage theOscMessage, final String theAddress, final int thePort) {
		flush(theOscMessage.getBytes(), new NetAddress(theAddress, thePort));
	}


	/**
	 * old version of constructor. still in here for backwards compatibility.
	 * 
	 * @deprecated
	 * @invisible
	 */
	public OscP5(final Object theParent, final String theHost, final int theSendToPort, final int theReceiveAtPort, final String theMethodName) {
		welcome();
		parent = theParent;

		registerDispose(parent);

		_myOscProperties = new OscProperties();
		_myOscProperties.setRemoteAddress(theHost, theSendToPort);
		_myOscProperties.setListeningPort(theReceiveAtPort);
		_myOscProperties.setEventMethod(theMethodName);
		_myOscNetManager = new OscNetManager();
		_myOscNetManager.start(_myOscProperties);
		_myOscNetManager.addUdpListener(this);
		isEventMethod = checkEventMethod();
	}


	/**
	 * @deprecated
	 * @param theAddrPattern String
	 * @return OscMessage
	 * @invisible
	 */
	public OscMessage newMsg(String theAddrPattern) {
		return new OscMessage(theAddrPattern);
	}


	/**
	 * @deprecated
	 * @param theAddrPattern String
	 * @return OscMessage
	 * @invisible
	 */

	public OscBundle newBundle() {
		return new OscBundle();
	}


	/**
	 * used by the monome library by jklabs
	 * 
	 * @deprecated
	 * @invisible
	 */
	public void disconnectFromTEMP() {
	}


	/**
	 * @deprecated
	 * @param theParent Object
	 * @param theAddress String
	 * @param thePort int
	 */
	public OscP5(final Object theParent, final String theAddress, final int thePort) {
		this(theParent, theAddress, thePort, OscProperties.MULTICAST);
	}

}