using UnityEngine;
using UnityEngine.UI;
using System.Collections;
using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.Linq;
#if UNITY_EDITOR
using UnityEditor;
#endif

namespace MoreMountains.Tools
{	
	/// <summary>
	/// Debug helpers
	/// </summary>
	public static class MMDebug 
	{
        #region Commands

        // the cached list of debug log commands
        private static MethodInfo[] _commands;
        // the max length of the log
        private static readonly int _logHistoryMaxLength = 256;

#if UNITY_EDITOR
        private static bool _debugDrawEnabledSet = false;
#endif
        private static bool _debugDrawEnabled = false;
        private static bool _debugLogEnabled = false;
        private static bool _debugLogEnabledSet = false;

        /// <summary>
        /// Returns a list of all the debug command lines found in the project's assemblies
        /// </summary>
        public static MethodInfo[] Commands
        {
            get
            {
                if (_commands == null)
                {
                    _commands = AppDomain.CurrentDomain.GetAssemblies()
                      .SelectMany(
                                m => m.GetTypes().SelectMany(
                                    n => n.GetMethods(BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public)
                                        .Where(o => o.GetCustomAttribute<MMDebugLogCommandAttribute>() != null))).ToArray();
                }

                return _commands;
            }
        }

        /// <summary>
        /// Tries to input a command
        /// </summary>
        /// <param name="command"></param>
        public static void DebugLogCommand(string command)
        {
            // if the command is empty we output an empty line
            if (command == string.Empty || command == null)
            {
                LogCommand("", "#ff2a00");
                return; 
            }

            // we split around spaces
            string[] splitCommand = command.Split(new char[] { ' ' }, System.StringSplitOptions.RemoveEmptyEntries);
            if (splitCommand == null || splitCommand.Length == 0)
            {
                LogCommand("Empty command", "#ff2a00");
                return;
            }
            
            // we check if the first command exists
            string commandFirst = MMString.UppercaseFirst(splitCommand[0]);
            MethodInfo[] methods = Commands.Where(m => m.Name == commandFirst).ToArray();
            if (methods.Length == 0)
            {
                LogCommand("Command " + commandFirst + " not found.", "#ff2a00");
                return;
            }

            MethodInfo commandInfo;
            object[] parameters = null;

            if (splitCommand.Length > 1)
            { 
                // if there are arguments
                commandInfo = methods.Where(m => m.GetParameters().Length > 0).FirstOrDefault();

                if (commandInfo == null)
                {
                    LogCommand("A version of command " + commandFirst + " with arguments could not be found. Maybe try without arguments.", "#ff2a00");
                    return;
                }

                MMDebugLogCommandArgumentCountAttribute argumentAttribute = commandInfo.GetCustomAttributes<MMDebugLogCommandArgumentCountAttribute>(true).FirstOrDefault();
                if (argumentAttribute != null && argumentAttribute.ArgumentCount > splitCommand.Length - 1)
                { 
                    LogCommand("A version of command " + commandFirst + " needs at least " + argumentAttribute.ArgumentCount + " arguments.", "#ff2a00");
                    return;
                }

                parameters = new object[] { splitCommand };
            }
            else
            { 
                // if there are no arguments 
                commandInfo = methods.Where(m => m.GetParameters().Length == 0).FirstOrDefault();

                if (commandInfo == null)
                {
                    LogCommand("A version of command " + commandFirst + " without arguments could not be found.", "#ff2a00");
                    return;
                }
            }

            LogCommand(command, "#FFC400");
            methods[0].Invoke(null, parameters);
        }

        /// <summary>
        /// Logs the command, adding it to the log history and triggers an event
        /// </summary>
        /// <param name="command"></param>
        /// <param name="color"></param>
        private static void LogCommand(string command, string color)
        {
            DebugLogItem item = new DebugLogItem(command, color, Time.frameCount, Time.time, 3, true);
            LogHistory.Add(item);
            MMDebugLogEvent.Trigger(new DebugLogItem(null, "", Time.frameCount, Time.time, 0, false));
        }

        #endregion

        #region DebugLog

        /// <summary>
        /// A struct used to store log items
        /// </summary>
        public struct DebugLogItem
        {
            public object Message;
            public string Color;
            public int Framecount;
            public float Time;
            public int TimePrecision;
            public bool DisplayFrameCount;

            public DebugLogItem(object message, string color, int framecount, float time, int timePrecision, bool displayFrameCount)
            {
                Message = message;
                Color = color;
                Framecount = framecount;
                Time = time;
                TimePrecision = timePrecision;
                DisplayFrameCount = displayFrameCount;
            }
        }

        /// <summary>
        /// A list of all the debug logs (up to DebugLogMaxLength entries)
        /// </summary>
        public static List<DebugLogItem> LogHistory = new List<DebugLogItem>(_logHistoryMaxLength);

