using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using BansheeEngine;

namespace BansheeEditor
{
	/** @addtogroup GUIEditor
	 *  @{
	 */

	/// <summary>
	/// Base class that can be implemented by GUI elements needing to elements along draw a horizontal timeline.
	/// </summary>
	public partial class GUITimeline : GUIElement
	{
		private GUITimeline(bool __dummy0) { }
		protected GUITimeline() { }

		/// <summary>Determines the range of values to display on the timeline, in seconds.</summary>
		public float Range
		{
			get { return Internal_getRange(mCachedPtr); }
			set { Internal_setRange(mCachedPtr, value); }
		}

		/// <summary>Determines the offset at which the displayed timeline values start at, in seconds.</summary>
		public float Offset
		{
			get { return Internal_getOffset(mCachedPtr); }
			set { Internal_setOffset(mCachedPtr, value); }
		}

		/// <summary>Number of frames per second, used for frame selection and marking.</summary>
		public uint FPS
		{
			get { return Internal_getFPS(mCachedPtr); }
			set { Internal_setFPS(mCachedPtr, value); }
		}

		/// <summary>Frame to display the frame marker on. Set to -1 to clear the frame marker.</summary>
		public uint MarkedFrame
		{
			get { return Internal_setMarkedFrame0(mCachedPtr); }
			set { Internal_setMarkedFrame(mCachedPtr, value); }
		}

		/// <summary>Sets the size of padding to apply to the left and right sides of the curve drawing, in pixels.</summary>
		public uint Padding
		{
			get { return Internal_getPadding(mCachedPtr); }
			set { Internal_setPadding(mCachedPtr, value); }
		}

		/// <summary>
		/// Uses the assigned FPS, range and physical size to calculate the frame that is under the provided coordinates.
		/// </summary>
		/// <param name="pixelCoords">Coordinates relative to this GUI element.</param>
		/// <returns>Frame that was clicked on, or -1 if the coordinates are outside of valid bounds.</returns>
		public uint GetFrame(Vector2I pixelCoords)
		{
			return Internal_getFrame(mCachedPtr, ref pixelCoords);
		}

		/// <summary>Returns the time at the specified pixel value along the timeline.</summary>
		/// <param name="pixel">X coordinate to sample at, relative to this GUI element in pixels.</param>
		/// <returns>Time along the curve at the specified coordinate.</returns>
		public float GetTime(int pixel)
		{
			return Internal_getTime(mCachedPtr, pixel);
		}

		/// <summary>Finds the pixel offset relative to the GUI element's origin for the specified time.</summary>
		/// <param name="time">Time value to return the offset for.</param>
		/// <returns>Offset in pixels relative to GUI element's origin</returns>
		public int GetOffset(float time)
		{
			return Internal_getOffset0(mCachedPtr, time);
		}

		/// <summary>Returns time for a frame with the specified index. Depends on set range and FPS.</summary>
		/// <param name="index">Index of the frame (not a key-frame) to get the time for.</param>
		/// <returns>Time of the frame with the provided index.</returns>
		public float GetTimeForFrame(int index)
		{
			return Internal_getTimeForFrame(mCachedPtr, index);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void Internal_setRange(IntPtr thisPtr, float range);
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern float Internal_getRange(IntPtr thisPtr);
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void Internal_setOffset(IntPtr thisPtr, float offset);
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern float Internal_getOffset(IntPtr thisPtr);
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void Internal_setFPS(IntPtr thisPtr, uint FPS);
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern uint Internal_getFPS(IntPtr thisPtr);
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void Internal_setMarkedFrame(IntPtr thisPtr, uint index);
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern uint Internal_setMarkedFrame0(IntPtr thisPtr);
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern uint Internal_getFrame(IntPtr thisPtr, ref Vector2I pixelCoords);
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern float Internal_getTime(IntPtr thisPtr, int pixel);
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern int Internal_getOffset0(IntPtr thisPtr, float time);
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern float Internal_getTimeForFrame(IntPtr thisPtr, int index);
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void Internal_setPadding(IntPtr thisPtr, uint padding);
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern uint Internal_getPadding(IntPtr thisPtr);
	}

	/** @} */
}