using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using UnityEditor;
using UnityEngine;

namespace Borodar.RainbowHierarchy.RList {

	public class ReorderableList {

		private const float ELEMENT_EDGE_TOP = 1;
		private const float ELEMENT_EDGE_BOT = 3;
		private const float ELEMENT_HEIGHT_OFFSET = ELEMENT_EDGE_TOP + ELEMENT_EDGE_BOT;

		private static int selectionHash = "ReorderableListSelection".GetHashCode();
		private static int dragAndDropHash = "ReorderableListDragAndDrop".GetHashCode();

		private const string EMPTY_LABEL = "List is Empty";
		private const string ARRAY_ERROR = "{0} is not an Array!";

		public enum ElementDisplayType {
			Auto,
			Expandable,
			SingleLine
		}

		public delegate void DrawHeaderDelegate(Rect rect, GUIContent label);
		public delegate void DrawFooterDelegate(Rect rect);
		public delegate void DrawElementDelegate(Rect rect, SerializedProperty element, GUIContent label, bool selected, bool focused);
		public delegate void ActionDelegate(ReorderableList list);
		public delegate bool ActionBoolDelegate(ReorderableList list);
		public delegate void AddDropdownDelegate(Rect buttonRect, ReorderableList list);
		public delegate Object DragDropReferenceDelegate(Object[] references, ReorderableList list);
		public delegate void DragDropAppendDelegate(Object reference, ReorderableList list);
		public delegate float GetElementHeightDelegate(SerializedProperty element);
		public delegate float GetElementsHeightDelegate(ReorderableList list);
		public delegate string GetElementNameDelegate(SerializedProperty element);
		public delegate GUIContent GetElementLabelDelegate(SerializedProperty element);
		public delegate void SurrogateCallback(SerializedProperty element, Object objectReference, ReorderableList list);

		public event DrawHeaderDelegate drawHeaderCallback;
		public event DrawFooterDelegate drawFooterCallback;
		public event DrawElementDelegate drawElementCallback;
		public event DrawElementDelegate drawElementBackgroundCallback;
		public event GetElementHeightDelegate getElementHeightCallback;
		public event GetElementsHeightDelegate getElementsHeightCallback;
		public event GetElementNameDelegate getElementNameCallback;
		public event GetElementLabelDelegate getElementLabelCallback;
		public event DragDropReferenceDelegate onValidateDragAndDropCallback;
		public event DragDropAppendDelegate onAppendDragDropCallback;
		public event ActionDelegate onReorderCallback;
		public event ActionDelegate onSelectCallback;
		public event ActionDelegate onAddCallback;
		public event AddDropdownDelegate onAddDropdownCallback;
		public event ActionDelegate onRemoveCallback;
		public event ActionDelegate onMouseUpCallback;
		public event ActionBoolDelegate onCanRemoveCallback;
		public event ActionDelegate onChangedCallback;

		public bool canAdd;
		public bool canRemove;
		public bool draggable;
		public bool sortable;
		public bool expandable;
		public bool multipleSelection;
		public GUIContent label;
		public float headerHeight;
		public float paginationHeight;
		public float footerHeight;
		public float slideEasing;
		public float verticalSpacing;
		public bool showDefaultBackground;
		public ElementDisplayType elementDisplayType;
		public string elementNameProperty;
		public string elementNameOverride;
		public bool elementLabels;
		public Texture elementIcon;
		public Surrogate surrogate;

		public bool paginate {
			get { return pagination.enabled; }
			set { pagination.enabled = value; }
		}

		public int pageSize {
			get { return pagination.pageSize; }
			set { pagination.pageSize = value; }
		}

		internal readonly int id;

		private SerializedProperty list;
		private int controlID = -1;
		private Rect[] elementRects;
		private GUIContent elementLabel;
		private GUIContent pageInfoContent;
		private GUIContent pageSizeContent;
		private ListSelection selection;
		private SlideGroup slideGroup;
		private int pressIndex;

		private bool doPagination {

			get { return pagination.enabled && !list.serializedObject.isEditingMultipleObjects; }
		}

		private float elementSpacing {

			get { return Mathf.Max(0, verticalSpacing - 2); }
		}

		private bool dragging;
		private float pressPosition;
		private float dragPosition;
		private int dragDirection;
		private DragList dragList;
		private ListSelection beforeDragSelection;
		private Pagination pagination;

		private int dragDropControlID = -1;

		public ReorderableList(SerializedProperty list)
			: this(list, true, true, true) {
		}

		public ReorderableList(SerializedProperty list, bool canAdd, bool canRemove, bool draggable)
			: this(list, canAdd, canRemove, draggable, ElementDisplayType.Auto, null, null, null) {
		}

		public ReorderableList(SerializedProperty list, bool canAdd, bool canRemove, bool draggable, ElementDisplayType elementDisplayType, string elementNameProperty, Texture elementIcon)
			: this(list, canAdd, canRemove, draggable, elementDisplayType, elementNameProperty, null, elementIcon) {
		}

		public ReorderableList(SerializedProperty list, bool canAdd, bool canRemove, bool draggable, ElementDisplayType elementDisplayType, string elementNameProperty, string elementNameOverride, Texture elementIcon) {

			if (list == null) {

				throw new MissingListExeption();
			}
			else if (!list.isArray) {

				//check if user passed in a ReorderableArray, if so, that becomes the list object

				SerializedProperty array = list.FindPropertyRelative("array");

				if (array == null || !array.isArray) {

					throw new InvalidListException();
				}

				this.list = array;
			}
			else {

				this.list = list;
			}

			this.canAdd = canAdd;
			this.canRemove = canRemove;
			this.draggable = draggable;
			this.elementDisplayType = elementDisplayType;
			this.elementNameProperty = elementNameProperty;
			this.elementNameOverride = elementNameOverride;
			this.elementIcon = elementIcon;

			id = GetHashCode();
			list.isExpanded = true;
			label = new GUIContent(list.displayName);
			pageInfoContent = new GUIContent();
			pageSizeContent = new GUIContent();

			verticalSpacing = EditorGUIUtility.standardVerticalSpacing;

			headerHeight = 18f;
			paginationHeight = 20f;
			footerHeight = 13f;
			slideEasing = 0.15f;
			expandable = true;
			elementLabels = true;
			showDefaultBackground = true;
			multipleSelection = true;
			pagination = new Pagination();
			elementLabel = new GUIContent();

			dragList = new DragList(0);
			selection = new ListSelection();
			slideGroup = new SlideGroup();
			elementRects = new Rect[0];
		}

		//
		// -- PROPERTIES --
		//

		public SerializedProperty List {

			get { return list; }
			internal set { list = value; }
		}

		public bool HasList {

			get { return list != null && list.isArray; }
		}

		public int Length {

			get {

				if (!HasList) {

					return 0;
				}
				else if (!list.hasMultipleDifferentValues) {

					return list.arraySize;
				}

				//When multiple objects are selected, because of a Unity bug, list.arraySize is never guranteed to actually be the smallest
				//array size. So we have to find it. Not that great since we're creating SerializedObjects here. There has to be a better way!

				int smallerArraySize = list.arraySize;

				foreach (Object targetObject in list.serializedObject.targetObjects) {

					SerializedObject serializedObject = new SerializedObject(targetObject);
					SerializedProperty property = serializedObject.FindProperty(list.propertyPath);

					smallerArraySize = Mathf.Min(property.arraySize, smallerArraySize);
				}

				return smallerArraySize;
			}
		}

		public int VisibleLength {

			get { return pagination.GetVisibleLength(Length); }
		}

		public int[] Selected {

			get { return selection.ToArray(); }
			set { selection = new ListSelection(value); }
		}

		public int Index {

			get { return selection.First; }
			set { selection.Select(value); }
		}

		public bool IsDragging {

			get { return dragging; }
		}

		//
		// -- PUBLIC --
		//

		public float GetHeight()
		{
			if (HasList) {
				var topHeight = doPagination ? headerHeight + paginationHeight : headerHeight;
				return list.isExpanded ? topHeight + GetElementsHeight() + footerHeight : headerHeight;
			}

			return EditorGUIUtility.singleLineHeight;
		}

		public void DoLayoutList() {

			Rect position = EditorGUILayout.GetControlRect(false, GetHeight(), EditorStyles.largeLabel);

			DoList(EditorGUI.IndentedRect(position), label);
		}

