using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;

namespace SoundIOSharp
{
	public class SoundIO : IDisposable
	{
		Pointer<SoundIo> handle;

		public SoundIO ()
		{
			handle = Natives.soundio_create ();
		}

		internal SoundIO (Pointer<SoundIo> handle)
		{
			this.handle = handle;
		}

		public void Dispose ()
		{
			foreach (var h in allocated_hglobals)
				Marshal.FreeHGlobal (h);
			Natives.soundio_destroy (handle);
		}

		// Equality (based on handle)

		public override bool Equals (object other)
		{
			var d = other as SoundIO;
			return d != null && this.handle == d.handle;
		}

		public override int GetHashCode ()
		{
			return (int) (IntPtr) handle;
		}

		public static bool operator == (SoundIO obj1, SoundIO obj2)
		{
			return (object)obj1 == null ? (object)obj2 == null : obj1.Equals (obj2);
		}

		public static bool operator != (SoundIO obj1, SoundIO obj2)
		{
			return (object)obj1 == null ? (object)obj2 != null : !obj1.Equals (obj2);
		}

		// fields

		// FIXME: this should be taken care in more centralized/decent manner... we don't want to write
		// this kind of code anywhere we need string marshaling.
		List<IntPtr> allocated_hglobals = new List<IntPtr> ();

		public string ApplicationName {
			get { return Marshal.PtrToStringAnsi (Marshal.ReadIntPtr (handle, app_name_offset)); }
			set {
				unsafe {
					var existing = Marshal.ReadIntPtr (handle, app_name_offset);
					if (allocated_hglobals.Contains (existing)) {
						allocated_hglobals.Remove (existing);
						Marshal.FreeHGlobal (existing);
					}
					var ptr = Marshal.StringToHGlobalAnsi (value);
					Marshal.WriteIntPtr (handle, app_name_offset, ptr);
					allocated_hglobals.Add (ptr);
				}
			}
		}
		static readonly int app_name_offset = (int)Marshal.OffsetOf<SoundIo> ("app_name");

		public SoundIOBackend CurrentBackend {
			get { return (SoundIOBackend) Marshal.ReadInt32 (handle, current_backend_offset); }
		}
		static readonly int current_backend_offset = (int)Marshal.OffsetOf<SoundIo> ("current_backend");

		// emit_rtprio_warning
		public Action EmitRealtimePriorityWarning {
			get { return emit_rtprio_warning; }
			set {
				emit_rtprio_warning = value;
				var ptr = Marshal.GetFunctionPointerForDelegate (on_devices_change);
				Marshal.WriteIntPtr (handle, emit_rtprio_warning_offset, ptr);
			}
		}
		static readonly int emit_rtprio_warning_offset = (int)Marshal.OffsetOf<SoundIo> ("emit_rtprio_warning");
		Action emit_rtprio_warning;

		// jack_error_callback
		public Action<string> JackErrorCallback {
			get { return jack_error_callback; }
			set {
				jack_error_callback = value;
				if (value == null)
					jack_error_callback = null;
				else
					jack_error_callback_native = msg => jack_error_callback (msg);
				var ptr = Marshal.GetFunctionPointerForDelegate (jack_error_callback_native);
				Marshal.WriteIntPtr (handle, jack_error_callback_offset, ptr);
			}
		}
		static readonly int jack_error_callback_offset = (int)Marshal.OffsetOf<SoundIo> ("jack_error_callback");
		Action<string> jack_error_callback;
		delegate void jack_error_delegate (string message);
		jack_error_delegate jack_error_callback_native;

		// jack_info_callback
		public Action<string> JackInfoCallback {
			get { return jack_info_callback; }
			set {
				jack_info_callback = value;
				if (value == null)
					jack_info_callback = null;
				else
					jack_info_callback_native = msg => jack_info_callback (msg);
				var ptr = Marshal.GetFunctionPointerForDelegate (jack_info_callback_native);
				Marshal.WriteIntPtr (handle, jack_info_callback_offset, ptr);
			}
		}
		static readonly int jack_info_callback_offset = (int)Marshal.OffsetOf<SoundIo> ("jack_info_callback");
		Action<string> jack_info_callback;
		delegate void jack_info_delegate (string message);
		jack_info_delegate jack_info_callback_native;

		// on_backend_disconnect
		public Action<int> OnBackendDisconnect {
			get { return on_backend_disconnect; }
			set {
				on_backend_disconnect = value;
				if (value == null)
					on_backend_disconnect_native = null;
				else
					on_backend_disconnect_native = (sio, err) => on_backend_disconnect (err);
				var ptr = Marshal.GetFunctionPointerForDelegate (on_backend_disconnect_native);
				Marshal.WriteIntPtr (handle, on_backend_disconnect_offset, ptr);
			}
		}
		static readonly int on_backend_disconnect_offset = (int)Marshal.OffsetOf<SoundIo> ("on_backend_disconnect");
		Action<int> on_backend_disconnect;
		delegate void on_backend_disconnect_delegate (IntPtr handle, int errorCode);
		on_backend_disconnect_delegate on_backend_disconnect_native;

