//----------------------------------------------------------------------------------
//
// CRUNGET : Get object
//
//----------------------------------------------------------------------------------
package Extensions
{
    import Actions.*;
    import flash.display.ActionScriptVersion;
    import flash.filters.ConvolutionFilter;

    import Conditions.*;

    import Expressions.*;

    import Objects.*;

    import RunLoop.*;

    import Services.*;

    import Sprites.*;

    import flash.utils.Dictionary;

    public class CRunFunction extends CRunExtension
    {
        var strParams:Dictionary = new Dictionary();
        var numParams:Dictionary = new Dictionary();
        var queue:Dictionary = new Dictionary();

        var returnStr:String;
        var returnNum:Number;

        public function CRunFunction()
        {

        }

        public override function handleRunObject():int
        {
            strParams = new Dictionary();
            numParams = new Dictionary();
            queue = new Dictionary();
            returnStr = "";
            returnNum = 0;
            return 0;
        }

        public override function getNumberOfConditions():int
        {
            return 3;
        }

        public override function condition(num:int, cnd:CCndExtension):Boolean
        {
            switch(num)
            {
                case 0:
                {
                    return onFunction(cnd.getParamExpString(rh,0));
                }
                case 1:
                {
                    return addString(cnd.getParamExpString(rh, 0), cnd.getParamExpString(rh, 1));
                }
                case 2:
                {
                    return addNumber(cnd.getParamExpString(rh, 0), cnd.getParamExpression(rh, 1));
                }
            }
            return false;
        }

        public override function action(num:int, act:CActExtension):void
        {
            switch(num)
            {
                case 0:
                {
                    insertString(act.getParamExpString(rh, 0), act.getParamExpString(rh, 1));
                    break;
                }
                case 1:
                {
                    insertNumber(act.getParamExpString(rh, 0), act.getParamExpression(rh, 1));
                    break;
                }
                case 2:
                {
                    runFunction(act.getParamExpString(rh, 0));
                    break;
                }
                case 3:
                {
                    returnString(act.getParamExpString(rh, 0));
                    break;
                }
                case 4:
                {
                    returnNumber(act.getParamExpression(rh, 0));
                    break;
                }
            }
        }

        public override function expression(num:int):CValue
        {
            switch(num)
            {
                case 0:
                {
                    return getString(ho.getExpParam().getString());
                }
                case 1:
                {
                    return getNumber(ho.getExpParam().getString());
                }
            }
            return new CValue(0);
        }

        public function onFunction(name:String):Boolean
        {
            return (queue[name] == 1);
        }

        public function addString(identifier:String, str:String):Boolean
        {
            insertString(identifier, str);
            return true;
        }

        public function addNumber(identifier:String, n:Number):Boolean
        {
            insertNumber(identifier, n);
            return true;
        }

        public function insertString(identifier:String, str:String):void
        {
            strParams[identifier] = str;
        }

        public function insertNumber(identifier:String, n:Number):void
        {
            numParams[identifier] = n;
        }

        public function runFunction(name:String):void
        {
            queueUp();
            queue[name] = 1;
            ho.generateEvent(onFunction, 0);
            queue[name] = 0;
            queueDown();
        }

        public function returnString(str:String):void
        {
            returnStr = str;
        }

        public function returnNumber(n:Number):void
        {
            returnNum = n;
        }

        public function getString(key:String):CValue
        {
            return CString(strParams[key]);
        }

        public function getNumber(key:String):CValue
        {
            return CDouble(numParams[key]);
        }

        public function queueUp():void
        {
            for (var k:Object in queue)
            {
                if (queue[k]>0)
                {
                    queue[k]++;
                }
            }
        }

        public function queueDown():void
        {
            for (var k:Object in queue)
            {
                if (queue[k]>0)
                {
                    queue[k]--;
                }
            }
        }

        public function CDouble(n:Number):CValue
        {
            var v:CValue = new CValue(0);
            v.forceDouble(n);
            return v;
        }

        public function CString(str:String):CValue
        {
            var v:CValue = new CValue(0);
            v.forceString(str);
            return v;
        }
    }
}