        /// <summary>
        /// Returns a string with all log history condensed
        /// </summary>
        public static string LogHistoryText
        {
            get
            {
                string colorPrefix = "";
                string colorSuffix = "";

                StringBuilder log = new StringBuilder();
                for (int i = 0; i < LogHistory.Count; i++)
                {
                    // colors
                    if (!string.IsNullOrEmpty(LogHistory[i].Color))
                    {
                        colorPrefix = "<color=" + LogHistory[i].Color + ">";
                        colorSuffix = "</color>";
                    }

                    // build output
                    if (LogHistory[i].DisplayFrameCount)
                    {
                        log.Append("<color=#82d3f9>[" + LogHistory[i].Framecount + "]</color> ");
                    }
                    log.Append("<color=#f9a682>[" + MMTime.FloatToTimeString(LogHistory[i].Time, false, true, true, true) + "]</color> ");
                    log.Append(colorPrefix + LogHistory[i].Message + colorSuffix);
                    log.Append(Environment.NewLine);
                }
                return log.ToString();
            }
        }

        /// <summary>
        /// Clears the debug log
        /// </summary>
        public static void DebugLogClear()
        {
            LogHistory.Clear();
            MMDebugLogEvent.Trigger(new DebugLogItem(null, "", Time.frameCount, Time.time, 0, false));
        }

        /// <summary>
        /// Outputs the message object to the console, prefixed with the current timestamp
        /// </summary>
        /// <param name="message">Message.</param>
        public static void DebugLogTime(object message, string color = "", int timePrecision = 3, bool displayFrameCount = true)
        {
            if (!DebugLogsEnabled)
            {
                return;
            }

            // colors
            string colorPrefix = "";
            string colorSuffix = "";
            if (!string.IsNullOrEmpty(color))
            {
                colorPrefix = "<color=" + color + ">";
                colorSuffix = "</color>";
            }

            // build output
            string output = "";
            if (displayFrameCount)
            {
                output += "<color=#82d3f9>[" + Time.frameCount + "]</color> ";
            }
            output += "<color=#f9a682>[" + MMTime.FloatToTimeString(Time.time, false, true, true, true) + "]</color> ";
            output += colorPrefix + message + colorSuffix;

            // we output to the console
            Debug.Log(output);

            DebugLogItem item = new DebugLogItem(message, color, Time.frameCount, Time.time, timePrecision, displayFrameCount);

            // we add to our DebugLog 
            if (LogHistory.Count > _logHistoryMaxLength)
            {
                LogHistory.RemoveAt(0);
            }

            LogHistory.Add(item);

            // we trigger an event
            MMDebugLogEvent.Trigger(item);

        }

        /// <summary>
        /// An event used to broadcast debug logs
        /// </summary>
        public struct MMDebugLogEvent
        {
            public delegate void Delegate(DebugLogItem item);
            static private event Delegate OnEvent;

            static public void Register(Delegate callback)
            {
                OnEvent += callback;
            }

            static public void Unregister(Delegate callback)
            {
                OnEvent -= callback;
            }

            static public void Trigger(DebugLogItem item)
            {
                OnEvent?.Invoke(item);
            }
        }

        #endregion

        #region EnableDisableDebugs

        /// <summary>
        /// whether or not debug logs (MMDebug.DebugLogTime, MMDebug.DebugOnScreen) should be displayed
        /// </summary>
        public static bool DebugLogsEnabled
        {
            get
            {
                if (_debugLogEnabledSet)
                {
                    return _debugLogEnabled;
                }
                
                if (PlayerPrefs.HasKey(_editorPrefsDebugLogs))
                {
                    _debugLogEnabled = (PlayerPrefs.GetInt(_editorPrefsDebugLogs) == 0) ? false : true;
                }
                else
                {
                    _debugLogEnabled = true;
                }

                _debugLogEnabledSet = true;
                return _debugLogEnabled;
            }
            private set { }
        }

        /// <summary>
        /// whether or not debug draws should be executed
        /// </summary>
        public static bool DebugDrawEnabled
        {
            get
            {
                #if UNITY_EDITOR
                    if (_debugDrawEnabledSet)
                    {
                        return _debugDrawEnabled;
                    }

                    if (PlayerPrefs.HasKey(_editorPrefsDebugDraws))
                    {
                        _debugDrawEnabled = (PlayerPrefs.GetInt(_editorPrefsDebugDraws) == 0) ? false : true;
                    }
                    else
                    {
                        _debugDrawEnabled = true;
                    }
                    _debugDrawEnabledSet = true;
                    return _debugDrawEnabled;
                #else
                    return false;
                #endif
            }
            private set { }
        }

        private const string _editorPrefsDebugLogs = "DebugLogsEnabled";
        private const string _editorPrefsDebugDraws = "DebugDrawsEnabled";

