/// <summary>
        ///   Depending on the group policy of its parent, the floating point return value indicates whether the decider will be activated.
        /// </summary>
        /// <param name="agentData"> Agent data. </param>
        /// <param name="decisionData"> Decision data to use in activate method. </param>
        /// <returns> Floating point value used to decide if the decider will be activated. </returns>
        public override float Decide(IAgentData agentData, ref IDecisionData decisionData)
        {
            // Create blackboard.
            Blackboard blackboard = new Blackboard();

            // Add parent blackboards.
            if (this.Blackboard != null)
            {
                blackboard.Parents.Add(this.Blackboard);
            }

            blackboard.Parents.Add(agentData.Blackboard);

            // Setup blackboard.
            Blackboard previousBlackboard = agentData.Blackboard;
            agentData.Blackboard = blackboard;

            // Deactivate child.
            IDecisionData childDecisionData = null;
            float decisionValue = this.DecideChild(agentData, ref childDecisionData);

            // Tear down.
            agentData.Blackboard = previousBlackboard;

            // Create decision data.
            if (decisionValue > 0.0f)
            {
                decisionData = new DecisionData { Blackboard = blackboard, ChildDecisionData = childDecisionData };
            }

            return decisionValue;
        }

        /// <summary>
        ///   Per frame update.
        /// </summary>
        /// <param name="agentData"> Agent data. </param>
        /// <returns> Execution status after this update. </returns>
        public override ExecutionStatus Update(IAgentData agentData)
        {
            Data data = agentData.GetTaskData<Data>();
            if (data.Status == ExecutionStatus.Running)
            {
                // Update.
                data.Status = this.UpdateChild(agentData);
            }
            else
            {
                // Restart if still possible.
                IDecisionData decisionData = null;
                ++agentData.CurrentDeciderLevel;
                float decisionValue = this.Task.Decide(agentData, ref decisionData);
                --agentData.CurrentDeciderLevel;
                if (decisionValue > 0.0f)
                {
                    data.Status = this.ActivateChild(agentData, decisionData);
                    if (data.Status == ExecutionStatus.Running)
                    {
                        data.Status = this.UpdateChild(agentData);
                    }
                }
                else
                {
                    data.Status = ExecutionStatus.Failed;
                }
            }

            return ExecutionStatus.Running;
        }

 /// <summary>
 ///   Deactivation.
 /// </summary>
 /// <param name="agentData"> Agent data. </param>
 public override void Deactivate(IAgentData agentData)
 {
     ITask task = this.GetTask(agentData);
     if (task != null)
     {
         task.Deactivate(agentData);
     }
 }

        /// <summary>
        ///   Decision function for a boolean condition.
        /// </summary>
        /// <param name="agentData"> Agent data. </param>
        /// <returns> Returns true if the condition is forfilled, else false. </returns>
        protected override bool Decide(IAgentData agentData)
        {
            object attribute = null;
            if (!agentData.Blackboard.TryGetValue(this.BlackboardAttributeKey, out attribute))
            {
                return false;
            }

            // Check that not null.
            return attribute != null;
        }

        /// <summary>
        ///   Deactivation.
        /// </summary>
        /// <param name="agentData"> Agent data. </param>
        public override void Deactivate(IAgentData agentData)
        {
            Data data = agentData.GetTaskData<Data>();

            // Deactivate child if running.
            if (data.Status == ExecutionStatus.Running)
            {
                this.DeactivateChild(agentData);
            }

            agentData.CurrentTaskData = null;
        }

        /// <summary>
        ///   Per frame update.
        /// </summary>
        /// <param name="agentData"> Agent data. </param>
        /// <returns> Execution status after this update. </returns>
        public override ExecutionStatus Update(IAgentData agentData)
        {
            // Get key of attribute to remove.
            object key = this.GetBlackboardAttributeKey(agentData);
            if (key != null)
            {
                // Remove attribute.
                agentData.Blackboard.RemoveValue(key);
            }

            return ExecutionStatus.Success;
        }

        /// <summary>
        ///   Activation. This method is called when the task was chosen to be executed. It's called right before the first update of the task. The task can setup its specific task data in here and do initial actions.
        /// </summary>
        /// <param name="agentData"> Agent data. </param>
        /// <param name="decisionData"> Decision data to use in activate method. </param>
        /// <returns> Execution status after activation. </returns>
        public override ExecutionStatus Activate(IAgentData agentData, IDecisionData decisionData)
        {
            Data data = new Data();
            data.Status = this.ActivateChild(agentData, decisionData);
            if (data.Status == ExecutionStatus.Failed)
            {
                return ExecutionStatus.Failed;
            }

            agentData.CurrentTaskData = data;

            return ExecutionStatus.Running;
        }

        /// <summary>
        ///   Deactivation.
        /// </summary>
        /// <param name="agentData"> Agent data. </param>
        public override void Deactivate(IAgentData agentData)
        {
            Data data = agentData.GetTaskData<Data>();

            // Setup blackboard.
            Setup(agentData, data);

            // Deactivate child.
            this.DeactivateChild(agentData);

            // Tear down.
            TearDown(agentData, data);
        }

        /// <summary>
        ///   Per frame update.
        /// </summary>
        /// <param name="agentData"> Agent data. </param>
        /// <returns> Execution status after this update. </returns>
        public override ExecutionStatus Update(IAgentData agentData)
        {
            // Get value from blackboard.
            object attribute = null;
            if (!agentData.Blackboard.TryGetValue(this.SourceAttributeKey, out attribute))
            {
                return ExecutionStatus.Failed;
            }

            // Set value to target key.
            agentData.Blackboard.SetValue(this.TargetAttributeKey, attribute);

            return ExecutionStatus.Success;
        }

        /// <summary>
        ///   Activation. This method is called when the task was chosen to be executed. It's called right before the first update of the task. The task can setup its specific task data in here and do initial actions.
        /// </summary>
        /// <param name="agentData"> Agent data. </param>
        /// <param name="decisionData"> Decision data to use in activate method. </param>
        /// <returns> Execution status after activation. </returns>
        public override ExecutionStatus Activate(IAgentData agentData, IDecisionData decisionData)
        {
            Data data = new Data { Status = ExecutionStatus.Failed };

            // Check if child wants to run.
            float childDecisionValue = this.DecideChild(agentData, ref decisionData);
            if (childDecisionValue > 0.0f)
            {
                data.Status = this.ActivateChild(agentData, decisionData);
            }

            agentData.CurrentTaskData = data;

            return ExecutionStatus.Running;
        }

        /// <summary>
        ///   Activation. This method is called when the task was chosen to be executed. It's called right before the first update of the task. The task can setup its specific task data in here and do initial actions.
        /// </summary>
        /// <param name="agentData"> Agent data. </param>
        /// <param name="decisionData"> Decision data to use in activate method. </param>
        /// <returns> Execution status after activation. </returns>
        public override ExecutionStatus Activate(IAgentData agentData, IDecisionData decisionData)
        {
            DecisionData taskDecisionData = (DecisionData)decisionData;

            // Create child blackboard.
            Data data = new Data { Blackboard = taskDecisionData.Blackboard, PreviousBlackboard = agentData.Blackboard };
            agentData.CurrentTaskData = data;

            // Setup blackboard.
            Setup(agentData, data);

            // Activate child.
            ExecutionStatus result = this.ActivateChild(agentData, taskDecisionData.ChildDecisionData);
            if (result != ExecutionStatus.Running)
            {
                // Tear down.
                TearDown(agentData, data);
            }

            return result;
        }

        /// <summary>
        ///   Activation. This method is called when the task was chosen to be executed. It's called right before the first update of the task. The task can setup its specific task data in here and do initial actions.
        /// </summary>
        /// <param name="agentData"> Agent data. </param>
        /// <param name="decisionData"> Decision data to use in activate method. </param>
        /// <returns> Execution status after activation. </returns>
        public override ExecutionStatus Activate(IAgentData agentData, IDecisionData decisionData)
        {
            Blackboard blackboard = agentData.Blackboard;
            if (blackboard.Parents == null)
            {
                return ExecutionStatus.Failed;
            }

            // Find attribute on parent blackboard.
            foreach (Blackboard parent in blackboard.Parents)
            {
                object attribute = null;
                if (parent.TryGetValue(this.AttributeKey, out attribute))
                {
                    // Set attribute on blackboard.
                    blackboard.SetValue(this.AttributeKey, attribute);

                    return ExecutionStatus.Success;
                }
            }

            return ExecutionStatus.Failed;
        }

        /// <summary>
        ///   Per frame update.
        /// </summary>
        /// <param name="agentData"> Agent data. </param>
        /// <returns> Execution status after this update. </returns>
        public override ExecutionStatus Update(IAgentData agentData)
        {
            Data data = agentData.CurrentTaskData as Data;
            if (data.Status == ExecutionStatus.Running)
            {
                data.Status = this.UpdateChild(agentData);
            }
            else
            {
                // Restart if still possible.
                IDecisionData decisionData = null;
                float decisionValue = this.Task.Decide(agentData, ref decisionData);
                if (decisionValue > 0.0f)
                {
                    data.Status = this.ActivateChild(agentData, decisionData);
                    if (data.Status == ExecutionStatus.Running)
                    {
                        data.Status = this.UpdateChild(agentData);
                    }
                }
            }

            return data.Status == ExecutionStatus.Failed ? ExecutionStatus.Failed : ExecutionStatus.Running;
        }

        private bool UpdateAgent(GridRegion destination, IAgentData cAgentData)
        {
            // Try local first
            if (cAgentData is AgentData)
            {
                if (m_localBackend.UpdateAgent(destination, (AgentData) cAgentData))
                    return true;
            }
            else if (cAgentData is AgentPosition)
            {
                if (m_localBackend.UpdateAgent(destination, (AgentPosition) cAgentData))
                    return true;
            }

            // else do the remote thing
            if (!m_localBackend.IsLocalRegion(destination.RegionHandle))
            {
                // Eventually, we want to use a caps url instead of the agentID
                string uri = MakeUri(destination, true) + cAgentData.AgentID + "/";

                if (m_blackListedRegions.ContainsKey(uri))
                {
                    //Check against time
                    if (m_blackListedRegions[uri] > 3 &&
                        Util.EnvironmentTickCountSubtract(m_blackListedRegions[uri]) > 0)
                    {
                        MainConsole.Instance.Warn("[SimServiceConnector]: Blacklisted region " + destination.RegionName + " requested");
                        //Still blacklisted
                        return false;
                    }
                }
                try
                {
                    OSDMap args = cAgentData.Pack();

                    args["destination_x"] = OSD.FromString(destination.RegionLocX.ToString());
                    args["destination_y"] = OSD.FromString(destination.RegionLocY.ToString());
                    args["destination_name"] = OSD.FromString(destination.RegionName);
                    args["destination_uuid"] = OSD.FromString(destination.RegionID.ToString());

                    OSDMap result = WebUtils.PutToService(uri, args, true, true, false);
                    if (!result["Success"].AsBoolean())
                    {
                        if (m_blackListedRegions.ContainsKey(uri))
                        {
                            if (m_blackListedRegions[uri] == 3)
                            {
                                //add it to the blacklist as the request completely failed 3 times
                                m_blackListedRegions[uri] = Util.EnvironmentTickCount() + 60*1000; //60 seconds
                            }
                            else if (m_blackListedRegions[uri] == 0)
                                m_blackListedRegions[uri]++;
                        }
                        else
                            m_blackListedRegions[uri] = 0;
                        return result["Success"].AsBoolean();
                    }
                    //Clear out the blacklist if it went through
                    m_blackListedRegions.Remove(uri);

                    OSDMap innerResult = (OSDMap) result["_Result"];
                    return innerResult["Updated"].AsBoolean();
                }
                catch (Exception e)
                {
                    MainConsole.Instance.Warn("[REMOTE SIMULATION CONNECTOR]: UpdateAgent failed with exception: " + e);
                }

                return false;
            }

            return false;
        }

 /// <summary>
 ///   Should return the key of the blackboard attribute to remove.
 /// </summary>
 /// <param name="agentData"> Agent data. </param>
 /// <returns> Key of the blackboard attribute to remove. </returns>
 protected abstract object GetBlackboardAttributeKey(IAgentData agentData);

        public void SendChildAgentUpdate(IAgentData childAgentUpdate, UUID regionID)
        {
            if (!m_KnownNeighbors.ContainsKey(regionID))
                return;

            Util.FireAndForget(delegate(object o)
            {
                //Send the updates to all known neighbors
                foreach (GridRegion region in m_KnownNeighbors[regionID])
                {
                    if (childAgentUpdate is AgentData)
                        m_simService.UpdateAgent(region, (AgentData)childAgentUpdate);
                    else
                        m_simService.UpdateAgent(region, (AgentPosition)childAgentUpdate);
                }
            });
        }

        public bool DoRetrieveRootAgentCall(RegionInfo region, UUID id, out IAgentData agent)
        {
            agent = null;
            // Eventually, we want to use a caps url instead of the agentID
            string uri = "http://" + region.ExternalHostName + ":" + region.HttpPort + "/agent/" + id + "/" + region.RegionHandle.ToString() + "/";
            //Console.WriteLine("   >>> DoRetrieveRootAgentCall <<< " + uri);

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uri);
            request.Method = "GET";
            request.Timeout = 10000;
            //request.Headers.Add("authorization", ""); // coming soon
            request.Headers["authorization"] = GenerateAuthorization();

            HttpWebResponse webResponse = null;
            string reply = string.Empty;
            try
            {
                webResponse = (HttpWebResponse)request.GetResponse();
                if (webResponse == null)
                {
                    m_log.Info("[REST COMMS]: Null reply on agent get ");
                    return false;
                }

                StreamReader sr = new StreamReader(webResponse.GetResponseStream());
                reply = sr.ReadToEnd().Trim();
                sr.Close();
                //Console.WriteLine("[REST COMMS]: ChildAgentUpdate reply was " + reply);
            }
            catch (WebException ex)
            {
                m_log.InfoFormat("[REST COMMS]: exception on reply of agent get {0}", ex.Message);
                // ignore, really
                return false;
            }

            if (webResponse.StatusCode == HttpStatusCode.OK)
            {
                // we know it's jason
                OSDMap args = GetOSDMap(reply);
                if (args == null)
                {
                    //Console.WriteLine("[REST COMMS]: Error getting OSDMap from reply");
                    return false;
                }

                agent = new CompleteAgentData();
                agent.Unpack(args);
                return true;
            }

            //Console.WriteLine("[REST COMMS]: DoRetrieveRootAgentCall returned status " + webResponse.StatusCode);
            return false;
        }

        /// <summary>
        /// Not sure what sequence causes this function to be invoked. The only calling
        /// path is through the GET method 
        /// </summary>
        public bool RetrieveAgent(GridRegion destination, UUID id, out IAgentData agent)
        {
            // m_log.DebugFormat("[REMOTE SIMULATION CONNECTOR]: RetrieveAgent start");

            agent = null;

            // Eventually, we want to use a caps url instead of the agentID
            string uri = destination.ServerURI + AgentPath() + id + "/" + destination.RegionID.ToString() + "/";

            try
            {
                OSDMap result = WebUtil.GetFromService(uri, 10000);
                if (result["Success"].AsBoolean())
                {
                    // OSDMap args = Util.GetOSDMap(result["_RawResult"].AsString());
                    OSDMap args = (OSDMap)result["_Result"];
                    if (args != null)
                    {
                        agent = new CompleteAgentData();
                        agent.Unpack(args, null);
                        return true;
                    }
                }
            }
            catch (Exception e)
            {
                m_log.Warn("[REMOTE SIMULATION CONNECTOR]: UpdateAgent failed with exception: " + e.ToString());
            }

            return false;
        }

        public virtual bool IncomingRetrieveRootAgent(UUID id, out IAgentData agent)
        {
            agent = null;
            ScenePresence sp = GetScenePresence(id);
            if ((sp != null) && (!sp.IsChildAgent))
            {
                sp.IsChildAgent = true;
                return sp.CopyAgent(out agent);
            }

            return false;
        }

 public bool SendRetrieveRootAgent(ulong regionHandle, UUID id, out IAgentData agent)
 {
     agent = null;
     foreach (Scene s in m_sceneList)
     {
         if (s.RegionInfo.RegionHandle == regionHandle)
         {
             //m_log.Debug("[LOCAL COMMS]: Found region to send ChildAgentUpdate");
             return s.IncomingRetrieveRootAgent(id, out agent);
         }
     }
     //m_log.Debug("[LOCAL COMMS]: region not found for ChildAgentUpdate");
     return false;
 }