		// on_devices_change
		public Action OnDevicesChange {
			get { return on_devices_change; }
			set {
				on_devices_change = value;
				if (value == null)
					on_devices_change_native = null;
				else
					on_devices_change_native = sio => on_devices_change ();
				var ptr = Marshal.GetFunctionPointerForDelegate (on_devices_change_native);
				Marshal.WriteIntPtr (handle, on_devices_change_offset, ptr);
			}
		}
		static readonly int on_devices_change_offset = (int)Marshal.OffsetOf<SoundIo> ("on_devices_change");
		Action on_devices_change;
		delegate void on_devices_change_delegate (IntPtr handle);
		on_devices_change_delegate on_devices_change_native;

		// on_events_signal
		public Action OnEventsSignal {
			get { return on_events_signal; }
			set {
				on_events_signal = value;
				if (value == null)
					on_events_signal_native = null;
				else
					on_events_signal_native = sio => on_events_signal ();
				var ptr = Marshal.GetFunctionPointerForDelegate (on_events_signal_native);
				Marshal.WriteIntPtr (handle, on_events_signal_offset, ptr);
			}
		}
		static readonly int on_events_signal_offset = (int)Marshal.OffsetOf<SoundIo> ("on_events_signal");
		Action on_events_signal;
		delegate void on_events_signal_delegate (IntPtr handle);
		on_events_signal_delegate on_events_signal_native;


		// functions

		public int BackendCount {
			get { return Natives.soundio_backend_count (handle); }
		}

		public int InputDeviceCount {
			get { return Natives.soundio_input_device_count (handle); }
		}

		public int OutputDeviceCount {
			get { return Natives.soundio_output_device_count (handle); }
		}

		public int DefaultInputDeviceIndex {
			get { return Natives.soundio_default_input_device_index (handle); }
		}

		public int DefaultOutputDeviceIndex {
			get { return Natives.soundio_default_output_device_index (handle); }
		}

		public SoundIOBackend GetBackend (int index)
		{
			return (SoundIOBackend) Natives.soundio_get_backend (handle, index);
		}

		public SoundIODevice GetInputDevice (int index)
		{
			return new SoundIODevice (Natives.soundio_get_input_device (handle, index));
		}

		public SoundIODevice GetOutputDevice (int index)
		{
			return new SoundIODevice (Natives.soundio_get_output_device (handle, index));
		}

		public void Connect ()
		{
			var ret = (SoundIoError) Natives.soundio_connect (handle);
			if (ret != SoundIoError.SoundIoErrorNone)
				throw new SoundIOException (ret);
		}

		public void ConnectBackend (SoundIOBackend backend)
		{
			var ret = (SoundIoError) Natives.soundio_connect_backend (handle, (SoundIoBackend) backend);
			if (ret != SoundIoError.SoundIoErrorNone)
				throw new SoundIOException (ret);
		}

		public void Disconnect ()
		{
			Natives.soundio_disconnect (handle);
		}

		public void FlushEvents ()
		{
			Natives.soundio_flush_events (handle);
		}

		public void WaitEvents ()
		{
			Natives.soundio_wait_events (handle);
		}

		public void Wakeup ()
		{
			Natives.soundio_wakeup (handle);
		}

		public void ForceDeviceScan ()
		{
			Natives.soundio_force_device_scan (handle);
		}

		public SoundIORingBuffer CreateRingBuffer (int capacity)
		{
			return new SoundIORingBuffer (Natives.soundio_ring_buffer_create (handle, capacity));
		}

		// static methods

		public static string VersionString {
			get { return Marshal.PtrToStringAnsi (Natives.soundio_version_string ()); }
		}

		public static int VersionMajor {
			get { return Natives.soundio_version_major (); }
		}

		public static int VersionMinor {
			get { return Natives.soundio_version_minor (); }
		}

		public static int VersionPatch {
			get { return Natives.soundio_version_patch (); }
		}

		public static string GetBackendName (SoundIOBackend backend)
		{
			return Marshal.PtrToStringAnsi (Natives.soundio_backend_name ((SoundIoBackend) backend));
		}

		public static bool HaveBackend (SoundIOBackend backend)
		{
			return Natives.soundio_have_backend ((SoundIoBackend) backend);
		}

		public static int GetBytesPerSample (SoundIOFormat format)
		{
			return Natives.soundio_get_bytes_per_sample ((SoundIoFormat) format);
		}

		public static int GetBytesPerFrame (SoundIOFormat format, int channelCount)
		{
			return Natives.soundio_get_bytes_per_frame ((SoundIoFormat) format, channelCount);
		}

		public static int GetBytesPerSecond (SoundIOFormat format, int channelCount, int sampleRate)
		{
			return Natives.soundio_get_bytes_per_second ((SoundIoFormat) format, channelCount, sampleRate);
		}

		public static string GetSoundFormatName (SoundIOFormat format)
		{
			return Marshal.PtrToStringAnsi (Natives.soundio_format_string ((SoundIoFormat) format));
		}
	}
}