		public void DoList(Rect rect, GUIContent label) {

			int indent = EditorGUI.indentLevel;
			EditorGUI.indentLevel = 0;

			Rect headerRect = rect;
			headerRect.height = headerHeight;

			if (!HasList) {
				DrawEmpty(headerRect, string.Format(ARRAY_ERROR, label.text), GUIStyle.none, EditorStyles.helpBox);
			}
			else
			{
				controlID = GUIUtility.GetControlID(selectionHash, FocusType.Keyboard, rect);
				dragDropControlID = GUIUtility.GetControlID(dragAndDropHash, FocusType.Passive, rect);

				DrawHeader(headerRect, label);

				if (list.isExpanded) {
					if (doPagination) {
						Rect paginateHeaderRect = headerRect;
						paginateHeaderRect.y += headerRect.height;
						paginateHeaderRect.height = paginationHeight;

						DrawPaginationHeader(paginateHeaderRect);

						headerRect.yMax = paginateHeaderRect.yMax - 1;
					}

					Rect elementBackgroundRect = rect;
					elementBackgroundRect.yMin = headerRect.yMax;
					elementBackgroundRect.yMax = rect.yMax - footerHeight;

					Event evt = Event.current;

					if (selection.Length > 1) {
						if (evt.type == EventType.ContextClick && CanSelect(evt.mousePosition)) {
							HandleMultipleContextClick(evt);
						}
					}

					if (Length > 0) {
						//update element rects if not dragging. Dragging caches draw rects so no need to update
						if (!dragging) {
							UpdateElementRects(elementBackgroundRect, evt);
						}

						if (elementRects.Length > 0) {
							int start, end;

							pagination.GetVisibleRange(elementRects.Length, out start, out end);

							Rect selectableRect = elementBackgroundRect;
							selectableRect.yMin = elementRects[start].yMin;
							selectableRect.yMax = elementRects[end - 1].yMax;

							HandlePreSelection(selectableRect, evt);
							DrawElements(elementBackgroundRect, evt);
							HandlePostSelection(selectableRect, evt);
						}
					}
					else {
						DrawEmpty(elementBackgroundRect, EMPTY_LABEL, Style.boxBackground, Style.verticalLabel);
					}

					Rect footerRect = rect;
					footerRect.yMin = elementBackgroundRect.yMax;
					footerRect.xMin = rect.xMax - 58;

					DrawFooter(footerRect);
				}
			}

			EditorGUI.indentLevel = indent;
		}

		public SerializedProperty AddItem<T>(T item) where T : Object {

			SerializedProperty property = AddItem();

			if (property != null) {

				property.objectReferenceValue = item;
			}

			return property;
		}

		public SerializedProperty AddItem() {

			if (HasList) {

				//TODO Validate add on multiple selected objects

				list.arraySize++;
				selection.Select(list.arraySize - 1);

				SetPageByIndex(list.arraySize - 1);
				DispatchChange();

				return list.GetArrayElementAtIndex(selection.Last);
			}
			else {

				throw new InvalidListException();
			}
		}

		public void Remove(int[] selection) {

			System.Array.Sort(selection);

			int i = selection.Length;

			while (--i > -1) {

				RemoveItem(selection[i]);
			}
		}

		public void RemoveItem(int index) {

			if (index >= 0 && index < Length) {

				SerializedProperty property = list.GetArrayElementAtIndex(index);

				if (property.propertyType == SerializedPropertyType.ObjectReference && property.objectReferenceValue) {

					property.objectReferenceValue = null;
				}

				list.DeleteArrayElementAtIndex(index);
				selection.Remove(index);

				//TODO Validate removal on multiple selected objects

				if (Length > 0) {
					selection.Select(Mathf.Max(0, index - 1));
				}

				DispatchChange();
			}
		}

		public SerializedProperty GetItem(int index) {

			if (index >= 0 && index < Length) {

				return list.GetArrayElementAtIndex(index);
			}
			else {

				return null;
			}
		}

		public int IndexOf(SerializedProperty element) {

			if (element != null) {

				int i = Length;

				while (--i > -1) {

					if (SerializedProperty.EqualContents(element, list.GetArrayElementAtIndex(i))) {

						return i;
					}
				}
			}

			return -1;
		}

		public void GrabKeyboardFocus() {

			GUIUtility.keyboardControl = id;
		}

		public bool HasKeyboardControl() {

			return GUIUtility.keyboardControl == id;
		}

		public void ReleaseKeyboardFocus() {

			if (GUIUtility.keyboardControl == id) {

				GUIUtility.keyboardControl = 0;
			}
		}

		public void SetPage(int page) {

			if (doPagination) {

				pagination.page = page;
			}
		}

		public void SetPageByIndex(int index) {

			if (doPagination) {

				pagination.page = pagination.GetPageForIndex(index);
			}
		}

		public int GetPage(int index) {

			return doPagination ? pagination.page : 0;
		}

		public int GetPageByIndex(int index) {

			return doPagination ? pagination.GetPageForIndex(index) : 0;
		}

		//
		// -- PRIVATE --
		//

		private float GetElementsHeight() {

			if (getElementsHeightCallback != null) {

				return getElementsHeightCallback(this);
			}

			int i, len = Length;

			if (len == 0) {

				return 28;
			}

			float totalHeight = 0;
			float spacing = elementSpacing;

			int start, end;

			pagination.GetVisibleRange(len, out start, out end);

			for (i = start; i < end; i++) {

				totalHeight += GetElementHeight(list.GetArrayElementAtIndex(i)) + spacing;
			}

			return totalHeight + 7 - spacing;
		}

		private float GetElementHeight(SerializedProperty element) {

			if (getElementHeightCallback != null) {

				return getElementHeightCallback(element) + ELEMENT_HEIGHT_OFFSET;
			}
			else
			{
				var height = EditorGUI.GetPropertyHeight(element, GetElementLabel(element, elementLabels),IsElementExpandable(element));
				height = (height > 0) ? height + ELEMENT_HEIGHT_OFFSET : height;
				return height;
			}
		}

		private Rect GetElementDrawRect(int index, Rect desiredRect) {

			if (slideEasing <= 0) {

				return desiredRect;
			}
			else {

				//lerp the drag easing toward slide easing, this creates a stronger easing at the start then slower at the end
				//when dealing with large lists, we can

				return dragging ? slideGroup.GetRect(dragList[index].startIndex, desiredRect, slideEasing) : slideGroup.SetRect(index, desiredRect);
			}
		}

		/*
		private Rect GetElementHeaderRect(SerializedProperty element, Rect elementRect) {

			Rect rect = elementRect;
			rect.height = EditorGUIUtility.singleLineHeight + verticalSpacing;

			return rect;
		}
		*/

		private Rect GetElementRenderRect(SerializedProperty element, Rect elementRect) {

			float offset = draggable ? 20 : 5;

			Rect rect = elementRect;
			rect.xMin += IsElementExpandable(element) ? offset + 10 : offset;
			rect.xMax -= 6;
			rect.yMin += ELEMENT_EDGE_TOP;
			rect.yMax -= ELEMENT_EDGE_BOT;

			return rect;
		}

		private void DrawHeader(Rect rect, GUIContent label) {

			if (showDefaultBackground && Event.current.type == EventType.Repaint) {

				Style.headerBackground.Draw(rect, false, false, false, false);
			}

			HandleDragAndDrop(rect, Event.current);

			bool multiline = elementDisplayType != ElementDisplayType.SingleLine;

			Rect titleRect = rect;
			titleRect.xMin += 6f;
			titleRect.xMax -= multiline ? 95f : 55f;
			titleRect.height -= 2f;
			titleRect.y++;

			label = EditorGUI.BeginProperty(titleRect, label, list);

			if (drawHeaderCallback != null) {

				drawHeaderCallback(titleRect, label);
			}
			else if (expandable) {

				titleRect.xMin += 10;

				EditorGUI.BeginChangeCheck();

				bool isExpanded = EditorGUI.Foldout(titleRect, list.isExpanded, label, true);

				if (EditorGUI.EndChangeCheck()) {

					list.isExpanded = isExpanded;
				}
			}
			else {
				GUI.Label(titleRect, label, EditorStyles.label);
			}

			EditorGUI.EndProperty();

			if (multiline) {

				Rect bRect1 = rect;
				bRect1.xMin = rect.xMax - 25;
				bRect1.xMax = rect.xMax - 5;

				if (GUI.Button(bRect1, Style.expandButton, Style.preButton)) {

					ExpandElements(true);
				}

				Rect bRect2 = rect;
				bRect2.xMin = bRect1.xMin - 20;
				bRect2.xMax = bRect1.xMin;

				if (GUI.Button(bRect2, Style.collapseButton, Style.preButton)) {

					ExpandElements(false);
				}

				rect.xMax = bRect2.xMin + 5;
			}

			//draw sorting options

			if (sortable) {

				Rect sortRect1 = rect;
				sortRect1.xMin = rect.xMax - 25;
				sortRect1.xMax = rect.xMax;

				Rect sortRect2 = rect;
				sortRect2.xMin = sortRect1.xMin - 20;
				sortRect2.xMax = sortRect1.xMin;

				if (EditorGUI.DropdownButton(sortRect1, Style.sortAscending, FocusType.Passive, Style.preButton)) {

					SortElements(sortRect1, false);
				}

				if (EditorGUI.DropdownButton(sortRect2, Style.sortDescending, FocusType.Passive, Style.preButton)) {

					SortElements(sortRect2, true);
				}
			}
		}