        /// <summary>
        /// Enables or disables debug logs 
        /// </summary>
        /// <param name="status"></param>
        public static void SetDebugLogsEnabled(bool status)
        {
            DebugLogsEnabled = status;
            _debugLogEnabled = status;
            #if UNITY_EDITOR
            int newStatus = status ? 1 : 0;
                PlayerPrefs.SetInt(_editorPrefsDebugLogs, newStatus);
            #endif
        }

        /// <summary>
        /// Enables or disables debug draws
        /// </summary>
        /// <param name="status"></param>
        public static void SetDebugDrawEnabled(bool status)
        {
            DebugDrawEnabled = status;
            _debugDrawEnabled = status;
            #if UNITY_EDITOR
                int newStatus = status ? 1 : 0;
                PlayerPrefs.SetInt(_editorPrefsDebugDraws, newStatus);
            #endif
        }

        #endregion

        #region Casts

        /// <summary>
        /// Draws a debug ray in 2D and does the actual raycast
        /// </summary>
        /// <returns>The raycast hit.</returns>
        /// <param name="rayOriginPoint">Ray origin point.</param>
        /// <param name="rayDirection">Ray direction.</param>
        /// <param name="rayDistance">Ray distance.</param>
        /// <param name="mask">Mask.</param>
        /// <param name="debug">If set to <c>true</c> debug.</param>
        /// <param name="color">Color.</param>
        public static RaycastHit2D RayCast(Vector2 rayOriginPoint, Vector2 rayDirection, float rayDistance, LayerMask mask, Color color,bool drawGizmo=false)
		{	
			if (drawGizmo && DebugDrawEnabled) 
			{
				Debug.DrawRay (rayOriginPoint, rayDirection * rayDistance, color);
			}
			return Physics2D.Raycast(rayOriginPoint,rayDirection,rayDistance,mask);		
		}

        /// <summary>
        /// Does a boxcast and draws a box gizmo
        /// </summary>
        /// <param name="origin"></param>
        /// <param name="size"></param>
        /// <param name="angle"></param>
        /// <param name="direction"></param>
        /// <param name="length"></param>
        /// <param name="mask"></param>
        /// <param name="color"></param>
        /// <param name="drawGizmo"></param>
        /// <returns></returns>
        public static RaycastHit2D BoxCast(Vector2 origin, Vector2 size, float angle, Vector2 direction, float length, LayerMask mask, Color color, bool drawGizmo = false)
        {
            if (drawGizmo && DebugDrawEnabled)
            {
                Quaternion rotation = Quaternion.Euler(0f, 0f, angle);

                Vector3[] points = new Vector3[8];

                float halfSizeX = size.x / 2f;
                float halfSizeY = size.y / 2f;

                points[0] = rotation * (origin + (Vector2.left * halfSizeX) + (Vector2.up * halfSizeY)); // top left
                points[1] = rotation * (origin + (Vector2.right * halfSizeX) + (Vector2.up * halfSizeY)); // top right
                points[2] = rotation * (origin + (Vector2.right * halfSizeX) - (Vector2.up * halfSizeY)); // bottom right
                points[3] = rotation * (origin + (Vector2.left * halfSizeX) - (Vector2.up * halfSizeY)); // bottom left
                
                points[4] = rotation * ((origin + Vector2.left * halfSizeX + Vector2.up * halfSizeY) + length * direction); // top left
                points[5] = rotation * ((origin + Vector2.right * halfSizeX + Vector2.up * halfSizeY) + length * direction); // top right
                points[6] = rotation * ((origin + Vector2.right * halfSizeX - Vector2.up * halfSizeY) + length * direction); // bottom right
                points[7] = rotation * ((origin + Vector2.left * halfSizeX - Vector2.up * halfSizeY) + length * direction); // bottom left
                                
                Debug.DrawLine(points[0], points[1], color);
                Debug.DrawLine(points[1], points[2], color);
                Debug.DrawLine(points[2], points[3], color);
                Debug.DrawLine(points[3], points[0], color);

                Debug.DrawLine(points[4], points[5], color);
                Debug.DrawLine(points[5], points[6], color);
                Debug.DrawLine(points[6], points[7], color);
                Debug.DrawLine(points[7], points[4], color);
                
                Debug.DrawLine(points[0], points[4], color);
                Debug.DrawLine(points[1], points[5], color);
                Debug.DrawLine(points[2], points[6], color);
                Debug.DrawLine(points[3], points[7], color);

            }
            return Physics2D.BoxCast(origin, size, angle, direction, length, mask);
        }

