using System;

using System.Runtime.InteropServices;

using System.Collections;

namespace Loudmouth {

    public delegate void ElementHandler        (Element element);

    public delegate void MessageHandler        (Message message);

    public delegate void PresenceHandler       (Presence presence);

    public delegate void IQHandler             (IQ iq);

    public delegate void ResultFunction        (bool success);

    public delegate void DisconnectionFunction ();

     public class Connection {

	private IntPtr _obj;

	private Hashtable _asyncHandlers;

	private ResultFunction result_func;

	public string Server {

	    get {

		return lm_connection_get_server(this._obj);

	    }

	    set {

		lm_connection_set_server(this._obj, value);

	    }

	}

	public uint Port {

	    get {

		return lm_connection_get_port(this._obj);

	    }

	    set {

		lm_connection_set_port(this._obj, value);

	    }

	}

	public bool IsOpen {

	    get {

		return lm_connection_is_open (this._obj);

	    }

	}

	public bool IsAuthenticated {

	    get {

		return lm_connection_is_authenticated(this._obj);

	    }

	}

	private delegate int  _ElementHandler (IntPtr h, IntPtr con, IntPtr elementObj, IntPtr ignored);

	private delegate void _ResultFunction (IntPtr con, bool success, IntPtr ptr);

	private delegate void _DisconnectFunction (IntPtr con, int reason, IntPtr ignored);

	[DllImport ("libloudmouth-1.so")]

	    private static extern int lm_message_get_type (IntPtr obj);

	private int HandleElement (IntPtr h, IntPtr con, IntPtr elementObj, IntPtr ignored) 

	{

	    switch (lm_message_get_type (elementObj)) {

		case (int) Element.ElementType.MESSAGE:

		    EmitIncomingMessage (new Message (elementObj));

		    break;

		case (int) Element.ElementType.PRESENCE:

		    EmitIncomingPresence (new Presence (elementObj));

		    break;

		case (int) Element.ElementType.IQ:

		    EmitIncomingIQ (new IQ (elementObj));

		    break;

	    }

	    return 0;

	}

	private int AsyncHandler (IntPtr h, IntPtr con, IntPtr elementObj, IntPtr id) {

	   ElementHandler handler = (ElementHandler) _asyncHandlers[id];

	   if (handler != null) {

	       handler(Element.CreateElement(elementObj));

	   }

	   return 0;

	}

	private void _HandleResult (IntPtr con, bool success, IntPtr ptr) {

	    ResultFunction func = this.result_func;

	    this.result_func = null;

	    func(success);

	}

	public event MessageHandler        IncomingMessage;

	public event PresenceHandler       IncomingPresence;

	public event IQHandler             IncomingIQ;

	public event DisconnectionFunction Disconnected;

	[DllImport ("libloudmouth-1.so")]

	    private static extern IntPtr lm_connection_new (string name);

	[DllImport ("libloudmouth-1.so")]

	    private static extern bool lm_connection_open (IntPtr obj, _ResultFunction func, IntPtr ptr, IntPtr ignored2, IntPtr errPtr);

	[DllImport ("libloudmouth-1.so")]

	    private static extern bool lm_connection_open_and_block (IntPtr obj, IntPtr errPtr);

	[DllImport ("libloudmouth-1.so")]

	    private static extern bool lm_connection_close (IntPtr obj, IntPtr errPtr);

	[DllImport ("libloudmouth-1.so")]

	    private static extern bool lm_connection_authenticate (IntPtr obj, string username, string password, string resource, _ResultFunction func, IntPtr ignored, IntPtr ignored2, IntPtr errPtr);

	[DllImport ("libloudmouth-1.so")]

	    private static extern bool lm_connection_authenticate_and_block (IntPtr obj, string username, string password, string resource, IntPtr errPtr);

	[DllImport ("libloudmouth-1.so")]

		private static extern bool lm_connection_is_open (IntPtr obj);

	[DllImport ("libloudmouth-1.so")]

	    private static extern bool lm_connection_is_authenticated (IntPtr obj);

	[DllImport ("libloudmouth-1.so")]

	    private static extern void lm_connection_set_server (IntPtr obj, string server);

	[DllImport ("libloudmouth-1.so")]

	    private static extern string lm_connection_get_server (IntPtr obj);

	[DllImport ("libloudmouth-1.so")]

	    private static extern void lm_connection_set_port (IntPtr obj, uint port);

	[DllImport ("libloudmouth-1.so")]

	    private static extern uint lm_connection_get_port (IntPtr obj);

	[DllImport ("libloudmouth-1.so")]

	    private static extern void lm_connection_set_ssl (IntPtr obj, IntPtr ssl);

	[DllImport ("libloudmouth-1.so")]

	    private static extern IntPtr lm_connection_get_ssl (IntPtr obj);

	[DllImport ("libloudmouth-1.so")]

	    private static extern void lm_connection_set_proxy (IntPtr obj, IntPtr proxy);

	[DllImport ("libloudmouth-1.so")]