		private void ExpandElements(bool expand) {

			if (!list.isExpanded && expand) {

				list.isExpanded = true;
			}

			int i, len = Length;

			for (i = 0; i < len; i++) {

				list.GetArrayElementAtIndex(i).isExpanded = expand;
			}
		}

		private void SortElements(Rect rect, bool descending) {

			int total = Length;

			//no point in sorting a list with 1 element!

			if (total <= 1) {

				return;
			}

			//the first property tells us what type of items are in the list
			//if generic, then we give the user a list of properties to sort on

			SerializedProperty prop = list.GetArrayElementAtIndex(0);

			if (prop.propertyType == SerializedPropertyType.Generic) {

				GenericMenu menu = new GenericMenu();

				SerializedProperty property = prop.Copy();
				SerializedProperty end = property.GetEndProperty();

				bool enterChildren = true;

				while (property.NextVisible(enterChildren) && !SerializedProperty.EqualContents(property, end)) {

					menu.AddItem(new GUIContent(property.name), false, userData => {

						//sort based on the property selected then apply the changes

						ListSort.SortOnProperty(list, total, descending, (string)userData);

						ApplyReorder();

						HandleUtility.Repaint();

					}, property.name);

					enterChildren = false;
				}

				menu.DropDown(rect);
			}
			else {

				//list is not generic, so we just sort directly on the type then apply the changes

				ListSort.SortOnType(list, total, descending, prop.propertyType);

				ApplyReorder();
			}
		}

		private void DrawEmpty(Rect rect, string label, GUIStyle backgroundStyle, GUIStyle labelStyle) {

			if (showDefaultBackground && Event.current.type == EventType.Repaint) {

				backgroundStyle.Draw(rect, false, false, false, false);
			}

			EditorGUI.LabelField(rect, label, labelStyle);
		}

		private void UpdateElementRects(Rect rect, Event evt) {

			//resize array if elements changed

			int i, len = Length;

			if (len != elementRects.Length) {

				System.Array.Resize(ref elementRects, len);
			}

			if (evt.type == EventType.Repaint) {

				//start rect

				Rect elementRect = rect;
				elementRect.yMin = elementRect.yMax = rect.yMin + 2;

				float spacing = elementSpacing;

				int start, end;

				pagination.GetVisibleRange(len, out start, out end);

				for (i = start; i < end; i++) {

					SerializedProperty element = list.GetArrayElementAtIndex(i);

					//update the elementRects value for this object. Grab the last elementRect for startPosition

					elementRect.y = elementRect.yMax;
					elementRect.height = GetElementHeight(element);
					elementRects[i] = elementRect;

					elementRect.yMax += spacing;
				}
			}
		}

		private void DrawElements(Rect rect, Event evt) {

			//draw list background

			if (showDefaultBackground && evt.type == EventType.Repaint) {

				Style.boxBackground.Draw(rect, false, false, false, false);
			}

			//if not dragging, draw elements as usual

			if (!dragging) {

				int start, end;

				pagination.GetVisibleRange(Length, out start, out end);

				for (int i = start; i < end; i++) {

					bool selected = selection.Contains(i);

					DrawElement(list.GetArrayElementAtIndex(i), GetElementDrawRect(i, elementRects[i]), selected, selected && GUIUtility.keyboardControl == controlID);
				}
			}
			else if (evt.type == EventType.Repaint) {

				//draw dragging elements only when repainting

				int i, s, len = dragList.Length;
				int sLen = selection.Length;

				//first, find the rects of the selected elements, we need to use them for overlap queries

				for (i = 0; i < sLen; i++) {

					DragElement element = dragList[i];

					//update the element desiredRect if selected. Selected elements appear first in the dragList, so other elements later in iteration will have rects to compare

					element.desiredRect.y = dragPosition - element.dragOffset;
					dragList[i] = element;
				}

				//draw elements, start from the bottom of the list as first elements are the ones selected, so should be drawn last

				i = len;

				while (--i > -1) {

					DragElement element = dragList[i];

					//draw dragging elements last as the loop is backwards

					if (element.selected) {

						DrawElement(element.property, element.desiredRect, true, true);
						continue;
					}

					//loop over selection and see what overlaps
					//if dragging down we start from the bottom of the selection
					//otherwise we start from the top. This helps to cover multiple selected objects

					Rect elementRect = element.rect;
					int elementIndex = element.startIndex;

					int start = dragDirection > 0 ? sLen - 1 : 0;
					int end = dragDirection > 0 ? -1 : sLen;

					for (s = start; s != end; s -= dragDirection) {

						DragElement selected = dragList[s];

						if (selected.Overlaps(elementRect, elementIndex, dragDirection)) {

							elementRect.y -= selected.rect.height * dragDirection;
							elementIndex += dragDirection;
						}
					}

					//draw the element with the new rect

					DrawElement(element.property, GetElementDrawRect(i, elementRect), false, false);

					//reassign the element back into the dragList

					element.desiredRect = elementRect;
					dragList[i] = element;
				}
			}
		}

		private void DrawElement(SerializedProperty element, Rect rect, bool selected, bool focused)
		{
			// Dont draw nothing for "hidden" elements
			if (rect.height < 1) return;

			Event evt = Event.current;

			if (drawElementBackgroundCallback != null)
			{
				drawElementBackgroundCallback(rect, element, null, selected, focused);
			}
			else if (evt.type == EventType.Repaint)
			{
				Style.elementBackground.Draw(rect, false, selected, selected, focused);

				// Separator
				var separatorRect = new Rect(rect.x + 1, rect.y + rect.height - 2, rect.width - 3, 1);
				EditorGUI.DrawRect(separatorRect, new Color(0f, 0f, 0f, 0.2f));
			}

			if (evt.type == EventType.Repaint && draggable)
			{
				Style.draggingHandle.Draw(new Rect(rect.x + 5, rect.y + 14, 10, rect.height - (rect.height - 6)), false, false, false, false);
			}

			GUIContent label = GetElementLabel(element, elementLabels);
			Rect renderRect = GetElementRenderRect(element, rect);

			if (drawElementCallback != null)
			{
				drawElementCallback(renderRect, element, label, selected, focused);
			}
			else
			{
				EditorGUI.PropertyField(renderRect, element, label, true);
			}

			//handle context click

			int controlId = GUIUtility.GetControlID(label, FocusType.Passive, rect);

			switch (evt.GetTypeForControl(controlId)) {
				case EventType.ContextClick:
					if (rect.Contains(evt.mousePosition))
						HandleSingleContextClick(evt, element);

					break;
			}
		}

		private GUIContent GetElementLabel(SerializedProperty element, bool allowElementLabel) {

			if (!allowElementLabel) {

				return GUIContent.none;
			}
			else if (getElementLabelCallback != null) {

				return getElementLabelCallback(element);
			}

			string name;

			if (getElementNameCallback != null) {

				name = getElementNameCallback(element);
			}
			else {

				name = GetElementName(element, elementNameProperty, elementNameOverride);
			}

			elementLabel.text = !string.IsNullOrEmpty(name) ? name : element.displayName;
			elementLabel.tooltip = element.tooltip;
			elementLabel.image = elementIcon;

			return elementLabel;
		}