        /// <summary>
        /// Draws a debug ray without allocating memory
        /// </summary>
        /// <returns>The ray cast non alloc.</returns>
        /// <param name="array">Array.</param>
        /// <param name="rayOriginPoint">Ray origin point.</param>
        /// <param name="rayDirection">Ray direction.</param>
        /// <param name="rayDistance">Ray distance.</param>
        /// <param name="mask">Mask.</param>
        /// <param name="color">Color.</param>
        /// <param name="drawGizmo">If set to <c>true</c> draw gizmo.</param>
        public static RaycastHit2D MonoRayCastNonAlloc(RaycastHit2D[] array, Vector2 rayOriginPoint, Vector2 rayDirection, float rayDistance, LayerMask mask, Color color,bool drawGizmo=false)
		{	
			if (drawGizmo && DebugDrawEnabled) 
			{
				Debug.DrawRay (rayOriginPoint, rayDirection * rayDistance, color);
			}
			if (Physics2D.RaycastNonAlloc(rayOriginPoint, rayDirection, array, rayDistance, mask) > 0)
			{
				return array[0];
			}
			return new RaycastHit2D();        	
		}

		/// <summary>
		/// Draws a debug ray in 3D and does the actual raycast
		/// </summary>
		/// <returns>The raycast hit.</returns>
		/// <param name="rayOriginPoint">Ray origin point.</param>
		/// <param name="rayDirection">Ray direction.</param>
		/// <param name="rayDistance">Ray distance.</param>
		/// <param name="mask">Mask.</param>
		/// <param name="debug">If set to <c>true</c> debug.</param>
		/// <param name="color">Color.</param>
		/// <param name="drawGizmo">If set to <c>true</c> draw gizmo.</param>
		public static RaycastHit Raycast3D(Vector3 rayOriginPoint, Vector3 rayDirection, float rayDistance, LayerMask mask, Color color,bool drawGizmo=false)
		{
			if (drawGizmo && DebugDrawEnabled) 
			{
				Debug.DrawRay (rayOriginPoint, rayDirection * rayDistance, color);
			}
			RaycastHit hit;
			Physics.Raycast(rayOriginPoint, rayDirection, out hit, rayDistance, mask);	
			return hit;
		}

        #endregion

        #region DebugOnScreen
        
        //public static MMConsole _console;
        public static MMDebugOnScreenConsole _console;
        private const string _debugConsolePrefabPath = "MMDebugOnScreenConsole";
                
        /// <summary>
        /// Instantiates a MMConsole if there isn't one already, and adds the message in parameter to it.
        /// </summary>
        /// <param name="message">Message.</param>
        public static void DebugOnScreen(string message)
        {
            if (!DebugLogsEnabled)
            {
                return;
            }

            InstantiateOnScreenConsole();
			_console.AddMessage(message, "", 30);
		}

		/// <summary>
		/// Instantiates a MMConsole if there isn't one already, and displays the label in bold and its value next to it.
		/// </summary>
		/// <param name="label">Label.</param>
		/// <param name="value">Value.</param>
		/// <param name="fontSize">The optional font size.</param>
		public static void DebugOnScreen(string label, object value, int fontSize=25)
        {
            if (!DebugLogsEnabled)
            {
                return;
            }

            InstantiateOnScreenConsole(fontSize);
			_console.AddMessage(label, value, fontSize);
		}

		/// <summary>
		/// Instantiates the on screen console if there isn't one already
		/// </summary>
		public static void InstantiateOnScreenConsole(int fontSize=25)
		{
            if (!DebugLogsEnabled)
            {
                return;
            }

            if (_console == null)
            {
	            // we try to find one in the scene
	            _console = (MMDebugOnScreenConsole) GameObject.FindObjectOfType(typeof(MMDebugOnScreenConsole));
            }


            if (_console == null)
			{	
                // we instantiate the console
                GameObject loaded = UnityEngine.Object.Instantiate(Resources.Load(_debugConsolePrefabPath) as GameObject);
                loaded.name = "MMDebugOnScreenConsole";
                _console = loaded.GetComponent<MMDebugOnScreenConsole>();                
            }
		}

		/// <summary>
		/// Use this method to specify what console to use
		/// </summary>
		/// <param name="newConsole"></param>
		public static void SetOnScreenConsole(MMDebugOnScreenConsole newConsole)
		{
			_console = newConsole;
		}

        #endregion

        #region DebugDraw

        /// <summary>
        /// Draws a gizmo arrow going from the origin position and along the direction Vector3
        /// </summary>
        /// <param name="origin">Origin.</param>
        /// <param name="direction">Direction.</param>
        /// <param name="color">Color.</param>
        public static void DrawGizmoArrow(Vector3 origin, Vector3 direction, Color color, float arrowHeadLength = 3f, float arrowHeadAngle = 25f)
	    {
            if (!DebugDrawEnabled)
            {
                return;
            }

	        Gizmos.color = color;
	        Gizmos.DrawRay(origin, direction);
	       
			DrawArrowEnd(true, origin, direction, color, arrowHeadLength, arrowHeadAngle);
	    }