	    private static extern IntPtr lm_connection_get_proxy (IntPtr obj);

	[DllImport ("libloudmouth-1.so")]

	    private static extern bool lm_connection_send (IntPtr obj, IntPtr message, IntPtr errPtr);

	[DllImport ("libloudmouth-1.so")]

	    private static extern bool lm_connection_send_with_reply (IntPtr obj, IntPtr message, IntPtr handler, IntPtr errPtr);

	[DllImport ("libloudmouth-1.so")]

	    private static extern IntPtr lm_connection_send_with_reply_and_block (IntPtr obj, IntPtr message, IntPtr errPtr);

	[DllImport ("libloudmouth-1.so")]

	    private static extern void lm_connection_register_message_handler (IntPtr obj, IntPtr handler, int type, int priority);

	[DllImport ("libloudmouth-1.so")]

	    private static extern void lm_connection_set_disconnect_function (IntPtr obj, _DisconnectFunction func, IntPtr u, IntPtr n);

	[DllImport ("libloudmouth-1.so")]

	    private static extern bool lm_connection_send_raw (IntPtr obj, string msg, IntPtr errPtr);

	[DllImport ("libloudmouth-1.so")]

	    private static extern void lm_connection_unref (IntPtr obj);

	[DllImport ("libloudmouth-1.so")]

	    private static extern IntPtr lm_message_handler_new (_ElementHandler handler, IntPtr u, IntPtr n);

	private void SetupConnection (string server, uint port)

	{

	    this._obj = lm_connection_new (server);

	    this.Port = port;

	    this._asyncHandlers = new Hashtable ();

	    IntPtr h = lm_message_handler_new (new _ElementHandler (this.HandleElement), IntPtr.Zero, IntPtr.Zero);

	    lm_connection_register_message_handler (this._obj, h, (int)Element.ElementType.MESSAGE, 1);

	    h = lm_message_handler_new (new _ElementHandler(this.HandleElement), IntPtr.Zero, IntPtr.Zero);

	    lm_connection_register_message_handler (this._obj, h, (int)Element.ElementType.PRESENCE, 1);

	    h = lm_message_handler_new (new _ElementHandler (this.HandleElement), IntPtr.Zero, IntPtr.Zero);

	    lm_connection_register_message_handler (this._obj, h, (int)Element.ElementType.IQ, 1);

	} 

	public Connection (string server) 

	{

	    SetupConnection (server, 5222);

	}

	public Connection (string server, uint port)

	{

	    SetupConnection (server, port);

	}

	public void Open (ResultFunction func) {

	    if (this.result_func != null) {

		// Throw exception?

		Console.WriteLine("Connection::Open: this.result_func != null");

		return;

	    }

	    this.result_func = func;

	    lm_connection_open(this._obj, new _ResultFunction(this._HandleResult), IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);

	}

	public bool OpenAndBlock () {

	    return lm_connection_open_and_block(this._obj, IntPtr.Zero);

	}

	public void Close () {

	    lm_connection_close (this._obj, IntPtr.Zero);

	}

	public void Authenticate (Account account, ResultFunction func) {

	    if (this.result_func != null) {

		// Throw exception?

		Console.WriteLine("Connection::Authenticate: this.result_func != null");

		return;

	    }

	    this.result_func = func;

	    lm_connection_authenticate(this._obj, account.username, account.password, account.resource, new _ResultFunction(this._HandleResult), IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);

	}

	public bool AuthenticateAndBlock (Account account) {

	    return lm_connection_authenticate_and_block (this._obj, account.username, account.password, account.resource, IntPtr.Zero);

	}

	public void Send (Element element) {

	    lm_connection_send (this._obj, element.GetObject (), IntPtr.Zero); 

	}

	public void SendWithReply (Element element, ElementHandler handler) {

	    IntPtr ptr = new IntPtr();

	    IntPtr chandler;

	    chandler = lm_message_handler_new(new _ElementHandler(this.AsyncHandler), ptr, IntPtr.Zero);

	    _asyncHandlers.Add(ptr, handler);

	    lm_connection_send_with_reply(_obj, element.GetObject(), chandler, IntPtr.Zero);

	}

	public Element SendWithReplyAndBlock (Element element) {

	    return Element.CreateElement(lm_connection_send_with_reply_and_block(this._obj, element.GetObject(), IntPtr.Zero));

	}

	public void SendRaw (string raw) {

	    lm_connection_send_raw (this._obj, raw, IntPtr.Zero);

	}

	private void EmitIncomingMessage (Message m)

	{

	    if (IncomingMessage != null) {

		IncomingMessage (m);

	    }

	}

	private void EmitIncomingPresence (Presence p)

	{

	    if (IncomingPresence != null) {

		IncomingPresence (p);

	    } 

	}

	private void EmitIncomingIQ (IQ iq)

	{

	    if (IncomingIQ != null) {

		IncomingIQ (iq);

	    }

	}

	private void EmitDisconnected ()

	{

	    if (Disconnected != null) {

		Disconnected ();

	    }

	}

    }

}