		private static string GetElementName(SerializedProperty element, string nameProperty, string nameOverride) {

			if (!string.IsNullOrEmpty(nameOverride)) {

				string path = element.propertyPath;

				const string arrayEndDelimeter = "]";
				const char arrayStartDelimeter = '[';

				if (path.EndsWith(arrayEndDelimeter)) {

					int startIndex = path.LastIndexOf(arrayStartDelimeter) + 1;

					return string.Format("{0} {1}", nameOverride, path.Substring(startIndex, path.Length - startIndex - 1));
				}

				return nameOverride;
			}
			else if (string.IsNullOrEmpty(nameProperty)) {

				return null;
			}
			else if (element.propertyType == SerializedPropertyType.ObjectReference && nameProperty == "name") {

				return element.objectReferenceValue ? element.objectReferenceValue.name : null;
			}

			SerializedProperty prop = element.FindPropertyRelative(nameProperty);

			if (prop != null) {

				switch (prop.propertyType) {

					case SerializedPropertyType.ObjectReference:

						return prop.objectReferenceValue ? prop.objectReferenceValue.name : null;

					case SerializedPropertyType.Enum:

						return prop.enumDisplayNames[prop.enumValueIndex];

					case SerializedPropertyType.Integer:
					case SerializedPropertyType.Character:

						return prop.intValue.ToString();

					case SerializedPropertyType.LayerMask:

						return GetLayerMaskName(prop.intValue);

					case SerializedPropertyType.String:

						return prop.stringValue;

					case SerializedPropertyType.Float:

						return prop.floatValue.ToString();
				}

				return prop.displayName;
			}

			return null;
		}

		private static string GetLayerMaskName(int mask) {

			if (mask == 0) {

				return "Nothing";
			}
			else if (mask < 0) {

				return "Everything";
			}

			string name = string.Empty;
			int n = 0;

			for (int i = 0; i < 32; i++) {

				if (((1 << i) & mask) != 0) {

					if (n == 4) {

						return "Mixed ...";
					}

					name += (n > 0 ? ", " : string.Empty) + LayerMask.LayerToName(i);
					n++;
				}
			}

			return name;
		}

		private void DrawFooter(Rect rect) {

			if (drawFooterCallback != null) {

				drawFooterCallback(rect);
				return;
			}

			if (Event.current.type == EventType.Repaint) {

				Style.footerBackground.Draw(rect, false, false, false, false);
			}

			Rect addRect = new Rect(rect.xMin + 4f, rect.y - 1f, 25f, 13f);
			Rect subRect = new Rect(rect.xMax - 29f, rect.y - 1f, 25f, 13f);

			EditorGUI.BeginDisabledGroup(!canAdd);

			if (GUI.Button(addRect, onAddDropdownCallback != null ? Style.iconToolbarPlusMore : Style.iconToolbarPlus, Style.preButton)) {

				if (onAddDropdownCallback != null) {

					onAddDropdownCallback(addRect, this);
				}
				else if (onAddCallback != null) {

					onAddCallback(this);
				}
				else {

					AddItem();
				}
			}

			EditorGUI.EndDisabledGroup();

			EditorGUI.BeginDisabledGroup(!CanSelect(selection) || !canRemove || (onCanRemoveCallback != null && !onCanRemoveCallback(this)));

			if (GUI.Button(subRect, Style.iconToolbarMinus, Style.preButton)) {

				if (onRemoveCallback != null) {

					onRemoveCallback(this);
				}
				else {
					Remove(selection.ToArray());

					list.serializedObject.ApplyModifiedProperties();
					list.serializedObject.Update();
				}
			}

			EditorGUI.EndDisabledGroup();
		}

		private void DrawPaginationHeader(Rect rect) {

			int total = Length;
			int pages = pagination.GetPageCount(total);
			int page = Mathf.Clamp(pagination.page, 0, pages - 1);

			//some actions may have reduced the page count, so we need to check the current page against the clamped one
			//if different, we need to change and repaint

			if (page != pagination.page) {

				pagination.page = page;
				HandleUtility.Repaint();
			}

			var prevRect = new Rect(rect.xMin + 4f, rect.y + 1f, 17f, 14f);
			var popupRect = new Rect(prevRect.xMax, rect.y + 1f, 17f, 14f);
			var nextRect = new Rect(popupRect.xMax, rect.y + 1f, 17f, 14f);

			if (Event.current.type == EventType.Repaint) {

				Style.paginationHeader.Draw(rect, false, true, true, false);
			}

			pageInfoContent.text = string.Format(Style.PAGE_INFO_FORMAT, pagination.page + 1, pages);

			Rect pageInfoRect = rect;
			pageInfoRect.width = Style.paginationText.CalcSize(pageInfoContent).x;
			pageInfoRect.x = rect.xMax - pageInfoRect.width - 7;
			pageInfoRect.y += 2;

			//draw page info

			GUI.Label(pageInfoRect, pageInfoContent, Style.paginationText);

			//draw page buttons and page popup

			if (GUI.Button(prevRect, Style.iconPagePrev, Style.preButton)) {

				pagination.page = Mathf.Max(0, pagination.page - 1);
			}

			if (EditorGUI.DropdownButton(popupRect, Style.iconPagePopup, FocusType.Passive, Style.preButton)) {

				GenericMenu menu = new GenericMenu();

				for (int i = 0; i < pages; i++) {

					int pageIndex = i;

					menu.AddItem(new GUIContent(string.Format("Page {0}", i + 1)), i == pagination.page, OnPageDropDownSelect, pageIndex);
				}

				menu.DropDown(popupRect);
			}

			if (GUI.Button(nextRect, Style.iconPageNext, Style.preButton)) {

				pagination.page = Mathf.Min(pages - 1, pagination.page + 1);
			}

			//if we're allowed to control the page size manually, show an editor

			pageSizeContent.text = total.ToString();

			GUIStyle style = Style.pageSizeTextField;
			Texture icon = Style.listIcon.image;

			float min = nextRect.xMax + 5;
			float max = pageInfoRect.xMin - 5;
			float space = max - min;
			float labelWidth = icon.width + 2;
			float width = style.CalcSize(pageSizeContent).x + 50 + labelWidth;

			Rect pageSizeRect = rect;
			pageSizeRect.y += 2f;
			pageSizeRect.x = min + (space - width) / 2;
			pageSizeRect.width = width - labelWidth;

			var iconRect = pageSizeRect;
			iconRect.y -= 2f;
			iconRect.width = 18f;

			pageSizeRect.x += 18f;
			pageSizeRect.width -= 18f;

			EditorGUI.BeginChangeCheck();

			EditorGUIUtility.labelWidth = labelWidth;
			EditorGUIUtility.SetIconSize(new Vector2(icon.width, icon.height));

			GUI.Label(iconRect, Style.listIcon);
			int newPageSize = EditorGUI.DelayedIntField(pageSizeRect, GUIContent.none, pagination.pageSize, style);

			EditorGUIUtility.labelWidth = 0;
			EditorGUIUtility.SetIconSize(Vector2.zero);

			if (EditorGUI.EndChangeCheck()) {

				pagination.pageSize = Mathf.Clamp(newPageSize, 0, total);
				pagination.page = Mathf.Min(pagination.GetPageCount(total) - 1, pagination.page);
			}
		}

		private void OnPageDropDownSelect(object userData) {
			pagination.page = (int)userData;
		}

		private void DispatchChange() {
			if (onChangedCallback != null) onChangedCallback(this);
		}

		private void HandleSingleContextClick(Event evt, SerializedProperty element) {

			selection.Select(IndexOf(element));

			GenericMenu menu = new GenericMenu();

			if (element.isInstantiatedPrefab) {

				menu.AddItem(new GUIContent("Revert " + GetElementLabel(element, true).text + " to Prefab"), false, selection.RevertValues, list);
				menu.AddSeparator(string.Empty);
			}

			HandleSharedContextClick(evt, menu, "Duplicate Array Element", "Delete Array Element", "Move Array Element");
		}

		private void HandleMultipleContextClick(Event evt) {

			GenericMenu menu = new GenericMenu();

			if (selection.CanRevert(list)) {

				menu.AddItem(new GUIContent("Revert Values to Prefab"), false, selection.RevertValues, list);
				menu.AddSeparator(string.Empty);
			}

			HandleSharedContextClick(evt, menu, "Duplicate Array Elements", "Delete Array Elements", "Move Array Elements");
		}