	    /// <summary>
		/// Draws a debug arrow going from the origin position and along the direction Vector3
	    /// </summary>
	    /// <param name="origin">Origin.</param>
	    /// <param name="direction">Direction.</param>
	    /// <param name="color">Color.</param>
	    public static void DebugDrawArrow(Vector3 origin, Vector3 direction, Color color, float arrowHeadLength = 0.2f, float arrowHeadAngle = 35f)
        {
            if (!DebugDrawEnabled)
            {
                return;
            }

            Debug.DrawRay(origin, direction, color);
	       
			DrawArrowEnd(false,origin,direction,color,arrowHeadLength,arrowHeadAngle);
	    }

		/// <summary>
		/// Draws a debug arrow going from the origin position and along the direction Vector3
		/// </summary>
		/// <param name="origin">Origin.</param>
		/// <param name="direction">Direction.</param>
		/// <param name="color">Color.</param>
		/// <param name="arrowLength">Arrow length.</param>
		/// <param name="arrowHeadLength">Arrow head length.</param>
		/// <param name="arrowHeadAngle">Arrow head angle.</param>
		public static void DebugDrawArrow(Vector3 origin, Vector3 direction, Color color, float arrowLength, float arrowHeadLength = 0.20f, float arrowHeadAngle = 35.0f)
        {
            if (!DebugDrawEnabled)
            {
                return;
            }

            Debug.DrawRay(origin, direction * arrowLength, color);

			DrawArrowEnd(false,origin,direction * arrowLength,color,arrowHeadLength,arrowHeadAngle);
		}

		/// <summary>
		/// Draws a debug cross of the specified size and color at the specified point
		/// </summary>
		/// <param name="spot">Spot.</param>
		/// <param name="crossSize">Cross size.</param>
		/// <param name="color">Color.</param>
		public static void DebugDrawCross (Vector3 spot, float crossSize, Color color)
        {
            if (!DebugDrawEnabled)
            {
                return;
            }

            Vector3 tempOrigin = Vector3.zero;
			Vector3 tempDirection = Vector3.zero;

			tempOrigin.x = spot.x - crossSize / 2;
			tempOrigin.y = spot.y - crossSize / 2;
            tempOrigin.z = spot.z ;
            tempDirection.x = 1; 
			tempDirection.y = 1;
            tempDirection.z = 0;
            Debug.DrawRay (tempOrigin, tempDirection * crossSize, color);

			tempOrigin.x = spot.x - crossSize / 2;
            tempOrigin.y = spot.y + crossSize / 2;
            tempOrigin.z = spot.z ;
            tempDirection.x = 1; 
			tempDirection.y = -1;
            tempDirection.z = 0;
            Debug.DrawRay (tempOrigin, tempDirection * crossSize, color);
		}

		/// <summary>
		/// Draws the arrow end for DebugDrawArrow
		/// </summary>
		/// <param name="drawGizmos">If set to <c>true</c> draw gizmos.</param>
		/// <param name="arrowEndPosition">Arrow end position.</param>
		/// <param name="direction">Direction.</param>
		/// <param name="color">Color.</param>
		/// <param name="arrowHeadLength">Arrow head length.</param>
		/// <param name="arrowHeadAngle">Arrow head angle.</param>
		private static void DrawArrowEnd (bool drawGizmos, Vector3 arrowEndPosition, Vector3 direction, Color color, float arrowHeadLength = 0.25f, float arrowHeadAngle = 40.0f)
        {
            if (!DebugDrawEnabled)
            {
                return;
            }

            if (direction == Vector3.zero)
			{
				return;
			}
	        Vector3 right = Quaternion.LookRotation (direction) * Quaternion.Euler (arrowHeadAngle, 0, 0) * Vector3.back;
	        Vector3 left = Quaternion.LookRotation (direction) * Quaternion.Euler (-arrowHeadAngle, 0, 0) * Vector3.back;
	        Vector3 up = Quaternion.LookRotation (direction) * Quaternion.Euler (0, arrowHeadAngle, 0) * Vector3.back;
	        Vector3 down = Quaternion.LookRotation (direction) * Quaternion.Euler (0, -arrowHeadAngle, 0) * Vector3.back;
	        if (drawGizmos) 
	        {
	            Gizmos.color = color;
	            Gizmos.DrawRay (arrowEndPosition + direction, right * arrowHeadLength);
	            Gizmos.DrawRay (arrowEndPosition + direction, left * arrowHeadLength);
	            Gizmos.DrawRay (arrowEndPosition + direction, up * arrowHeadLength);
	            Gizmos.DrawRay (arrowEndPosition + direction, down * arrowHeadLength);
	        }
	        else
	        {
	            Debug.DrawRay (arrowEndPosition + direction, right * arrowHeadLength, color);
	            Debug.DrawRay (arrowEndPosition + direction, left * arrowHeadLength, color);
	            Debug.DrawRay (arrowEndPosition + direction, up * arrowHeadLength, color);
	            Debug.DrawRay (arrowEndPosition + direction, down * arrowHeadLength, color);
	        }
	    }

