public void AddOfflineMessage(GridInstantMessage message)
 {
     foreach (string m_ServerURI in m_ServerURIs)
     {
         SimianUtils.AddGeneric(new UUID(message.toAgentID), "OfflineMessages", UUID.Random().ToString(), message.ToOSD(), m_ServerURI);
     }
 }

        public GridInstantMessage[] GetOfflineMessages(UUID PrincipalID)
        {
            OSDMap map = new OSDMap();

            map["PrincipalID"] = PrincipalID;
            map["Method"] = "getofflinemessages";

            List<GridInstantMessage> Messages = new List<GridInstantMessage>();
            try
            {
                List<string> urls =
                    m_registry.RequestModuleInterface<IConfigurationService>().FindValueOf(PrincipalID.ToString(),
                                                                                           "RemoteServerURI");
                foreach (string url in urls)
                {
                    OSDMap result = WebUtils.PostToService(url + "osd", map, true, false);
                    OSDArray array = (OSDArray) OSDParser.DeserializeJson(result["_RawResult"]);
                    foreach (OSD o in array)
                    {
                        GridInstantMessage message = new GridInstantMessage();
                        message.FromOSD((OSDMap) o);
                        Messages.Add(message);
                    }
                }
                return Messages.ToArray();
            }
            catch (Exception e)
            {
                MainConsole.Instance.DebugFormat("[AuroraRemoteOfflineMessagesConnector]: Exception when contacting server: {0}", e);
            }
            return Messages.ToArray();
        }

 public bool AddOfflineMessage (GridInstantMessage message)
 {
     List<string> serverURIs = m_registry.RequestModuleInterface<IConfigurationService> ().FindValueOf (message.toAgentID.ToString (), "FriendsServerURI");
     if (serverURIs.Count > 0) //Remote user... or should be
         return m_remoteService.AddOfflineMessage (message);
     return m_localService.AddOfflineMessage (message);
 }

 private OSDMap syncRecievedService_OnMessageReceived(OSDMap message)
 {
     string method = message["Method"];
     if (method == "SendInstantMessages")
     {
         List<GridInstantMessage> messages =
             ((OSDArray) message["Messages"]).ConvertAll<GridInstantMessage>((o) =>
                                                                                 {
                                                                                     GridInstantMessage im =
                                                                                         new GridInstantMessage();
                                                                                     im.FromOSD((OSDMap) o);
                                                                                     return im;
                                                                                 });
         ISceneManager manager = m_registry.RequestModuleInterface<ISceneManager>();
         if (manager != null)
         {
             IMessageTransferModule messageTransfer =
                 manager.Scene.RequestModuleInterface<IMessageTransferModule>();
             if (messageTransfer != null)
             {
                 foreach (GridInstantMessage im in messages)
                     messageTransfer.SendInstantMessage(im);
             }
         }
     }
     return null;
 }

 public bool AddOfflineMessage(GridInstantMessage message)
 {
     foreach (string m_ServerURI in m_ServerURIs)
     {
         SimianUtils.AddGeneric(message.toAgentID, "OfflineMessages", UUID.Random().ToString(), message.ToOSD(),
                                m_ServerURI);
     }
     return true;
 }

        public bool AddOfflineMessage(GridInstantMessage message)
        {
            object remoteValue = DoRemote(message);
            if (remoteValue != null || m_doRemoteOnly)
                return remoteValue == null ? false : (bool) remoteValue;

            if (m_maxOfflineMessages <= 0 ||
                GenericUtils.GetGenericCount(message.ToAgentID, "OfflineMessages", GD) < m_maxOfflineMessages)
            {
                GenericUtils.AddGeneric(message.ToAgentID, "OfflineMessages", UUID.Random().ToString(),
                                        message.ToOSD(), GD);
                return true;
            }
            return false;
        }

 public GridInstantMessage[] GetOfflineMessages(UUID PrincipalID)
 {
     List<GridInstantMessage> Messages = new List<GridInstantMessage>();
     Dictionary<string, OSDMap> Maps = new Dictionary<string,OSDMap>();
     if(SimianUtils.GetGenericEntries(PrincipalID, "OfflineMessages", m_ServerURI, out Maps))
     {
         GridInstantMessage baseMessage = new GridInstantMessage();
         foreach(OSDMap map in Maps.Values)
         {
             baseMessage.FromOSD(map);
             Messages.Add(baseMessage);
         }
     }
     return Messages.ToArray();
 }

        public GridInstantMessage[] GetOfflineMessages(UUID PrincipalID)
        {
            Dictionary<string, object> sendData = new Dictionary<string, object>();

            sendData["PRINCIPALID"] = PrincipalID;
            sendData["METHOD"] = "getofflinemessages";

            string reqString = WebUtils.BuildQueryString(sendData);
            List<GridInstantMessage> Messages = new List<GridInstantMessage>();
            try
            {
                List<string> m_ServerURIs = m_registry.RequestModuleInterface<IConfigurationService>().FindValueOf(PrincipalID.ToString(), "RemoteServerURI");
                foreach (string m_ServerURI in m_ServerURIs)
                {
                    string reply = SynchronousRestFormsRequester.MakeRequest("POST",
                           m_ServerURI + "/auroradata",
                           reqString);
                    if (reply != string.Empty)
                    {
                        Dictionary<string, object> replyData = WebUtils.ParseXmlResponse(reply);

                        foreach (object f in replyData)
                        {
                            KeyValuePair<string, object> value = (KeyValuePair<string, object>)f;
                            if (value.Value is Dictionary<string, object>)
                            {
                                Dictionary<string, object> valuevalue = value.Value as Dictionary<string, object>;
                                GridInstantMessage message = new GridInstantMessage();
                                message.FromKVP(valuevalue);
                                Messages.Add(message);
                            }
                        }
                    }
                }
                return Messages.ToArray();
            }
            catch (Exception e)
            {
                m_log.DebugFormat("[AuroraRemoteOfflineMessagesConnector]: Exception when contacting server: {0}", e.ToString());
            }
            return Messages.ToArray();
        }

        public virtual void SendInstantMessages(GridInstantMessage im, List<UUID> AgentsToSendTo)
        {
            //Check for local users first
            List<UUID> RemoveUsers = new List<UUID>();
            foreach (UUID t in AgentsToSendTo)
            {
                IScenePresence user;
                if (!RemoveUsers.Contains(t) &&
                    m_Scene.TryGetScenePresence(t, out user))
                {
                    // Local message
                    user.ControllingClient.SendInstantMessage(im);
                    RemoveUsers.Add(t);
                }
            }
            //Clear the local users out
            foreach (UUID agentID in RemoveUsers)
            {
                AgentsToSendTo.Remove(agentID);
            }

            SendMultipleGridInstantMessageViaXMLRPC(im, AgentsToSendTo);
        }

        public void llGiveInventoryList(string destination, string category, LSL_List inventory)
        {
            ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
            

            UUID destID;
            if (!UUID.TryParse(destination, out destID))
                return;

            List<UUID> itemList = new List<UUID>();

            foreach (Object item in inventory.Data)
            {
                UUID itemID;
                if (UUID.TryParse(item.ToString(), out itemID))
                {
                    itemList.Add(itemID);
                }
                else
                {
                    itemID = GetTaskInventoryItem(item.ToString());
                    if (itemID != UUID.Zero)
                        itemList.Add(itemID);
                }
            }

            if (itemList.Count == 0)
                return;
            UUID folderID = UUID.Zero;
            ILLClientInventory inventoryModule = World.RequestModuleInterface<ILLClientInventory>();
            if (inventoryModule != null)
                folderID = inventoryModule.MoveTaskInventoryItemsToUserInventory(destID, category, m_host, itemList);

            if (folderID == UUID.Zero)
                return;

            byte[] bucket = new byte[17];
            bucket[0] = (byte)AssetType.Folder;
            byte[] objBytes = folderID.GetBytes();
            Array.Copy(objBytes, 0, bucket, 1, 16);

            GridInstantMessage msg = new GridInstantMessage(World,
                    m_host.UUID, m_host.Name+", an object owned by "+
                    resolveName(m_host.OwnerID)+",", destID,
                    (byte)InstantMessageDialog.InventoryOffered,
                    false, category+"\n"+m_host.Name+" is located at "+
                    World.RegionInfo.RegionName+" "+
                    m_host.AbsolutePosition.ToString(),
                    folderID, true, m_host.AbsolutePosition,
                    bucket);

            if (m_TransferModule != null)
                m_TransferModule.SendInstantMessage(msg);
        }

 public bool LocalFriendshipDenied(UUID userID, string userName, UUID friendID)
 {
     IClientAPI friendClient = LocateClientObject(friendID);
     if (friendClient != null)
     {
         // the prospective friend in this sim as root agent
         GridInstantMessage im = new GridInstantMessage(m_Scenes[0], userID, userName, friendID,
             (byte)OpenMetaverse.InstantMessageDialog.FriendshipDeclined, userID.ToString(), false, Vector3.Zero);
         friendClient.SendInstantMessage(im);
         // we're done
         return true;
     }
     
     return false;
 }

        public DateTime llInstantMessage(string user, string message)
        {
            ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
            

            // We may be able to use ClientView.SendInstantMessage here, but we need a client instance.
            // InstantMessageModule.OnInstantMessage searches through a list of scenes for a client matching the toAgent,
            // but I don't think we have a list of scenes available from here.
            // (We also don't want to duplicate the code in OnInstantMessage if we can avoid it.)

            UUID friendTransactionID = UUID.Random();

            GridInstantMessage msg = new GridInstantMessage();
            msg.fromAgentID = new Guid(m_host.UUID.ToString());
            msg.toAgentID = new Guid(user); 
            msg.imSessionID = new Guid(friendTransactionID.ToString()); // This is the item we're mucking with here
            msg.timestamp = (uint)Util.UnixTimeSinceEpoch();
            msg.fromAgentName = m_host.Name;
            
            // Cap the message length at 1024.
            if (message != null && message.Length > 1024)
                msg.message = message.Substring(0, 1024);
            else
                msg.message = message;
            
            msg.dialog = (byte)InstantMessageDialog.MessageFromObject;
            msg.fromGroup = false;
            msg.offline = (byte)0; 
            msg.ParentEstateID = 0;
            msg.Position = m_host.AbsolutePosition;
            msg.RegionID = World.RegionInfo.RegionID.Guid;
            msg.binaryBucket
                = Util.StringToBytes256(
                    "{0}/{1}/{2}/{3}",
                    World.RegionInfo.RegionName,
                    (int)Math.Floor(m_host.AbsolutePosition.X),
                    (int)Math.Floor(m_host.AbsolutePosition.Y),
                    (int)Math.Floor(m_host.AbsolutePosition.Z));

            if (m_TransferModule != null)
            {
                m_TransferModule.SendInstantMessage(msg, delegate(bool success) {});
            }
            return PScriptSleep(2000);
      }

        public DateTime llGiveInventory(string destination, string inventory)
        {
            ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
            
            bool found = false;
            UUID destId = UUID.Zero;
            UUID objId = UUID.Zero;
            int assetType = 0;
            string objName = String.Empty;

            if (!UUID.TryParse(destination, out destId))
            {
                llSay(0, "Could not parse key " + destination);
                return DateTime.Now;
            }

            // move the first object found with this inventory name
            lock (m_host.TaskInventory)
            {
                foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
                {
                    if (inv.Value.Name == inventory)
                    {
                        found = true;
                        objId = inv.Key;
                        assetType = inv.Value.Type;
                        objName = inv.Value.Name;
                        break;
                    }
                }
            }

            if (!found)
            {
                llSay(0, String.Format("Could not find object '{0}'", inventory));
                throw new Exception(String.Format("The inventory object '{0}' could not be found", inventory));
            }

            GridUserInfo info = m_host.ParentGroup.Scene.GridUserService.GetGridUserInfo(destId.ToString());

            // check if destination is an avatar
            if ((info != null && info.Online) || World.GetScenePresence(destId) != null)
            {
                // destination is an avatar
                InventoryItemBase agentItem = null;
                ILLClientInventory inventoryModule = World.RequestModuleInterface<ILLClientInventory>();
                if(inventoryModule != null)
                    agentItem = inventoryModule.MoveTaskInventoryItemToUserInventory(destId, UUID.Zero, m_host, objId);

                if (agentItem == null)
                    return DateTime.Now;

                byte[] bucket = new byte[17];
                bucket[0] = (byte)assetType;
                byte[] objBytes = agentItem.ID.GetBytes();
                Array.Copy(objBytes, 0, bucket, 1, 16);

                OpenSim.Framework.Console.MainConsole.Instance.Output("Giving inventory to " + destId + " from " + m_host.Name, "None");
                GridInstantMessage msg = new GridInstantMessage(World,
                        m_host.UUID, m_host.Name+", an object owned by "+
                        resolveName(m_host.OwnerID)+",", destId,
                        (byte)InstantMessageDialog.InventoryOffered,
                        false, objName+"'\n'"+m_host.Name+"' is located at "+
                        m_host.AbsolutePosition.ToString() + " in '" + World.RegionInfo.RegionName,
                        agentItem.ID, true, m_host.AbsolutePosition,
                        bucket);

                if (m_TransferModule != null)
                    m_TransferModule.SendInstantMessage(msg);
            }
            else
            {
                // destination is an object
                ILLClientInventory inventoryModule = World.RequestModuleInterface<ILLClientInventory>();
                if (inventoryModule != null)
                    inventoryModule.MoveTaskInventoryItemToObject(destId, m_host, objId);
            }
            return PScriptSleep(3000);
        }

        public void OnStartLure(byte lureType, string message, UUID targetid, IClientAPI client)
        {
            IScenePresence presence = client.Scene.GetScenePresence(client.AgentId);
            Vector3 position = presence.AbsolutePosition + new Vector3(2, 0, 0)*presence.Rotation;
            UUID dest = Util.BuildFakeParcelID(
                client.Scene.RegionInfo.RegionHandle,
                (uint) position.X,
                (uint) position.Y,
                (uint) position.Z);

            GridInstantMessage m = new GridInstantMessage()
                {
                    FromAgentID = client.AgentId,
                    FromAgentName = client.Name,
                    ToAgentID = targetid,
                    Dialog = (byte)InstantMessageDialog.RequestTeleport,
                    Message = "",
                    SessionID = dest,
                    Offline = 0,
                    Position = presence.AbsolutePosition,
                    BinaryBucket = new Byte[0],
                    RegionID = client.Scene.RegionInfo.RegionID
                };

            if (m_allowGodTeleports && client.Scene.Permissions.CanGodTeleport(client.AgentId, targetid))
            //if we are an admin and are in god mode
            {
                //God tp them
                m.Dialog = (byte)InstantMessageDialog.GodLikeRequestTeleport;
            }

            if (m_TransferModule != null)
                m_TransferModule.SendInstantMessage(m);
        }

        private void OnGridInstantMessage(GridInstantMessage im)
        {
            if (im.Dialog == (byte) InstantMessageDialog.RequestTeleport)
            {
                MainConsole.Instance.DebugFormat(
                    "[HG LURE MODULE]: RequestTeleport sessionID={0}, regionID={1}, message={2}", im.SessionID,
                    im.RegionID, im.Message);

                // Forward. We do this, because the IM module explicitly rejects
                // IMs of this type
                if (m_TransferModule != null)
                    m_TransferModule.SendInstantMessage(im);
            }
        }

 public void SendInstantMessage(GridInstantMessage im)
 {
     IMessageTransferModule m_TransferModule =
         m_object.Scene.RequestModuleInterface<IMessageTransferModule>();
     if (m_TransferModule != null)
         m_TransferModule.SendInstantMessage(im);
 }

        /// <summary>
        /// Remove the member from this session
        /// </summary>
        /// <param name="client"></param>
        /// <param name="im"></param>
        public void DropMemberFromSession(IClientAPI client, GridInstantMessage im)
        {
            ChatSession session;
            ChatSessions.TryGetValue(im.imSessionID, out session);
            if (session == null)
                return;
            ChatSessionMember member = new ChatSessionMember() { AvatarKey = UUID.Zero };
            foreach (ChatSessionMember testmember in session.Members)
            {
                if (member.AvatarKey == im.fromAgentID)
                    member = testmember;
            }

            if (member.AvatarKey != UUID.Zero)
                session.Members.Remove(member);

            if (session.Members.Count == 0)
            {
                ChatSessions.Remove(session.SessionID);
                return;
            }

            OpenMetaverse.Messages.Linden.ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock block = new OpenMetaverse.Messages.Linden.ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock();
            block.AgentID = member.AvatarKey;
            block.CanVoiceChat = member.CanVoiceChat;
            block.IsModerator = member.IsModerator;
            block.MuteText = member.MuteText;
            block.MuteVoice = member.MuteVoice;
            block.Transition = "LEAVE";
            IEventQueueService eq = client.Scene.RequestModuleInterface<IEventQueueService>();
            foreach (ChatSessionMember sessionMember in session.Members)
            {
                eq.ChatterBoxSessionAgentListUpdates(session.SessionID, new OpenMetaverse.Messages.Linden.ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock[] { block }, sessionMember.AvatarKey, "LEAVE", findScene(sessionMember.AvatarKey).RegionInfo.RegionHandle);
            }
        }

        /// <summary>
        ///     This deals with sending the return IMs as well as actually returning the objects
        /// </summary>
        protected internal void CheckFrameEvents()
        {
            // Go through all updates and check for temp and auto return
            CheckPrimForAutoReturn();
            CheckPrimForTemperary();
            lock (m_returns)
            {
                foreach (KeyValuePair<UUID, ReturnInfo> ret in m_returns)
                {
                    if (ret.Value.reason != "")
                    {
                        UUID transaction = UUID.Random();

                        GridInstantMessage msg = new GridInstantMessage
                                                     {
                                                         fromAgentID = UUID.Zero,
                                                         toAgentID = ret.Key,
                                                         imSessionID = transaction,
                                                         timestamp = (uint) Util.UnixTimeSinceEpoch(),
                                                         fromAgentName = "Server",
                                                         dialog = 19,
                                                         fromGroup = false,
                                                         offline = 1,
                                                         ParentEstateID =
                                                             m_scene.RegionInfo.EstateSettings.ParentEstateID,
                                                         Position = Vector3.Zero,
                                                         RegionID = m_scene.RegionInfo.RegionID,
                                                         binaryBucket = Util.StringToBytes256("\0")
                                                     };
                        // From server
                        // Object msg
                        // We must fill in a null-terminated 'empty' string here since bytes[0] will crash viewer 3.

                        if (ret.Value.count > 1)
                            msg.message =
                                string.Format("Your {0} objects were returned from {1} in region {2} due to {3}",
                                              ret.Value.count, ret.Value.location.ToString(),
                                              m_scene.RegionInfo.RegionName, ret.Value.reason);
                        else
                            msg.message = string.Format(
                                "Your object {0} was returned from {1} in region {2} due to {3}", ret.Value.objectName,
                                ret.Value.location.ToString(), m_scene.RegionInfo.RegionName, ret.Value.reason);

                        IMessageTransferModule tr = m_scene.RequestModuleInterface<IMessageTransferModule>();
                        if (tr != null)
                            tr.SendInstantMessage(msg);

                        if (ret.Value.Groups.Count > 1)
                            MainConsole.Instance.InfoFormat(
                                "[LandManagement]: Returning {0} objects due to parcel auto return.",
                                ret.Value.Groups.Count);
                        else
                            MainConsole.Instance.Info("[LandManagement]: Returning 1 object due to parcel auto return.");
                    }
                    IAsyncSceneObjectGroupDeleter asyncDelete =
                        m_scene.RequestModuleInterface<IAsyncSceneObjectGroupDeleter>();
                    if (asyncDelete != null)
                    {
                        asyncDelete.DeleteToInventory(
                            DeRezAction.Return, ret.Value.Groups[0].RootChild.OwnerID, ret.Value.Groups,
                            ret.Value.Groups[0].RootChild.OwnerID,
                            true, true);
                    }
                }
                m_returns.Clear();
            }
        }

        private void OnInstantMessage(IClientAPI client, GridInstantMessage im)
        {
            if ((InstantMessageDialog)im.dialog == InstantMessageDialog.FriendshipOffered)
            { 
                // we got a friendship offer
                UUID principalID = im.fromAgentID;
                UUID friendID = im.toAgentID;

                //Can't trust the incoming name for friend offers, so we have to find it ourselves.
                UserAccount sender = m_Scenes[0].UserAccountService.GetUserAccount(UUID.Zero, principalID);
                im.fromAgentName = sender.Name;
                UserAccount reciever = m_Scenes[0].UserAccountService.GetUserAccount(UUID.Zero, friendID);

                m_log.DebugFormat("[FRIENDS]: {0} offered friendship to {1}", sender.Name, reciever.Name);
                // This user wants to be friends with the other user.
                // Let's add the relation backwards, in case the other is not online
                FriendsService.StoreFriend(friendID, principalID.ToString(), 0);

                // Now let's ask the other user to be friends with this user
                ForwardFriendshipOffer(principalID, friendID, im);
            }
        }

 private void OnGridInstantMessage(GridInstantMessage msg)
 {
     OnInstantMessage(findScenePresence(msg.toAgentID).ControllingClient, msg);
 }