		private void HandleSharedContextClick(Event evt, GenericMenu menu, string duplicateLabel, string deleteLabel, string moveLabel) {

			menu.AddItem(new GUIContent(duplicateLabel), false, HandleDuplicate, list);
			menu.AddItem(new GUIContent(deleteLabel), false, HandleDelete, list);

			if (doPagination) {

				int pages = pagination.GetPageCount(Length);

				if (pages > 1) {

					for (int i = 0; i < pages; i++) {

						string label = string.Format("{0}/Page {1}", moveLabel, i + 1);

						menu.AddItem(new GUIContent(label), i == pagination.page, HandleMoveElement, i);
					}
				}
			}

			menu.ShowAsContext();

			evt.Use();
		}

		private void HandleMoveElement(object userData) {

			int toPage = (int)userData;
			int fromPage = pagination.page;
			int size = pagination.pageSize;
			int offset = (toPage * size) - (fromPage * size);
			int direction = offset > 0 ? 1 : -1;
			int total = Length;

			//We need to find the actually positions things will move to and not clamp the index
			//because sometimes something wants to move to a negative index, or beyond the length
			//we need to find this overlow and adjust the move offsets based on that

			int overflow = 0;

			for (int i = 0; i < selection.Length; i++) {

				int desiredIndex = selection[i] + offset;

				overflow = direction < 0 ? Mathf.Min(overflow, desiredIndex) : Mathf.Max(overflow, desiredIndex - total);
			}

			offset -= overflow;

			//copy the current list to prepare for moving

			UpdateDragList(0, 0, total);

			//create a list that will act as our new order

			List<DragElement> orderedList = new List<DragElement>(dragList.Elements.Where(t => !selection.Contains(t.startIndex)));

			//go through the selection and insert them into the new order based on the page offset

			selection.Sort();

			for (int i = 0; i < selection.Length; i++) {

				int selIndex = selection[i];
				int oldIndex = dragList.GetIndexFromSelection(selIndex);
				int newIndex = Mathf.Clamp(selIndex + offset, 0, orderedList.Count);

				orderedList.Insert(newIndex, dragList[oldIndex]);
			}

			//finally, perform the re-order

			dragList.Elements = orderedList.ToArray();

			ReorderDraggedElements(direction, 0, null);

			//assume we still want to view these items

			pagination.page = toPage;
		}

		private void HandleDelete(object userData) {

			selection.Delete(userData as SerializedProperty);

			DispatchChange();
		}

		private void HandleDuplicate(object userData) {

			selection.Duplicate(userData as SerializedProperty);

			DispatchChange();
		}

		private void HandleDragAndDrop(Rect rect, Event evt) {

			switch (evt.GetTypeForControl(dragDropControlID)) {

				case EventType.DragUpdated:
				case EventType.DragPerform:

					if (GUI.enabled && rect.Contains(evt.mousePosition)) {

						Object[] objectReferences = DragAndDrop.objectReferences;
						Object[] references = new Object[1];

						bool acceptDrag = false;

						foreach (Object object1 in objectReferences) {

							references[0] = object1;
							Object object2 = ValidateObjectDragAndDrop(references);

							if (object2 != null) {

								DragAndDrop.visualMode = DragAndDropVisualMode.Copy;

								if (evt.type == EventType.DragPerform) {

									AppendDragAndDropValue(object2);

									acceptDrag = true;
									DragAndDrop.activeControlID = 0;
								}
								else {

									DragAndDrop.activeControlID = dragDropControlID;
								}
							}
						}

						if (acceptDrag) {

							GUI.changed = true;
							DragAndDrop.AcceptDrag();
						}
					}

					break;

				case EventType.DragExited:

					if (GUI.enabled) {

						HandleUtility.Repaint();
					}

					break;
			}
		}

		private Object ValidateObjectDragAndDrop(Object[] references) {

			if (onValidateDragAndDropCallback != null) {

				return onValidateDragAndDropCallback(references, this);
			}
			else if (surrogate.HasType) {

				//if we have a surrogate type, then validate using the surrogate type rather than the list

				return Internals.ValidateObjectDragAndDrop(references, null, surrogate.type, surrogate.exactType);
			}

			return Internals.ValidateObjectDragAndDrop(references, list, null, false);
		}

		private void AppendDragAndDropValue(Object obj) {

			if (onAppendDragDropCallback != null) {

				onAppendDragDropCallback(obj, this);
			}
			else {

				//check if we have a surrogate type. If so use that for appending

				if (surrogate.HasType) {

					surrogate.Invoke(AddItem(), obj, this);
				}
				else {

					Internals.AppendDragAndDropValue(obj, list);
				}
			}

			DispatchChange();
		}

		private void HandlePreSelection(Rect rect, Event evt) {

			if (evt.type == EventType.MouseDrag && draggable && GUIUtility.hotControl == controlID) {

				if (selection.Length > 0 && UpdateDragPosition(evt.mousePosition, rect, dragList)) {

					GUIUtility.keyboardControl = controlID;
					dragging = true;
				}

				evt.Use();
			}

			/* TODO This is buggy. The reason for this is to allow selection and dragging of an element using the header, or top row (if any)
			 * The main issue here is determining whether the element has an "expandable" drop down arrow, which if it does, will capture the mouse event *without* the code below
			 * Because of property drawers and certain property types, it's impossible to know this automatically (without dirty reflection)
			 * So if the below code is active and we determine that the property is expandable but isn't actually. Then we'll accidently capture the mouse focus and prevent anything else from receiving it :(
			 * So for now, in order to drag or select a row, the user must select empty space on the row. Not a huge deal, and doesn't break functionality.
			 * What needs to happen is the drag event needs to occur independent of the event type. But that's messy too, as some controls have horizontal drag sliders :(
			if (evt.type == EventType.MouseDown) {

				//check if we contain the mouse press
				//we also need to check what has current focus. If nothing we can assume control
				//if there's something, check if the header has been pressed if the element is expandable
				//if we did press the header, then override the control

				if (rect.Contains(evt.mousePosition) && IsSelectionButton(evt)) {

					int index = GetSelectionIndex(evt.mousePosition);

					if (CanSelect(index)) {

						SerializedProperty element = list.GetArrayElementAtIndex(index);

						if (IsElementExpandable(element)) {

							Rect elementHeaderRect = GetElementHeaderRect(element, elementRects[index]);
							Rect elementRenderRect = GetElementRenderRect(element, elementRects[index]);

							Rect elementExpandRect = elementHeaderRect;
							elementExpandRect.xMin = elementRenderRect.xMin - 10;
							elementExpandRect.xMax = elementRenderRect.xMin;

							if (elementHeaderRect.Contains(evt.mousePosition) && !elementExpandRect.Contains(evt.mousePosition)) {

								DoSelection(index, true, evt);
								HandleUtility.Repaint();
							}
						}
					}
				}
			}
			*/
		}

		private void HandlePostSelection(Rect rect, Event evt) {

			switch (evt.GetTypeForControl(controlID)) {

				case EventType.MouseDown:

					if (rect.Contains(evt.mousePosition) && IsSelectionButton(evt)) {

						int index = GetSelectionIndex(evt.mousePosition);

						if (CanSelect(index)) {

							DoSelection(index, GUIUtility.keyboardControl == 0 || GUIUtility.keyboardControl == controlID || evt.button == 2, evt);
						}
						else {

							selection.Clear();
						}

						HandleUtility.Repaint();
					}

					break;

				case EventType.MouseUp:

					if (!draggable) {

						//select the single object if no selection modifier is being performed

						selection.SelectWhenNoAction(pressIndex, evt);

						if (onMouseUpCallback != null && IsPositionWithinElement(evt.mousePosition, selection.Last)) {

							onMouseUpCallback(this);
						}
					}
					else if (GUIUtility.hotControl == controlID) {

						evt.Use();

						if (dragging) {

							dragging = false;

							//move elements in list

							ReorderDraggedElements(dragDirection, dragList.StartIndex, () => dragList.SortByPosition());
						}
						else {

							//if we didn't drag, then select the original pressed object

							selection.SelectWhenNoAction(pressIndex, evt);

							if (onMouseUpCallback != null) {

								onMouseUpCallback(this);
							}
						}

						GUIUtility.hotControl = 0;
					}

					HandleUtility.Repaint();

					break;

				case EventType.KeyDown:

					if (GUIUtility.keyboardControl == controlID) {

						if (evt.keyCode == KeyCode.DownArrow && !dragging) {

							selection.Select(Mathf.Min(selection.Last + 1, Length - 1));
							evt.Use();
						}
						else if (evt.keyCode == KeyCode.UpArrow && !dragging) {

							selection.Select(Mathf.Max(selection.Last - 1, 0));
							evt.Use();
						}
						else if (evt.keyCode == KeyCode.Escape && GUIUtility.hotControl == controlID) {

							GUIUtility.hotControl = 0;

							if (dragging) {

								dragging = false;
								selection = beforeDragSelection;
							}

							evt.Use();
						}
					}

					break;
			}
		}