		/// <summary>
		/// Draws handles to materialize the bounds of an object on screen.
		/// </summary>
		/// <param name="bounds">Bounds.</param>
		/// <param name="color">Color.</param>
		public static void DrawHandlesBounds(Bounds bounds, Color color)
        {
            if (!DebugDrawEnabled)
            {
                return;
            }

#if UNITY_EDITOR
            Vector3 boundsCenter = bounds.center;
		    Vector3 boundsExtents = bounds.extents;
		  
			Vector3 v3FrontTopLeft     = new Vector3(boundsCenter.x - boundsExtents.x, boundsCenter.y + boundsExtents.y, boundsCenter.z - boundsExtents.z);  // Front top left corner
			Vector3 v3FrontTopRight    = new Vector3(boundsCenter.x + boundsExtents.x, boundsCenter.y + boundsExtents.y, boundsCenter.z - boundsExtents.z);  // Front top right corner
			Vector3 v3FrontBottomLeft  = new Vector3(boundsCenter.x - boundsExtents.x, boundsCenter.y - boundsExtents.y, boundsCenter.z - boundsExtents.z);  // Front bottom left corner
			Vector3 v3FrontBottomRight = new Vector3(boundsCenter.x + boundsExtents.x, boundsCenter.y - boundsExtents.y, boundsCenter.z - boundsExtents.z);  // Front bottom right corner
			Vector3 v3BackTopLeft      = new Vector3(boundsCenter.x - boundsExtents.x, boundsCenter.y + boundsExtents.y, boundsCenter.z + boundsExtents.z);  // Back top left corner
			Vector3 v3BackTopRight     = new Vector3(boundsCenter.x + boundsExtents.x, boundsCenter.y + boundsExtents.y, boundsCenter.z + boundsExtents.z);  // Back top right corner
			Vector3 v3BackBottomLeft   = new Vector3(boundsCenter.x - boundsExtents.x, boundsCenter.y - boundsExtents.y, boundsCenter.z + boundsExtents.z);  // Back bottom left corner
			Vector3 v3BackBottomRight  = new Vector3(boundsCenter.x + boundsExtents.x, boundsCenter.y - boundsExtents.y, boundsCenter.z + boundsExtents.z);  // Back bottom right corner


			Handles.color = color;

			Handles.DrawLine (v3FrontTopLeft, v3FrontTopRight);
			Handles.DrawLine (v3FrontTopRight, v3FrontBottomRight);
			Handles.DrawLine (v3FrontBottomRight, v3FrontBottomLeft);
			Handles.DrawLine (v3FrontBottomLeft, v3FrontTopLeft);
		         
			Handles.DrawLine (v3BackTopLeft, v3BackTopRight);
			Handles.DrawLine (v3BackTopRight, v3BackBottomRight);
			Handles.DrawLine (v3BackBottomRight, v3BackBottomLeft);
			Handles.DrawLine (v3BackBottomLeft, v3BackTopLeft);
		         
			Handles.DrawLine (v3FrontTopLeft, v3BackTopLeft);
			Handles.DrawLine (v3FrontTopRight, v3BackTopRight);
			Handles.DrawLine (v3FrontBottomRight, v3BackBottomRight);
			Handles.DrawLine (v3FrontBottomLeft, v3BackBottomLeft);  
#endif
		}

        /// <summary>
        /// Draws a solid rectangle at the specified position and size, and of the specified colors
        /// </summary>
        /// <param name="position"></param>
        /// <param name="size"></param>
        /// <param name="borderColor"></param>
        /// <param name="solidColor"></param>
        public static void DrawSolidRectangle(Vector3 position, Vector3 size, Color borderColor, Color solidColor)
        {
            if (!DebugDrawEnabled)
            {
                return;
            }

#if UNITY_EDITOR

            Vector3 halfSize = size / 2f;

            Vector3[] verts = new Vector3[4];
            verts[0] = new Vector3(halfSize.x, halfSize.y, halfSize.z);
            verts[1] = new Vector3(-halfSize.x, halfSize.y, halfSize.z);
            verts[2] = new Vector3(-halfSize.x, -halfSize.y, halfSize.z);
            verts[3] = new Vector3(halfSize.x, -halfSize.y, halfSize.z);
            Handles.DrawSolidRectangleWithOutline(verts, solidColor, borderColor);
            
#endif
        }
        
        /// <summary>
        /// Draws a gizmo sphere of the specified size and color at a position
        /// </summary>
        /// <param name="position">Position.</param>
        /// <param name="size">Size.</param>
        /// <param name="color">Color.</param>
        public static void DrawGizmoPoint(Vector3 position, float size, Color color)
        {
            if (!DebugDrawEnabled)
            {
                return;
            }
            Gizmos.color = color;
			Gizmos.DrawWireSphere(position,size);
		}

