/*
 * ActionFloatArrayGet.cs
using UnityEngine;
using System.Collections.Generic;
#if UNITY_EDITOR
using UnityEditor;
#endif

namespace AC
{

    [System.Serializable]
    public class ActionFloatArrayGet : Action
    {

        // Source (FloatArray)
        public VariableLocation arrayLocation;
        public int arrayParameterID = -1;
        public int arrayVariableID;
        public Variables arrayVariables;
        public int arrayVariablesConstantID = 0;

        public int index = 0;
        public int indexParameterID = -1;

        // Destination (Float)
        public VariableLocation floatLocation;
        public int floatParameterID = -1;
        public int floatVariableID;
        public Variables floatVariables;
        public int floatVariablesConstantID = 0;

        protected LocalVariables localVariables;
        protected GVar runtimeArrayVariable;
        protected GVar runtimeFloatVariable;
        protected Variables runtimeFloatVariables;


        public override ActionCategory Category { get { return ActionCategory.Variable; }}
        public override string Title { get { return "Get Float Array Element"; }}
        public override string Description { get { return "Copies the value of an element in a FloatArray variable, at a given index, into a Float variable."; }}


        public override void AssignValues (List<ActionParameter> parameters)
        {
            index = AssignInteger (parameters, indexParameterID, index);

            // Source array
            runtimeArrayVariable = null;
            switch (arrayLocation)
            {
                case VariableLocation.Global:
                    arrayVariableID = AssignVariableID (parameters, arrayParameterID, arrayVariableID);
                    runtimeArrayVariable = GlobalVariables.GetVariable (arrayVariableID);
                    break;

                case VariableLocation.Local:
                    if (!isAssetFile)
                    {
                        arrayVariableID = AssignVariableID (parameters, arrayParameterID, arrayVariableID);
                        runtimeArrayVariable = LocalVariables.GetVariable (arrayVariableID, localVariables);
                    }
                    break;

                case VariableLocation.Component:
                    Variables runtimeArrayVariables = AssignFile<Variables> (arrayVariablesConstantID, arrayVariables);
                    if (runtimeArrayVariables != null)
                    {
                        runtimeArrayVariable = runtimeArrayVariables.GetVariable (arrayVariableID);
                    }
                    runtimeArrayVariable = AssignVariable (parameters, arrayParameterID, runtimeArrayVariable);
                    break;
            }

            // Destination float
            runtimeFloatVariable = null;
            runtimeFloatVariables = null;
            switch (floatLocation)
            {
                case VariableLocation.Global:
                    floatVariableID = AssignVariableID (parameters, floatParameterID, floatVariableID);
                    runtimeFloatVariable = GlobalVariables.GetVariable (floatVariableID, true);
                    break;

                case VariableLocation.Local:
                    if (!isAssetFile)
                    {
                        floatVariableID = AssignVariableID (parameters, floatParameterID, floatVariableID);
                        runtimeFloatVariable = LocalVariables.GetVariable (floatVariableID, localVariables);
                    }
                    break;

                case VariableLocation.Component:
                    runtimeFloatVariables = AssignFile<Variables> (floatVariablesConstantID, floatVariables);
                    if (runtimeFloatVariables != null)
                    {
                        runtimeFloatVariable = runtimeFloatVariables.GetVariable (floatVariableID);
                    }
                    runtimeFloatVariable = AssignVariable (parameters, floatParameterID, runtimeFloatVariable);
                    runtimeFloatVariables = AssignVariablesComponent (parameters, floatParameterID, runtimeFloatVariables);
                    break;
            }
        }


        public override void AssignParentList (ActionList actionList)
        {
            if (actionList != null)
            {
                localVariables = UnityVersionHandler.GetLocalVariablesOfGameObject (actionList.gameObject);
            }
            if (localVariables == null)
            {
                localVariables = KickStarter.localVariables;
            }

            base.AssignParentList (actionList);
        }


        public override float Run ()
        {
            if (runtimeArrayVariable == null)
            {
                LogWarning ("Cannot get Float Array element - the FloatArray variable cannot be found.");
                return 0f;
            }
            if (runtimeFloatVariable == null)
            {
                LogWarning ("Cannot get Float Array element - the Float variable to write to cannot be found.");
                return 0f;
            }
            if (runtimeArrayVariable.type != VariableType.FloatArray)
            {
                LogWarning ("Cannot get Float Array element - variable '" + runtimeArrayVariable.label + "' is not a FloatArray.");
                return 0f;
            }
            if (runtimeFloatVariable.type != VariableType.Float)
            {
                LogWarning ("Cannot get Float Array element - variable '" + runtimeFloatVariable.label + "' is not a Float.");
                return 0f;
            }

            float value;
            if (!runtimeArrayVariable.TryGetFloatArrayElement (index, out value))
            {
                LogWarning ("Cannot get index " + index + " of FloatArray variable '" + runtimeArrayVariable.label + "' - index is out of range (size = " + runtimeArrayVariable.FloatArrayLength + ")");
                return 0f;
            }

            runtimeFloatVariable.FloatValue = value;
            runtimeFloatVariable.Upload (floatLocation, runtimeFloatVariables);
            KickStarter.actionListManager.VariableChanged ();

            return 0f;
        }


        #if UNITY_EDITOR

        public override void ShowGUI (List<ActionParameter> parameters)
        {
            // Source
            arrayLocation = (VariableLocation) EditorGUILayout.EnumPopup ("Array source:", arrayLocation);

            switch (arrayLocation)
            {
                case VariableLocation.Global:
                    GlobalVariableField ("FloatArray variable:", ref arrayVariableID, null, parameters, ref arrayParameterID);
                    break;

                case VariableLocation.Local:
                    if (isAssetFile)
                    {
                        EditorGUILayout.HelpBox ("Local variables cannot be accessed in ActionList assets.", MessageType.Info);
                    }
                    else if (localVariables != null)
                    {
                        LocalVariableField ("FloatArray variable:", ref arrayVariableID, null, parameters, ref arrayParameterID);
                    }
                    else
                    {
                        EditorGUILayout.HelpBox ("No 'Local Variables' component found in the scene. Please add an AC GameEngine object from the Scene Manager.", MessageType.Info);
                    }
                    break;

                case VariableLocation.Component:
                    ComponentVariableField ("FloatArray variable:", ref arrayVariables, ref arrayVariablesConstantID, ref arrayVariableID, null, parameters, ref arrayParameterID);
                    break;
            }

            IntField ("Index:", ref index, parameters, ref indexParameterID);
            if (indexParameterID < 0 && index < 0)
            {
                index = 0;
            }

            EditorGUILayout.Space ();

            // Destination
            floatLocation = (VariableLocation) EditorGUILayout.EnumPopup ("Float source:", floatLocation);

            switch (floatLocation)
            {
                case VariableLocation.Global:
                    GlobalVariableField ("Float variable:", ref floatVariableID, null, parameters, ref floatParameterID);
                    break;

                case VariableLocation.Local:
                    if (isAssetFile)
                    {
                        EditorGUILayout.HelpBox ("Local variables cannot be accessed in ActionList assets.", MessageType.Info);
                    }
                    else if (localVariables != null)
                    {
                        LocalVariableField ("Float variable:", ref floatVariableID, null, parameters, ref floatParameterID);
                    }
                    else
                    {
                        EditorGUILayout.HelpBox ("No 'Local Variables' component found in the scene. Please add an AC GameEngine object from the Scene Manager.", MessageType.Info);
                    }
                    break;

                case VariableLocation.Component:
                    ComponentVariableField ("Float variable:", ref floatVariables, ref floatVariablesConstantID, ref floatVariableID, null, parameters, ref floatParameterID);
                    break;
            }
        }


        public override string SetLabel ()
        {
            GVar arrayVar = GetEditorVariable (arrayLocation, arrayVariableID, arrayVariables, arrayParameterID);
            GVar floatVar = GetEditorVariable (floatLocation, floatVariableID, floatVariables, floatParameterID);

            if (arrayVar != null && floatVar != null)
            {
                return floatVar.label + " = " + arrayVar.label + "[" + ((indexParameterID < 0) ? index.ToString () : "param") + "]";
            }
            return string.Empty;
        }


        private GVar GetEditorVariable (VariableLocation location, int variableID, Variables variables, int parameterID)
        {
            if (parameterID >= 0)
            {
                return null;
            }

            switch (location)
            {
                case VariableLocation.Global:
                    return (KickStarter.variablesManager != null) ? KickStarter.variablesManager.GetVariable (variableID) : null;

                case VariableLocation.Local:
                    return isAssetFile ? null : LocalVariables.GetVariable (variableID);

                case VariableLocation.Component:
                    return (variables != null) ? variables.GetVariable (variableID) : null;
            }
            return null;
        }


        public override int GetNumVariableReferences (VariableLocation _location, int varID, List<ActionParameter> parameters, Variables _variables = null, int _variablesConstantID = 0)
        {
            int thisCount = 0;

            if (arrayLocation == _location && arrayVariableID == varID && arrayParameterID < 0)
            {
                if (_location != VariableLocation.Component || (arrayVariables && arrayVariables == _variables) || (_variablesConstantID != 0 && _variablesConstantID == arrayVariablesConstantID))
                {
                    thisCount ++;
                }
            }

            if (floatLocation == _location && floatVariableID == varID && floatParameterID < 0)
            {
                if (_location != VariableLocation.Component || (floatVariables && floatVariables == _variables) || (_variablesConstantID != 0 && _variablesConstantID == floatVariablesConstantID))
                {
                    thisCount ++;
                }
            }

            thisCount += base.GetNumVariableReferences (_location, varID, parameters, _variables, _variablesConstantID);
            return thisCount;
        }


        public override int UpdateVariableReferences (VariableLocation _location, int oldVarID, int newVarID, List<ActionParameter> parameters, Variables _variables = null, int _variablesConstantID = 0)
        {
            int thisCount = 0;

            if (arrayLocation == _location && arrayVariableID == oldVarID && arrayParameterID < 0)
            {
                if (_location != VariableLocation.Component || (arrayVariables && arrayVariables == _variables) || (_variablesConstantID != 0 && _variablesConstantID == arrayVariablesConstantID))
                {
                    arrayVariableID = newVarID;
                    thisCount ++;
                }
            }

            if (floatLocation == _location && floatVariableID == oldVarID && floatParameterID < 0)
            {
                if (_location != VariableLocation.Component || (floatVariables && floatVariables == _variables) || (_variablesConstantID != 0 && _variablesConstantID == floatVariablesConstantID))
                {
                    floatVariableID = newVarID;
                    thisCount ++;
                }
            }

            thisCount += base.UpdateVariableReferences (_location, oldVarID, newVarID, parameters, _variables, _variablesConstantID);
            return thisCount;
        }


        public override void AssignConstantIDs (bool saveScriptsToo, bool fromAssetFile)
        {
            if (arrayLocation == VariableLocation.Component)
            {
                if (saveScriptsToo && arrayVariables && arrayParameterID < 0)
                {
                    AddSaveScript<RememberVariables> (arrayVariables);
                }
                arrayVariablesConstantID = AssignConstantID<Variables> (arrayVariables, arrayVariablesConstantID, arrayParameterID);
            }

            if (floatLocation == VariableLocation.Component)
            {
                if (saveScriptsToo && floatVariables && floatParameterID < 0)
                {
                    AddSaveScript<RememberVariables> (floatVariables);
                }
                floatVariablesConstantID = AssignConstantID<Variables> (floatVariables, floatVariablesConstantID, floatParameterID);
            }
        }


        public override bool ReferencesObjectOrID (GameObject gameObject, int id)
        {
            if (arrayParameterID < 0 && arrayLocation == VariableLocation.Component)
            {
                if (arrayVariables && arrayVariables.gameObject == gameObject) return true;
                if (arrayVariablesConstantID == id && id != 0) return true;
            }
            if (floatParameterID < 0 && floatLocation == VariableLocation.Component)
            {
                if (floatVariables && floatVariables.gameObject == gameObject) return true;
                if (floatVariablesConstantID == id && id != 0) return true;
            }
            return base.ReferencesObjectOrID (gameObject, id);
        }

        #endif

    }

}