		private bool IsSelectionButton(Event evt) {

			return evt.button == 0 || evt.button == 2;
		}

		private void DoSelection(int index, bool setKeyboardControl, Event evt) {

			//append selections based on action, this may be a additive (ctrl) or range (shift) selection

			if (multipleSelection) {

				selection.AppendWithAction(pressIndex = index, evt);
			}
			else {

				selection.Select(pressIndex = index);
			}

			if (onSelectCallback != null) {

				onSelectCallback(this);
			}

			if (draggable) {

				dragging = false;
				dragPosition = pressPosition = evt.mousePosition.y;

				int start, end;

				pagination.GetVisibleRange(Length, out start, out end);

				UpdateDragList(dragPosition, start, end);

				selection.Trim(start, end);

				beforeDragSelection = selection.Clone();

				GUIUtility.hotControl = controlID;
			}

			if (setKeyboardControl) {

				GUIUtility.keyboardControl = controlID;
			}

			evt.Use();
		}

		private void UpdateDragList(float dragPosition, int start, int end) {

			dragList.Resize(start, end - start);

			for (int i = start; i < end; i++) {

				SerializedProperty property = list.GetArrayElementAtIndex(i);
				Rect elementRect = elementRects[i];

				DragElement dragElement = new DragElement() {
					property = property,
					dragOffset = dragPosition - elementRect.y,
					rect = elementRect,
					desiredRect = elementRect,
					selected = selection.Contains(i),
					startIndex = i
				};

				dragList[i - start] = dragElement;
			}

			//finally, sort the dragList by selection, selected objects appear first in the list
			//selection order is preserved as well

			dragList.SortByIndex();
		}

		private bool UpdateDragPosition(Vector2 position, Rect bounds, DragList dragList) {

			//find new drag position

			int startIndex = 0;
			int endIndex = selection.Length - 1;

			float minOffset = dragList[startIndex].dragOffset;
			float maxOffset = dragList[endIndex].rect.height - dragList[endIndex].dragOffset;

			dragPosition = Mathf.Clamp(position.y, bounds.yMin + minOffset, bounds.yMax - maxOffset);

			if (Mathf.Abs(dragPosition - pressPosition) > 1) {

				dragDirection = (int)Mathf.Sign(dragPosition - pressPosition);
				return true;
			}

			return false;
		}

		private void ReorderDraggedElements(int direction, int offset, System.Action sortList) {

			//save the current expanded states on all elements. I don't see any other way to do this
			//MoveArrayElement does not move the foldout states, so... fun.

			dragList.RecordState();

			if (sortList != null) {

				sortList();
			}

			selection.Sort((a, b) => {

				int d1 = dragList.GetIndexFromSelection(a);
				int d2 = dragList.GetIndexFromSelection(b);

				return direction > 0 ? d1.CompareTo(d2) : d2.CompareTo(d1);
			});

			//swap the selected elements in the List

			int s = selection.Length;

			while (--s > -1) {

				int newIndex = dragList.GetIndexFromSelection(selection[s]);
				int listIndex = newIndex + offset;

				selection[s] = listIndex;

				list.MoveArrayElement(dragList[newIndex].startIndex, listIndex);
			}

			//restore expanded states on items

			dragList.RestoreState(list);

			//apply and update

			ApplyReorder();
		}

		private void ApplyReorder() {
			list.serializedObject.ApplyModifiedProperties();
			list.serializedObject.Update();

			if (onReorderCallback != null) {

				onReorderCallback(this);
			}

			DispatchChange();
		}

		private int GetSelectionIndex(Vector2 position) {

			int start, end;

			pagination.GetVisibleRange(elementRects.Length, out start, out end);

			for (int i = start; i < end; i++) {

				Rect rect = elementRects[i];

				if (rect.Contains(position) || (i == 0 && position.y <= rect.yMin) || (i == end - 1 && position.y >= rect.yMax)) {

					return i;
				}
			}

			return -1;
		}

		private bool CanSelect(ListSelection selection) {

			return selection.Length > 0 ? selection.All(s => CanSelect(s)) : false;
		}

		private bool CanSelect(int index) {

			return index >= 0 && index < Length;
		}

		private bool CanSelect(Vector2 position) {

			return selection.Length > 0 ? selection.Any(s => IsPositionWithinElement(position, s)) : false;
		}

		private bool IsPositionWithinElement(Vector2 position, int index) {

			return CanSelect(index) ? elementRects[index].Contains(position) : false;
		}

		private bool IsElementExpandable(SerializedProperty element) {

			switch (elementDisplayType) {

				case ElementDisplayType.Auto:

					return element.hasVisibleChildren && IsTypeExpandable(element.propertyType);

				case ElementDisplayType.Expandable: return true;
				case ElementDisplayType.SingleLine: return false;
			}

			return false;
		}

		private bool IsTypeExpandable(SerializedPropertyType type) {

			switch (type) {

				case SerializedPropertyType.Generic:
				case SerializedPropertyType.Vector4:
				case SerializedPropertyType.Quaternion:
				case SerializedPropertyType.ArraySize:

					return true;

				default:

					return false;
			}
		}

		//
		// -- LIST STYLE --
		//

		static class Style {

			internal const string PAGE_INFO_FORMAT = "{0} / {1}";

			internal static GUIContent iconToolbarPlus;
			internal static GUIContent iconToolbarPlusMore;
			internal static GUIContent iconToolbarMinus;
			internal static GUIContent iconPagePrev;
			internal static GUIContent iconPageNext;
			internal static GUIContent iconPagePopup;

			internal static GUIStyle paginationText;
			internal static GUIStyle pageSizeTextField;
			internal static GUIStyle draggingHandle;
			internal static GUIStyle headerBackground;
			internal static GUIStyle footerBackground;
			internal static GUIStyle paginationHeader;
			internal static GUIStyle boxBackground;
			internal static GUIStyle preButton;
			internal static GUIStyle elementBackground;
			internal static GUIStyle verticalLabel;
			internal static GUIContent expandButton;
			internal static GUIContent collapseButton;
			internal static GUIContent sortAscending;
			internal static GUIContent sortDescending;

			internal static GUIContent listIcon;

			static Style() {

				iconToolbarPlus = EditorGUIUtility.IconContent("Toolbar Plus", "| Add to list");
				iconToolbarPlusMore = EditorGUIUtility.IconContent("Toolbar Plus More", "| Choose to add to list");
				iconToolbarMinus = EditorGUIUtility.IconContent("Toolbar Minus", "| Remove selection from list");
				iconPagePrev = EditorGUIUtility.IconContent("Animation.PrevKey", "| Previous page");
				iconPageNext = EditorGUIUtility.IconContent("Animation.NextKey", "| Next page");
				iconPagePopup = EditorGUIUtility.IconContent("UnityEditor.SceneHierarchyWindow", "| Select page");

				paginationText = new GUIStyle();
				paginationText.margin = new RectOffset(2, 2, 0, 0);
				paginationText.fontSize = EditorStyles.miniTextField.fontSize;
				paginationText.font = EditorStyles.miniFont;
				paginationText.normal.textColor = EditorStyles.miniTextField.normal.textColor;
				paginationText.alignment = TextAnchor.UpperLeft;
				paginationText.clipping = TextClipping.Clip;

				pageSizeTextField = new GUIStyle(EditorStyles.miniTextField);
				pageSizeTextField.alignment = TextAnchor.MiddleLeft;
				pageSizeTextField.clipping = TextClipping.Clip;
//				pageSizeTextField.fixedHeight = 0;
				pageSizeTextField.padding = new RectOffset(3, 0, 0, 0);
//				pageSizeTextField.overflow = new RectOffset(0, 0, -2, -3);
//				pageSizeTextField.contentOffset = new Vector2(0, -1);
				pageSizeTextField.font = EditorStyles.miniFont;
				pageSizeTextField.fontSize = EditorStyles.miniTextField.fontSize;
				pageSizeTextField.fontStyle = FontStyle.Normal;
				pageSizeTextField.wordWrap = false;
				pageSizeTextField.normal.textColor = EditorStyles.miniTextField.normal.textColor;


				draggingHandle = new GUIStyle("RL DragHandle");
				headerBackground = new GUIStyle("RL Header");
				footerBackground = new GUIStyle("RL Footer");
				paginationHeader = new GUIStyle("RL Header");
				paginationHeader.border = new RectOffset(2, 3, 2, 3);
				elementBackground = new GUIStyle("RL Element");
				elementBackground.border = new RectOffset(2, 3, 2, 3);
				verticalLabel = new GUIStyle(EditorStyles.label);
				verticalLabel.alignment = TextAnchor.UpperLeft;
				verticalLabel.contentOffset = new Vector2(10, 3);
				boxBackground = new GUIStyle("RL Background");
				boxBackground.border = new RectOffset(6, 3, 3, 6);
				preButton = new GUIStyle("RL FooterButton");

				expandButton = EditorGUIUtility.IconContent("align_vertically_center_active");
				expandButton.tooltip = "Expand All Elements";

				collapseButton = EditorGUIUtility.IconContent("winbtn_win_min");
				collapseButton.tooltip = "Collapse All Elements";

				sortAscending = EditorGUIUtility.IconContent("align_vertically_bottom");
				sortAscending.tooltip = "Sort Ascending";

				sortDescending = EditorGUIUtility.IconContent("align_vertically_top");
				sortDescending.tooltip = "Sort Descending";

				listIcon = EditorGUIUtility.IconContent("align_horizontally_right");
			}
		}