		/// <summary>
		/// Draws a cube at the specified position, and of the specified color and size
		/// </summary>
		/// <param name="position">Position.</param>
		/// <param name="color">Color.</param>
		/// <param name="size">Size.</param>
		public static void DrawCube (Vector3 position, Color color, Vector3 size)
        {
            if (!DebugDrawEnabled)
            {
                return;
            }

            Vector3 halfSize = size / 2f; 

			Vector3[] points = new Vector3 []
			{
				position + new Vector3(halfSize.x,halfSize.y,halfSize.z),
				position + new Vector3(-halfSize.x,halfSize.y,halfSize.z),
				position + new Vector3(-halfSize.x,-halfSize.y,halfSize.z),
				position + new Vector3(halfSize.x,-halfSize.y,halfSize.z),			
				position + new Vector3(halfSize.x,halfSize.y,-halfSize.z),
				position + new Vector3(-halfSize.x,halfSize.y,-halfSize.z),
				position + new Vector3(-halfSize.x,-halfSize.y,-halfSize.z),
				position + new Vector3(halfSize.x,-halfSize.y,-halfSize.z),
			};

			Debug.DrawLine (points[0], points[1], color ); 
			Debug.DrawLine (points[1], points[2], color ); 
			Debug.DrawLine (points[2], points[3], color ); 
			Debug.DrawLine (points[3], points[0], color ); 
		}

        /// <summary>
        /// Draws a cube at the specified position, offset, and of the specified size
        /// </summary>
        /// <param name="transform"></param>
        /// <param name="offset"></param>
        /// <param name="cubeSize"></param>
        /// <param name="wireOnly"></param>
        public static void DrawGizmoCube(Transform transform, Vector3 offset, Vector3 cubeSize, bool wireOnly)
        {
            if (!DebugDrawEnabled)
            {
                return;
            }

            Matrix4x4 rotationMatrix = transform.localToWorldMatrix;
            Gizmos.matrix = rotationMatrix;
            if (wireOnly)
            {
                Gizmos.DrawWireCube(offset, cubeSize);
            }
            else
            {
                Gizmos.DrawCube(offset, cubeSize);
            }
        }

		/// <summary>
		/// Draws a gizmo rectangle
		/// </summary>
		/// <param name="center">Center.</param>
		/// <param name="size">Size.</param>
		/// <param name="color">Color.</param>
		public static void DrawGizmoRectangle(Vector2 center, Vector2 size, Color color)
        {
            if (!DebugDrawEnabled)
            {
                return;
            }

            Gizmos.color = color;

			Vector3 v3TopLeft = new Vector3(center.x - size.x/2, center.y + size.y/2, 0);
			Vector3 v3TopRight = new Vector3(center.x + size.x/2, center.y + size.y/2, 0);;
			Vector3 v3BottomRight = new Vector3(center.x + size.x/2, center.y - size.y/2, 0);;
			Vector3 v3BottomLeft = new Vector3(center.x - size.x/2, center.y - size.y/2, 0);;

			Gizmos.DrawLine(v3TopLeft,v3TopRight);
			Gizmos.DrawLine(v3TopRight,v3BottomRight);
			Gizmos.DrawLine(v3BottomRight,v3BottomLeft);
			Gizmos.DrawLine(v3BottomLeft,v3TopLeft);
        }

        /// <summary>
        /// Draws a gizmo rectangle
        /// </summary>
        /// <param name="center">Center.</param>
        /// <param name="size">Size.</param>
        /// <param name="color">Color.</param>
        public static void DrawGizmoRectangle(Vector2 center, Vector2 size, Matrix4x4 rotationMatrix, Color color)
        {
            if (!DebugDrawEnabled)
            {
                return;
            }

            GL.PushMatrix();

            Gizmos.color = color;

            Vector3 v3TopLeft = rotationMatrix * new Vector3(center.x - size.x / 2, center.y + size.y / 2, 0);
            Vector3 v3TopRight = rotationMatrix * new Vector3(center.x + size.x / 2, center.y + size.y / 2, 0); ;
            Vector3 v3BottomRight = rotationMatrix * new Vector3(center.x + size.x / 2, center.y - size.y / 2, 0); ;
            Vector3 v3BottomLeft = rotationMatrix * new Vector3(center.x - size.x / 2, center.y - size.y / 2, 0); ;

            
            Gizmos.DrawLine(v3TopLeft, v3TopRight);
            Gizmos.DrawLine(v3TopRight, v3BottomRight);
            Gizmos.DrawLine(v3BottomRight, v3BottomLeft);
            Gizmos.DrawLine(v3BottomLeft, v3TopLeft);
            GL.PopMatrix();
        }

        /// <summary>
        /// Draws a rectangle based on a Rect and color
        /// </summary>
        /// <param name="rectangle">Rectangle.</param>
        /// <param name="color">Color.</param>
        public static void DrawRectangle (Rect rectangle, Color color)
        {
            if (!DebugDrawEnabled)
            {
                return;
            }

            Vector3 pos = new Vector3( rectangle.x + rectangle.width/2, rectangle.y + rectangle.height/2, 0.0f );
			Vector3 scale = new Vector3 (rectangle.width, rectangle.height, 0.0f );

			MMDebug.DrawRectangle (pos, color, scale); 
		}	