		//
		// -- DRAG LIST --
		//

		struct DragList {

			private int startIndex;
			private DragElement[] elements;
			private int length;

			internal DragList(int length) {

				this.length = length;

				startIndex = 0;
				elements = new DragElement[length];
			}

			internal int StartIndex {

				get { return startIndex; }
			}

			internal int Length {

				get { return length; }
			}

			internal DragElement[] Elements {

				get { return elements; }
				set { elements = value; }
			}

			internal DragElement this[int index] {

				get { return elements[index]; }
				set { elements[index] = value; }
			}

			internal void Resize(int start, int length) {

				startIndex = start;

				this.length = length;

				if (elements.Length != length) {

					System.Array.Resize(ref elements, length);
				}
			}

			internal void SortByIndex() {

				System.Array.Sort(elements, (a, b) => {

					if (b.selected) {

						return a.selected ? a.startIndex.CompareTo(b.startIndex) : 1;
					}
					else if (a.selected) {

						return b.selected ? b.startIndex.CompareTo(a.startIndex) : -1;
					}

					return a.startIndex.CompareTo(b.startIndex);
				});
			}

			internal void RecordState() {

				for (int i = 0; i < length; i++) {

					elements[i].RecordState();
				}
			}

			internal void RestoreState(SerializedProperty list) {

				for (int i = 0; i < length; i++) {

					elements[i].RestoreState(list.GetArrayElementAtIndex(i + startIndex));
				}
			}

			internal void SortByPosition() {

				System.Array.Sort(elements, (a, b) => a.desiredRect.center.y.CompareTo(b.desiredRect.center.y));
			}

			internal int GetIndexFromSelection(int index) {

				return System.Array.FindIndex(elements, t => t.startIndex == index);
			}
		}

		//
		// -- DRAG ELEMENT --
		//

		struct DragElement {

			internal SerializedProperty property;
			internal int startIndex;
			internal float dragOffset;
			internal bool selected;
			internal Rect rect;
			internal Rect desiredRect;

			private bool isExpanded;
			private Dictionary<int, bool> states;

			internal bool Overlaps(Rect value, int index, int direction) {

				if (direction < 0 && index < startIndex) {

					return desiredRect.yMin < value.center.y;
				}
				else if (direction > 0 && index > startIndex) {

					return desiredRect.yMax > value.center.y;
				}

				return false;
			}

			internal void RecordState() {

				states = new Dictionary<int, bool>();
				isExpanded = property.isExpanded;

				Iterate(this, property, (DragElement e, SerializedProperty p, int index) => {

					e.states[index] = p.isExpanded;
				});
			}

			internal void RestoreState(SerializedProperty property) {

				property.isExpanded = isExpanded;

				Iterate(this, property, (DragElement e, SerializedProperty p, int index) => {

					p.isExpanded = e.states[index];
				});
			}

			private static void Iterate(DragElement element, SerializedProperty property, System.Action<DragElement, SerializedProperty, int> action) {

				SerializedProperty copy = property.Copy();
				SerializedProperty end = copy.GetEndProperty();

				int index = 0;

				while (copy.NextVisible(true) && !SerializedProperty.EqualContents(copy, end)) {

					if (copy.hasVisibleChildren) {

						action(element, copy, index);
						index++;
					}
				}
			}
		}

		//
		// -- SLIDE GROUP --
		//

		class SlideGroup {

			private Dictionary<int, Rect> animIDs;

			public SlideGroup() {

				animIDs = new Dictionary<int, Rect>();
			}

			public Rect GetRect(int id, Rect r, float easing) {

				if (Event.current.type != EventType.Repaint) {

					return r;
				}

				if (!animIDs.ContainsKey(id)) {

					animIDs.Add(id, r);
					return r;
				}
				else {

					Rect rect = animIDs[id];

					if (rect.y != r.y) {

						float delta = r.y - rect.y;
						float absDelta = Mathf.Abs(delta);

						//if the distance between current rect and target is too large, then move the element towards the target rect so it reaches the destination faster

						if (absDelta > (rect.height * 2)) {

							r.y = delta > 0 ? r.y - rect.height : r.y + rect.height;
						}
						else if (absDelta > 0.5) {

							r.y = Mathf.Lerp(rect.y, r.y, easing);
						}

						animIDs[id] = r;
						HandleUtility.Repaint();
					}

					return r;
				}
			}

			public Rect SetRect(int id, Rect rect) {

				if (animIDs.ContainsKey(id)) {

					animIDs[id] = rect;
				}
				else {

					animIDs.Add(id, rect);
				}

				return rect;
			}
		}

		//
		// -- PAGINATION --
		//

		struct Pagination {

			internal bool enabled;
			internal int pageSize;
			internal int page;

			internal bool usePagination {
				get { return enabled && pageSize > 0; }
			}

			internal int GetVisibleLength(int total) {

				int start, end;

				if (GetVisibleRange(total, out start, out end)) {

					return end - start;
				}

				return total;
			}

			internal int GetPageForIndex(int index) {

				return usePagination ? Mathf.FloorToInt(index / (float) pageSize) : 0;
			}

			internal int GetPageCount(int total) {

				return usePagination ? Mathf.CeilToInt(total / (float) pageSize) : 1;
			}

			internal bool GetVisibleRange(int total, out int start, out int end) {

				if (usePagination) {

					int size = pageSize;

					start = Mathf.Clamp(page * size, 0, total - 1);
					end = Mathf.Min(start + size, total);
					return true;
				}

				start = 0;
				end = total;
				return false;
			}
		}

		//
		// -- SELECTION --
		//

		class ListSelection : IEnumerable<int> {

			private List<int> indexes;

			internal int? firstSelected;

			public ListSelection() {

				indexes = new List<int>();
			}

			public ListSelection(int[] indexes) {

				this.indexes = new List<int>(indexes);
			}

			public int First {

				get { return indexes.Count > 0 ? indexes[0] : -1; }
			}

			public int Last {

				get { return indexes.Count > 0 ? indexes[indexes.Count - 1] : -1; }
			}

			public int Length {

				get { return indexes.Count; }
			}

			public int this[int index] {

				get { return indexes[index]; }
				set {

					int oldIndex = indexes[index];

					indexes[index] = value;

					if (oldIndex == firstSelected) {

						firstSelected = value;
					}
				}
			}

			public bool Contains(int index) {

				return indexes.Contains(index);
			}

			public void Clear() {

				indexes.Clear();
				firstSelected = null;
			}

			public void SelectWhenNoAction(int index, Event evt) {

				if (!EditorGUI.actionKey && !evt.shift) {

					Select(index);
				}
			}

			public void Select(int index) {

				indexes.Clear();
				indexes.Add(index);

				firstSelected = index;
			}

			public void Remove(int index) {

				if (indexes.Contains(index)) {

					indexes.Remove(index);
				}
			}

			public void AppendWithAction(int index, Event evt) {

				if (EditorGUI.actionKey) {

					if (Contains(index)) {

						Remove(index);
					}
					else {

						Append(index);
						firstSelected = index;
					}
				}
				else if (evt.shift && indexes.Count > 0 && firstSelected.HasValue) {

					indexes.Clear();

					AppendRange(firstSelected.Value, index);
				}
				else if (!Contains(index)) {

					Select(index);
				}
			}

			public void Sort() {

				if (indexes.Count > 0) {

					indexes.Sort();
				}
			}

			public void Sort(System.Comparison<int> comparison) {

				if (indexes.Count > 0) {

					indexes.Sort(comparison);
				}
			}

			public int[] ToArray() {

				return indexes.ToArray();
			}

			public ListSelection Clone() {

				ListSelection clone = new ListSelection(ToArray());
				clone.firstSelected = firstSelected;

				return clone;
			}

			internal void Trim(int min, int max) {

				int i = indexes.Count;

				while (--i > -1) {

					int index = indexes[i];

					if (index < min || index >= max) {

						if (index == firstSelected && i > 0) {

							firstSelected = indexes[i - 1];
						}

						indexes.RemoveAt(i);
					}
				}
			}

			internal bool CanRevert(SerializedProperty list) {

				if (list.serializedObject.targetObjects.Length == 1) {

					for (int i = 0; i < Length; i++) {

						if (list.GetArrayElementAtIndex(this[i]).isInstantiatedPrefab) {

							return true;
						}
					}
				}

				return false;
			}

			internal void RevertValues(object userData) {

				SerializedProperty list = userData as SerializedProperty;

				for (int i = 0; i < Length; i++) {

					SerializedProperty property = list.GetArrayElementAtIndex(this[i]);

					if (property.isInstantiatedPrefab) {

						property.prefabOverride = false;
					}
				}

				list.serializedObject.ApplyModifiedProperties();
				list.serializedObject.Update();

				HandleUtility.Repaint();
			}

			internal void Duplicate(SerializedProperty list) {

				int offset = 0;

				for (int i = 0; i < Length; i++) {

					this[i] += offset;

					list.GetArrayElementAtIndex(this[i]).DuplicateCommand();
					list.serializedObject.ApplyModifiedProperties();
					list.serializedObject.Update();

					offset++;
				}
			}

			internal void Delete(SerializedProperty list) {

				Sort();

				int i = Length;

				while (--i > -1) {

					list.GetArrayElementAtIndex(this[i]).DeleteCommand();
				}

				Clear();

				list.serializedObject.ApplyModifiedProperties();
				list.serializedObject.Update();
			}

			private void Append(int index) {

				if (index >= 0 && !indexes.Contains(index)) {

					indexes.Add(index);
				}
			}

			private void AppendRange(int from, int to) {

				int dir = (int)Mathf.Sign(to - from);

				if (dir != 0) {

					for (int i = from; i != to; i += dir) {

						Append(i);
					}
				}

				Append(to);
			}

			public IEnumerator<int> GetEnumerator() {

				return ((IEnumerable<int>)indexes).GetEnumerator();
			}

			IEnumerator IEnumerable.GetEnumerator() {

				return ((IEnumerable<int>)indexes).GetEnumerator();
			}
		}

		//
		// -- SORTING --
		//

		static class ListSort {

			private delegate int SortComparision(SerializedProperty p1, SerializedProperty p2);

			internal static void SortOnProperty(SerializedProperty list, int length, bool descending, string propertyName) {

				BubbleSort(list, length, (p1, p2) => {

					SerializedProperty a = p1.FindPropertyRelative(propertyName);
					SerializedProperty b = p2.FindPropertyRelative(propertyName);

					if (a != null && b != null && a.propertyType == b.propertyType) {

						int comparison = Compare(a, b, descending, a.propertyType);

						return descending ? -comparison : comparison;
					}

					return 0;
				});
			}

			internal static void SortOnType(SerializedProperty list, int length, bool descending, SerializedPropertyType type) {

				BubbleSort(list, length, (p1, p2) => {

					int comparision = Compare(p1, p2, descending, type);

					return descending ? -comparision : comparision;
				});
			}

			//
			// -- PRIVATE --
			//

			private static void BubbleSort(SerializedProperty list, int length, SortComparision comparision) {

				for (int i = 0; i < length; i++) {

					SerializedProperty p1 = list.GetArrayElementAtIndex(i);

					for (int j = i + 1; j < length; j++) {

						SerializedProperty p2 = list.GetArrayElementAtIndex(j);

						if (comparision(p1, p2) > 0) {

							list.MoveArrayElement(j, i);
						}
					}
				}
			}

			private static int Compare(SerializedProperty p1, SerializedProperty p2, bool descending, SerializedPropertyType type) {

				if (p1 == null || p2 == null) {

					return 0;
				}

				switch (type) {

					case SerializedPropertyType.Boolean:

						return p1.boolValue.CompareTo(p2.boolValue);

					case SerializedPropertyType.Character:
					case SerializedPropertyType.Enum:
					case SerializedPropertyType.Integer:
					case SerializedPropertyType.LayerMask:

						return p1.longValue.CompareTo(p2.longValue);

					case SerializedPropertyType.Color:

						return p1.colorValue.grayscale.CompareTo(p2.colorValue.grayscale);

					case SerializedPropertyType.ExposedReference:

						return CompareObjects(p1.exposedReferenceValue, p2.exposedReferenceValue, descending);

					case SerializedPropertyType.Float:

						return p1.doubleValue.CompareTo(p2.doubleValue);

					case SerializedPropertyType.ObjectReference:

						return CompareObjects(p1.objectReferenceValue, p2.objectReferenceValue, descending);

					case SerializedPropertyType.String:

						return p1.stringValue.CompareTo(p2.stringValue);

					default:

						return 0;
				}
			}

			private static int CompareObjects(Object obj1, Object obj2, bool descending) {

				if (obj1 && obj2) {

					return obj1.name.CompareTo(obj2.name);
				}
				else if (obj1) {

					return descending ? 1 : -1;
				}

				return descending ? -1 : 1;
			}
		}

		//
		// -- SURROGATE --
		//

		public struct Surrogate {

			public System.Type type;
			public bool exactType;
			public SurrogateCallback callback;

			internal bool enabled;

			public bool HasType {

				get { return enabled && type != null; }
			}

			public Surrogate(System.Type type)
				: this(type, null) {
			}

			public Surrogate(System.Type type, SurrogateCallback callback) {

				this.type = type;
				this.callback = callback;

				enabled = true;
				exactType = false;
			}

			public void Invoke(SerializedProperty element, Object objectReference, ReorderableList list) {

				if (element != null && callback != null) {

					callback.Invoke(element, objectReference, list);
				}
			}
		}

		//
		// -- EXCEPTIONS --
		//

		class InvalidListException : System.InvalidOperationException {

			public InvalidListException() : base("ReorderableList serializedProperty must be an array") {
			}
		}

		class MissingListExeption : System.ArgumentNullException {

			public MissingListExeption() : base("ReorderableList serializedProperty is null") {
			}
		}

		//
		// -- INTERNAL --
		//

		static class Internals {

			private static MethodInfo dragDropValidation;
			private static object[] dragDropValidationParams;
			private static MethodInfo appendDragDrop;
			private static object[] appendDragDropParams;

			static Internals() {

				dragDropValidation = System.Type.GetType("UnityEditor.EditorGUI, UnityEditor").GetMethod("ValidateObjectFieldAssignment", BindingFlags.NonPublic | BindingFlags.Static);
				appendDragDrop = typeof(SerializedProperty).GetMethod("AppendFoldoutPPtrValue", BindingFlags.NonPublic | BindingFlags.Instance);
			}

			internal static Object ValidateObjectDragAndDrop(Object[] references, SerializedProperty property, System.Type type, bool exactType) {

				dragDropValidationParams = GetParams(ref dragDropValidationParams, 4);
				dragDropValidationParams[0] = references;
				dragDropValidationParams[1] = type;
				dragDropValidationParams[2] = property;
				dragDropValidationParams[3] = exactType ? 1 : 0;

				return dragDropValidation.Invoke(null, dragDropValidationParams) as Object;
			}

			internal static void AppendDragAndDropValue(Object obj, SerializedProperty list) {

				appendDragDropParams = GetParams(ref appendDragDropParams, 1);
				appendDragDropParams[0] = obj;
				appendDragDrop.Invoke(list, appendDragDropParams);
			}

			private static object[] GetParams(ref object[] parameters, int count) {

				if (parameters == null) {

					parameters = new object[count];
				}

				return parameters;
			}
		}
	}
}