		/// <summary>
		/// Draws a rectangle of the specified color and size at the specified position
		/// </summary>
		/// <param name="position">Position.</param>
		/// <param name="color">Color.</param>
		/// <param name="size">Size.</param>
		public static void DrawRectangle  (Vector3 position, Color color, Vector3 size)
        {
            if (!DebugDrawEnabled)
            {
                return;
            }

            Vector3 halfSize = size / 2f; 

			Vector3[] points = new Vector3 []
			{
				position + new Vector3(halfSize.x,halfSize.y,halfSize.z),
				position + new Vector3(-halfSize.x,halfSize.y,halfSize.z),
				position + new Vector3(-halfSize.x,-halfSize.y,halfSize.z),
				position + new Vector3(halfSize.x,-halfSize.y,halfSize.z),	
			};

			Debug.DrawLine (points[0], points[1], color ); 
			Debug.DrawLine (points[1], points[2], color ); 
			Debug.DrawLine (points[2], points[3], color ); 
			Debug.DrawLine (points[3], points[0], color ); 
		}
        
        /// <summary>
        /// Draws a point of the specified color and size at the specified position
        /// </summary>
        /// <param name="pos">Position.</param>
        /// <param name="col">Col.</param>
        /// <param name="scale">Scale.</param>
        public static void DrawPoint (Vector3 position, Color color, float size)
        {
            if (!DebugDrawEnabled)
            {
                return;
            }

            Vector3[] points = new Vector3[] 
			{
				position + (Vector3.up * size), 
				position - (Vector3.up * size), 
				position + (Vector3.right * size), 
				position - (Vector3.right * size), 
				position + (Vector3.forward * size), 
				position - (Vector3.forward * size)
			}; 		

			Debug.DrawLine (points[0], points[1], color ); 
			Debug.DrawLine (points[2], points[3], color ); 
			Debug.DrawLine (points[4], points[5], color ); 
			Debug.DrawLine (points[0], points[2], color ); 
			Debug.DrawLine (points[0], points[3], color ); 
			Debug.DrawLine (points[0], points[4], color ); 
			Debug.DrawLine (points[0], points[5], color ); 
			Debug.DrawLine (points[1], points[2], color ); 
			Debug.DrawLine (points[1], points[3], color ); 
			Debug.DrawLine (points[1], points[4], color ); 
			Debug.DrawLine (points[1], points[5], color ); 
			Debug.DrawLine (points[4], points[2], color ); 
			Debug.DrawLine (points[4], points[3], color ); 
			Debug.DrawLine (points[5], points[2], color ); 
			Debug.DrawLine (points[5], points[3], color ); 
		}

        #endregion

        #region Info

        public static string GetSystemInfo()
        {
            string result = "SYSTEM INFO";

            #if UNITY_IOS
                 result += "\n[iPhone generation]iPhone.generation.ToString()";
            #endif

            #if UNITY_ANDROID
                result += "\n[system info]" + SystemInfo.deviceModel;
            #endif

            result += "\n<color=#FFFFFF>Device Type :</color> " + SystemInfo.deviceType;
            result += "\n<color=#FFFFFF>OS Version :</color> " + SystemInfo.operatingSystem;
            result += "\n<color=#FFFFFF>System Memory Size :</color> " + SystemInfo.systemMemorySize;
            result += "\n<color=#FFFFFF>Graphic Device Name :</color> " + SystemInfo.graphicsDeviceName + " (version " + SystemInfo.graphicsDeviceVersion + ")";
            result += "\n<color=#FFFFFF>Graphic Memory Size :</color> " + SystemInfo.graphicsMemorySize;
            result += "\n<color=#FFFFFF>Graphic Max Texture Size :</color> " + SystemInfo.maxTextureSize;
            result += "\n<color=#FFFFFF>Graphic Shader Level :</color> " + SystemInfo.graphicsShaderLevel;
            result += "\n<color=#FFFFFF>Compute Shader Support :</color> " + SystemInfo.supportsComputeShaders;

            result += "\n<color=#FFFFFF>Processor Count :</color> " + SystemInfo.processorCount;
            result += "\n<color=#FFFFFF>Processor Type :</color> " + SystemInfo.processorType;
            result += "\n<color=#FFFFFF>3D Texture Support :</color> " + SystemInfo.supports3DTextures;
            result += "\n<color=#FFFFFF>Shadow Support :</color> " + SystemInfo.supportsShadows;

            result += "\n<color=#FFFFFF>Platform :</color> " + Application.platform;
            result += "\n<color=#FFFFFF>Screen Size :</color> " + Screen.width + " x " + Screen.height;
            result += "\n<color=#FFFFFF>DPI :</color> " + Screen.dpi;

            return result;
        }

        #endregion
    }
}