text:
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Timers;
using log4net;
using Mono.Addins;
using Nini.Config;
using OpenMetaverse;
using OpenMetaverse.StructuredData;
using OpenSim.Framework;
using OpenSim.Framework.Communications;
using OpenSim.Region.Framework.Interfaces;
using OpenSim.Region.Framework.Scenes;
using OpenSim.Services.Interfaces;
using System.Text;
using DirFindFlags = OpenMetaverse.DirectoryManager.DirFindFlags;

namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
{
    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "GroupsModule")]
    public class GroupsModule : ISharedRegionModule, IGroupsModule
    {
        /// <summary>
        /// ; To use this module, you must specify the following in your OpenSim.ini
        /// [GROUPS]
        /// Enabled = true
        ///
        /// Module   = GroupsModule
        /// NoticesEnabled = true
        /// DebugEnabled   = true
        ///
        /// GroupsServicesConnectorModule = XmlRpcGroupsServicesConnector
        /// XmlRpcServiceURL      = http://osflotsam.org/xmlrpc.php
        /// XmlRpcServiceReadKey  = 1234
        /// XmlRpcServiceWriteKey = 1234
        ///
        /// MessagingModule  = GroupsMessagingModule
        /// MessagingEnabled = true
        ///
        /// ; Disables HTTP Keep-Alive for Groups Module HTTP Requests, work around for
        /// ; a problem discovered on some Windows based region servers.  Only disable
        /// ; if you see a large number (dozens) of the following Exceptions:
        /// ; System.Net.WebException: The request was aborted: The request was canceled.
        ///
        /// XmlRpcDisableKeepAlive = false
        /// </summary>

        private static readonly ILog m_log =
            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);

        private List<Scene> m_sceneList = new List<Scene>();

        private IMessageTransferModule m_msgTransferModule;

        private IGroupsMessagingModule m_groupsMessagingModule;

        private IGroupsServicesConnector m_groupData;

        // Configuration settings
        private bool m_groupsEnabled = false;
        private bool m_groupNoticesEnabled = true;
        private bool m_debugEnabled = false;
        private int  m_levelGroupCreate = 0;

        #region Region Module interfaceBase Members

        public void Initialise(IConfigSource config)
        {
            IConfig groupsConfig = config.Configs["Groups"];

            if (groupsConfig == null)
            {
                // Do not run this module by default.
                return;
            }
            else
            {
                m_groupsEnabled = groupsConfig.GetBoolean("Enabled", false);
                if (!m_groupsEnabled)
                {
                    return;
                }

                if (groupsConfig.GetString("Module", "Default") != Name)
                {
                    m_groupsEnabled = false;

                    return;
                }

                m_log.InfoFormat("[GROUPS]: Initializing {0}", this.Name);

                m_groupNoticesEnabled   = groupsConfig.GetBoolean("NoticesEnabled", true);
                m_debugEnabled          = groupsConfig.GetBoolean("DebugEnabled", false);
                m_levelGroupCreate      = groupsConfig.GetInt("LevelGroupCreate", 0);
            }
        }

        public void AddRegion(Scene scene)
        {
            if (m_groupsEnabled)
            {
                scene.RegisterModuleInterface<IGroupsModule>(this);
                scene.AddCommand(
                    "Debug",
                    this,
                    "debug groups verbose",
                    "debug groups verbose <true|false>",
                    "This setting turns on very verbose groups debugging",
                    HandleDebugGroupsVerbose);
            }
        }

        private void HandleDebugGroupsVerbose(object modules, string[] args)
        {
            if (args.Length < 4)
            {
                MainConsole.Instance.Output("Usage: debug groups verbose <true|false>");
                return;
            }

            bool verbose = false;
            if (!bool.TryParse(args[3], out verbose))
            {
                MainConsole.Instance.Output("Usage: debug groups verbose <true|false>");
                return;
            }

            m_debugEnabled = verbose;

            MainConsole.Instance.OutputFormat("{0} verbose logging set to {1}", Name, m_debugEnabled);
        }

        public void RegionLoaded(Scene scene)
        {
            if (!m_groupsEnabled)
                return;

            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            if (m_groupData == null)
            {
                m_groupData = scene.RequestModuleInterface<IGroupsServicesConnector>();

                // No Groups Service Connector, then nothing works...
                if (m_groupData == null)
                {
                    m_groupsEnabled = false;
                    m_log.Error("[GROUPS]: Could not get IGroupsServicesConnector");
                    Close();
                    return;
                }
            }

            if (m_msgTransferModule == null)
            {
                m_msgTransferModule = scene.RequestModuleInterface<IMessageTransferModule>();

                // No message transfer module, no notices, group invites, rejects, ejects, etc
                if (m_msgTransferModule == null)
                {
                    m_groupsEnabled = false;
                    m_log.Warn("[GROUPS]: Could not get IMessageTransferModule");
                }
            }

            if (m_groupsMessagingModule == null)
            {
                m_groupsMessagingModule = scene.RequestModuleInterface<IGroupsMessagingModule>();

                // No message transfer module, no notices, group invites, rejects, ejects, etc
                if (m_groupsMessagingModule == null)
                    m_log.Warn("[GROUPS]: Could not get IGroupsMessagingModule");
            }

            lock (m_sceneList)
            {
                m_sceneList.Add(scene);
            }

            scene.EventManager.OnNewClient += OnNewClient;
            scene.EventManager.OnIncomingInstantMessage += OnGridInstantMessage;
            // The InstantMessageModule itself doesn't do this,
            // so lets see if things explode if we don't do it
            // scene.EventManager.OnClientClosed += OnClientClosed;

        }

        public void RemoveRegion(Scene scene)
        {
            if (!m_groupsEnabled)
                return;

            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            lock (m_sceneList)
            {
                m_sceneList.Remove(scene);
            }
        }

        public void Close()
        {
            if (!m_groupsEnabled)
                return;

            if (m_debugEnabled) m_log.Debug("[GROUPS]: Shutting down Groups module.");
        }

        public Type ReplaceableInterface
        {
            get { return null; }
        }

        public string Name
        {
            get { return "GroupsModule"; }
        }

        #endregion

        #region ISharedRegionModule Members

        public void PostInitialise()
        {
            // NoOp
        }

        #endregion

        #region EventHandlers
        private void OnNewClient(IClientAPI client)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            client.OnUUIDGroupNameRequest += HandleUUIDGroupNameRequest;
            client.OnAgentDataUpdateRequest += OnAgentDataUpdateRequest;
            client.OnRequestAvatarProperties += OnRequestAvatarProperties;

            // Used for Notices and Group Invites/Accept/Reject
            client.OnInstantMessage += OnInstantMessage;

            // Send client their groups information.
            SendAgentGroupDataUpdate(client, client.AgentId);
        }

        private void OnRequestAvatarProperties(IClientAPI remoteClient, UUID avatarID)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            //GroupMembershipData[] avatarGroups = m_groupData.GetAgentGroupMemberships(GetRequestingAgentID(remoteClient), avatarID).ToArray();
            GroupMembershipData[] avatarGroups = GetProfileListedGroupMemberships(remoteClient, avatarID);
            remoteClient.SendAvatarGroupsReply(avatarID, avatarGroups);
        }

        /*
         * This becomes very problematic in a shared module.  In a shared module you may have more then one
         * reference to IClientAPI's, one for 0 or 1 root connections, and 0 or more child connections.
         * The OnClientClosed event does not provide anything to indicate which one of those should be closed
         * nor does it provide what scene it was from so that the specific reference can be looked up.
         * The InstantMessageModule.cs does not currently worry about unregistering the handles,
         * and it should be an issue, since it's the client that references us not the other way around
         * , so as long as we don't keep a reference to the client laying around, the client can still be GC'ed
        private void OnClientClosed(UUID AgentId)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            lock (m_ActiveClients)
            {
                if (m_ActiveClients.ContainsKey(AgentId))
                {
                    IClientAPI client = m_ActiveClients[AgentId];
                    client.OnUUIDGroupNameRequest -= HandleUUIDGroupNameRequest;
                    client.OnAgentDataUpdateRequest -= OnAgentDataUpdateRequest;
                    client.OnDirFindQuery -= OnDirFindQuery;
                    client.OnInstantMessage -= OnInstantMessage;

                    m_ActiveClients.Remove(AgentId);
                }
                else
                {
                    if (m_debugEnabled) m_log.WarnFormat("[GROUPS]: Client closed that wasn't registered here.");
                }

            }
        }
        */

        private void OnAgentDataUpdateRequest(IClientAPI remoteClient, UUID dataForAgentID, UUID sessionID)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            UUID activeGroupID = UUID.Zero;
            string activeGroupTitle = string.Empty;
            string activeGroupName = string.Empty;
            ulong activeGroupPowers  = (ulong)GroupPowers.None;

            GroupMembershipData membership = m_groupData.GetAgentActiveMembership(GetRequestingAgentID(remoteClient), dataForAgentID);
            if (membership != null)
            {
                activeGroupID = membership.GroupID;
                activeGroupTitle = membership.GroupTitle;
                activeGroupPowers = membership.GroupPowers;
            }

            SendAgentDataUpdate(remoteClient, dataForAgentID, activeGroupID, activeGroupName, activeGroupPowers, activeGroupTitle);

            SendScenePresenceUpdate(dataForAgentID, activeGroupTitle);
        }

        private void HandleUUIDGroupNameRequest(UUID GroupID, IClientAPI remoteClient)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            string GroupName;

            GroupRecord group = m_groupData.GetGroupRecord(GetRequestingAgentID(remoteClient), GroupID, null);
            if (group != null)
            {
                GroupName = group.GroupName;
            }
            else
            {
                GroupName = "Unknown";
            }

            remoteClient.SendGroupNameReply(GroupID, GroupName);
        }

        private void OnInstantMessage(IClientAPI remoteClient, GridInstantMessage im)
        {
            if (m_debugEnabled)
                m_log.DebugFormat(
                    "[GROUPS]: {0} called for {1}, message type {2}",
                    System.Reflection.MethodBase.GetCurrentMethod().Name, remoteClient.Name, (InstantMessageDialog)im.dialog);

            // Group invitations
            if ((im.dialog == (byte)InstantMessageDialog.GroupInvitationAccept) || (im.dialog == (byte)InstantMessageDialog.GroupInvitationDecline))
            {
                UUID inviteID = new UUID(im.imSessionID);
                GroupInviteInfo inviteInfo = m_groupData.GetAgentToGroupInvite(GetRequestingAgentID(remoteClient), inviteID);

                if (inviteInfo == null)
                {
                    if (m_debugEnabled) m_log.WarnFormat("[GROUPS]: Received an Invite IM for an invite that does not exist {0}.", inviteID);
                    return;
                }

                if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: Invite is for Agent {0} to Group {1}.", inviteInfo.AgentID, inviteInfo.GroupID);

                UUID fromAgentID = new UUID(im.fromAgentID);
                if ((inviteInfo != null) && (fromAgentID == inviteInfo.AgentID))
                {
                    // Accept
                    if (im.dialog == (byte)InstantMessageDialog.GroupInvitationAccept)
                    {
                        if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: Received an accept invite notice.");

                        // and the sessionid is the role
                        m_groupData.AddAgentToGroup(GetRequestingAgentID(remoteClient), inviteInfo.AgentID, inviteInfo.GroupID, inviteInfo.RoleID);

                        GridInstantMessage msg = new GridInstantMessage();
                        msg.imSessionID = UUID.Zero.Guid;
                        msg.fromAgentID = UUID.Zero.Guid;
                        msg.toAgentID = inviteInfo.AgentID.Guid;
                        msg.timestamp = (uint)Util.UnixTimeSinceEpoch();
                        msg.fromAgentName = "Groups";
                        msg.message = string.Format("You have been added to the group.");
                        msg.dialog = (byte)OpenMetaverse.InstantMessageDialog.MessageBox;
                        msg.fromGroup = false;
                        msg.offline = (byte)0;
                        msg.ParentEstateID = 0;
                        msg.Position = Vector3.Zero;
                        msg.RegionID = UUID.Zero.Guid;
                        msg.binaryBucket = new byte[0];

                        OutgoingInstantMessage(msg, inviteInfo.AgentID);

                        UpdateAllClientsWithGroupInfo(inviteInfo.AgentID);

                        // TODO: If the inviter is still online, they need an agent dataupdate
                        // and maybe group membership updates for the invitee

                        m_groupData.RemoveAgentToGroupInvite(GetRequestingAgentID(remoteClient), inviteID);
                    }

                    // Reject
                    if (im.dialog == (byte)InstantMessageDialog.GroupInvitationDecline)
                    {
                        if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: Received a reject invite notice.");
                        m_groupData.RemoveAgentToGroupInvite(GetRequestingAgentID(remoteClient), inviteID);
                    }
                }
            }

            // Group notices
            if ((im.dialog == (byte)InstantMessageDialog.GroupNotice))
            {
                if (!m_groupNoticesEnabled)
                {
                    return;
                }

                UUID GroupID = new UUID(im.toAgentID);
                if (m_groupData.GetGroupRecord(GetRequestingAgentID(remoteClient), GroupID, null) != null)
                {
                    UUID NoticeID = UUID.Random();
                    string Subject = im.message.Substring(0, im.message.IndexOf('|'));
                    string Message = im.message.Substring(Subject.Length + 1);

                    InventoryItemBase item = null;
                    bool hasAttachment = false;
                    UUID itemID = UUID.Zero;    //Assignment to quiet compiler
                    UUID ownerID = UUID.Zero;   //Assignment to quiet compiler
                    byte[] bucket;

                    if (im.binaryBucket.Length >= 1 && im.binaryBucket[0] > 0)
                    {
                        string binBucket = OpenMetaverse.Utils.BytesToString(im.binaryBucket);
                        binBucket = binBucket.Remove(0, 14).Trim();

                        OSDMap binBucketOSD = (OSDMap)OSDParser.DeserializeLLSDXml(binBucket);
                        if (binBucketOSD is OSD)
                        {
                            OSDMap binBucketMap = (OSDMap)binBucketOSD;

                            itemID = binBucketMap["item_id"].AsUUID();
                            ownerID = binBucketMap["owner_id"].AsUUID();

                            //Attempt to get the details of the attached item.
                            //If sender doesn't own the attachment, the item
                            //variable will be set to null and attachment will
                            //not be included with the group notice.
                            Scene scene = (Scene)remoteClient.Scene;
                            item = new InventoryItemBase(itemID, ownerID);
                            item = scene.InventoryService.GetItem(item);

                            if (item != null)
                            {
                                //Got item details so include the attachment.
                                hasAttachment = true;
                            }
                        }
                        else
                        {
                            m_log.DebugFormat("[Groups]: Received OSD with unexpected type: {0}", binBucketOSD.GetType());
                        }
                    }

                    if (hasAttachment)
                    {
                        //Bucket contains information about attachment.
                        //
                        //Byte offset and description of bucket data:
                        //0:  1 byte indicating if attachment is present
                        //1:  1 byte indicating the type of attachment
                        //2:  16 bytes - Group UUID
                        //18: 16 bytes - UUID of the attachment owner
                        //34: 16 bytes - UUID of the attachment
                        //50: variable - Name of the attachment
                        //??: NUL byte to terminate the attachment name
                        byte[] name = Encoding.UTF8.GetBytes(item.Name);
                        bucket = new byte[51 + name.Length];//3 bytes, 3 UUIDs, and name
                        bucket[0] = 1;                      //Has attachment flag
                        bucket[1] = (byte)item.InvType;     //Type of Attachment
                        GroupID.ToBytes(bucket, 2);
                        ownerID.ToBytes(bucket, 18);
                        itemID.ToBytes(bucket, 34);
                        name.CopyTo(bucket, 50);
                    }
                    else
                    {
                        bucket = new byte[19];
                        bucket[0] = 0;  //Has attachment flag
                        bucket[1] = 0;  //Type of attachment
                        GroupID.ToBytes(bucket, 2);
                        bucket[18] = 0; //NUL terminate name of attachment
                    }

                    m_groupData.AddGroupNotice(GetRequestingAgentID(remoteClient), GroupID, NoticeID, im.fromAgentName, Subject, Message, bucket);
                    if (OnNewGroupNotice != null)
                    {
                        OnNewGroupNotice(GroupID, NoticeID);
                    }

                    if (m_debugEnabled)
                    {
                        foreach (GroupMembersData member in m_groupData.GetGroupMembers(GetRequestingAgentID(remoteClient), GroupID))
                        {
                            if (m_debugEnabled)
                            {
                                UserAccount targetUser
                                    = m_sceneList[0].UserAccountService.GetUserAccount(
                                        remoteClient.Scene.RegionInfo.ScopeID, member.AgentID);

                                if (targetUser != null)
                                {
                                    m_log.DebugFormat(
                                        "[GROUPS]: Prepping group notice {0} for agent: {1} who Accepts Notices ({2})",
                                        NoticeID, targetUser.FirstName + " " + targetUser.LastName, member.AcceptNotices);
                                }
                                else
                                {
                                    m_log.DebugFormat(
                                        "[GROUPS]: Prepping group notice {0} for agent: {1} who Accepts Notices ({2})",
                                        NoticeID, member.AgentID, member.AcceptNotices);
                                }
                            }
                        }
                    }

                    GridInstantMessage msg
                        = CreateGroupNoticeIM(UUID.Zero, NoticeID, (byte)OpenMetaverse.InstantMessageDialog.GroupNotice);

                    if (m_groupsMessagingModule != null)
                        m_groupsMessagingModule.SendMessageToGroup(
                            msg, GroupID, remoteClient.AgentId, gmd => gmd.AcceptNotices);
                }
            }

            if (im.dialog == (byte)InstantMessageDialog.GroupNoticeInventoryAccepted)
            {
                //Is bucket large enough to hold UUID of the attachment?
                if (im.binaryBucket.Length < 16)
                    return;

                UUID noticeID = new UUID(im.imSessionID);

                if (m_debugEnabled)
                    m_log.DebugFormat("[GROUPS]: Requesting notice {0} for {1}", noticeID, remoteClient.AgentId);

                GroupNoticeInfo notice = m_groupData.GetGroupNotice(GetRequestingAgentID(remoteClient), noticeID);
                if (notice != null)
                {
                    UUID giver = new UUID(notice.BinaryBucket, 18);
                    UUID attachmentUUID = new UUID(notice.BinaryBucket, 34);

                    if (m_debugEnabled)
                        m_log.DebugFormat("[Groups]: Giving inventory from {0} to {1}", giver, remoteClient.AgentId);

                    string message;
                    InventoryItemBase itemCopy = ((Scene)(remoteClient.Scene)).GiveInventoryItem(remoteClient.AgentId,
                        giver, attachmentUUID, out message);

                    if (itemCopy == null)
                    {
                        remoteClient.SendAgentAlertMessage(message, false);
                        return;
                    }

                    remoteClient.SendInventoryItemCreateUpdate(itemCopy, 0);
                }
                else
                {
                    if (m_debugEnabled)
                        m_log.DebugFormat(
                            "[GROUPS]: Could not find notice {0} for {1} on GroupNoticeInventoryAccepted.",
                            noticeID, remoteClient.AgentId);
                }
            }

            // Interop, received special 210 code for ejecting a group member
            // this only works within the comms servers domain, and won't work hypergrid
            // TODO:FIXME: Use a presence server of some kind to find out where the
            // client actually is, and try contacting that region directly to notify them,
            // or provide the notification via xmlrpc update queue
            if ((im.dialog == 210))
            {
                // This is sent from the region that the ejectee was ejected from
                // if it's being delivered here, then the ejectee is here
                // so we need to send local updates to the agent.

                UUID ejecteeID = new UUID(im.toAgentID);

                im.dialog = (byte)InstantMessageDialog.MessageFromAgent;
                OutgoingInstantMessage(im, ejecteeID);

                IClientAPI ejectee = GetActiveClient(ejecteeID);
                if (ejectee != null)
                {
                    UUID groupID = new UUID(im.imSessionID);
                    ejectee.SendAgentDropGroup(groupID);
                }
            }
        }

        private void OnGridInstantMessage(GridInstantMessage msg)
        {
            if (m_debugEnabled) m_log.InfoFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            // Trigger the above event handler
            OnInstantMessage(null, msg);

            // If a message from a group arrives here, it may need to be forwarded to a local client
            if (msg.fromGroup == true)
            {
                switch (msg.dialog)
                {
                    case (byte)InstantMessageDialog.GroupInvitation:
                    case (byte)InstantMessageDialog.GroupNotice:
                        UUID toAgentID = new UUID(msg.toAgentID);
                        IClientAPI localClient = GetActiveClient(toAgentID);
                        if (localClient != null)
                        {
                            localClient.SendInstantMessage(msg);
                        }
                        break;
                }
            }
        }

        #endregion

        #region IGroupsModule Members

        public event NewGroupNotice OnNewGroupNotice;

        public GroupRecord GetGroupRecord(UUID GroupID)
        {
            return m_groupData.GetGroupRecord(UUID.Zero, GroupID, null);
        }

        public GroupRecord GetGroupRecord(string name)
        {
            return m_groupData.GetGroupRecord(UUID.Zero, UUID.Zero, name);
        }

        public void ActivateGroup(IClientAPI remoteClient, UUID groupID)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            m_groupData.SetAgentActiveGroup(GetRequestingAgentID(remoteClient), GetRequestingAgentID(remoteClient), groupID);

            // Changing active group changes title, active powers, all kinds of things
            // anyone who is in any region that can see this client, should probably be
            // updated with new group info.  At a minimum, they should get ScenePresence
            // updated with new title.
            UpdateAllClientsWithGroupInfo(GetRequestingAgentID(remoteClient));
        }

        /// <summary>
        /// Get the Role Titles for an Agent, for a specific group
        /// </summary>
        public List<GroupTitlesData> GroupTitlesRequest(IClientAPI remoteClient, UUID groupID)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            List<GroupRolesData> agentRoles = m_groupData.GetAgentGroupRoles(GetRequestingAgentID(remoteClient), GetRequestingAgentID(remoteClient), groupID);
            GroupMembershipData agentMembership = m_groupData.GetAgentGroupMembership(GetRequestingAgentID(remoteClient), GetRequestingAgentID(remoteClient), groupID);

            List<GroupTitlesData> titles = new List<GroupTitlesData>();
            foreach (GroupRolesData role in agentRoles)
            {
                GroupTitlesData title = new GroupTitlesData();
                title.Name = role.Name;
                if (agentMembership != null)
                {
                    title.Selected = agentMembership.ActiveRole == role.RoleID;
                }
                title.UUID = role.RoleID;

                titles.Add(title);
            }

            return titles;
        }

        public List<GroupMembersData> GroupMembersRequest(IClientAPI remoteClient, UUID groupID)
        {
            if (m_debugEnabled)
                m_log.DebugFormat(
                    "[GROUPS]: GroupMembersRequest called for {0} from client {1}", groupID, remoteClient.Name);

            List<GroupMembersData> data = m_groupData.GetGroupMembers(GetRequestingAgentID(remoteClient), groupID);

            if (m_debugEnabled)
            {
                foreach (GroupMembersData member in data)
                {
                    m_log.DebugFormat("[GROUPS]: Member({0}) - IsOwner({1})", member.AgentID, member.IsOwner);
                }
            }

            return data;

        }

        public List<GroupRolesData> GroupRoleDataRequest(IClientAPI remoteClient, UUID groupID)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            List<GroupRolesData> data = m_groupData.GetGroupRoles(GetRequestingAgentID(remoteClient), groupID);

            return data;
        }

        public List<GroupRoleMembersData> GroupRoleMembersRequest(IClientAPI remoteClient, UUID groupID)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            List<GroupRoleMembersData> data = m_groupData.GetGroupRoleMembers(GetRequestingAgentID(remoteClient), groupID);

            if (m_debugEnabled)
            {
                foreach (GroupRoleMembersData member in data)
                {
                    m_log.DebugFormat("[GROUPS]: Member({0}) - Role({1})", member.MemberID, member.RoleID);
                }
            }
            return data;
        }

        public GroupProfileData GroupProfileRequest(IClientAPI remoteClient, UUID groupID)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            GroupProfileData profile = new GroupProfileData();

            GroupRecord groupInfo = m_groupData.GetGroupRecord(GetRequestingAgentID(remoteClient), groupID, null);
            if (groupInfo != null)
            {
                profile.AllowPublish = groupInfo.AllowPublish;
                profile.Charter = groupInfo.Charter;
                profile.FounderID = groupInfo.FounderID;
                profile.GroupID = groupID;
                profile.GroupMembershipCount = m_groupData.GetGroupMembers(GetRequestingAgentID(remoteClient), groupID).Count;
                profile.GroupRolesCount = m_groupData.GetGroupRoles(GetRequestingAgentID(remoteClient), groupID).Count;
                profile.InsigniaID = groupInfo.GroupPicture;
                profile.MaturePublish = groupInfo.MaturePublish;
                profile.MembershipFee = groupInfo.MembershipFee;
                profile.Money = 0; // TODO: Get this from the currency server?
                profile.Name = groupInfo.GroupName;
                profile.OpenEnrollment = groupInfo.OpenEnrollment;
                profile.OwnerRole = groupInfo.OwnerRoleID;
                profile.ShowInList = groupInfo.ShowInList;
            }

            GroupMembershipData memberInfo = m_groupData.GetAgentGroupMembership(GetRequestingAgentID(remoteClient), GetRequestingAgentID(remoteClient), groupID);
            if (memberInfo != null)
            {
                profile.MemberTitle = memberInfo.GroupTitle;
                profile.PowersMask = memberInfo.GroupPowers;
            }

            return profile;
        }

        public GroupMembershipData[] GetMembershipData(UUID agentID)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            return m_groupData.GetAgentGroupMemberships(UUID.Zero, agentID).ToArray();
        }

        public GroupMembershipData GetMembershipData(UUID groupID, UUID agentID)
        {
            if (m_debugEnabled)
                m_log.DebugFormat(
                    "[GROUPS]: {0} called with groupID={1}, agentID={2}",
                    System.Reflection.MethodBase.GetCurrentMethod().Name, groupID, agentID);

            return m_groupData.GetAgentGroupMembership(UUID.Zero, agentID, groupID);
        }

        public void UpdateGroupInfo(IClientAPI remoteClient, UUID groupID, string charter, bool showInList, UUID insigniaID, int membershipFee, bool openEnrollment, bool allowPublish, bool maturePublish)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            // Note: Permissions checking for modification rights is handled by the Groups Server/Service
            m_groupData.UpdateGroup(GetRequestingAgentID(remoteClient), groupID, charter, showInList, insigniaID, membershipFee, openEnrollment, allowPublish, maturePublish);
        }

        public void SetGroupAcceptNotices(IClientAPI remoteClient, UUID groupID, bool acceptNotices, bool listInProfile)
        {
            // Note: Permissions checking for modification rights is handled by the Groups Server/Service
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            m_groupData.SetAgentGroupInfo(GetRequestingAgentID(remoteClient), GetRequestingAgentID(remoteClient), groupID, acceptNotices, listInProfile);
        }

        public UUID CreateGroup(IClientAPI remoteClient, string name, string charter, bool showInList, UUID insigniaID, int membershipFee, bool openEnrollment, bool allowPublish, bool maturePublish)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            if (m_groupData.GetGroupRecord(GetRequestingAgentID(remoteClient), UUID.Zero, name) != null)
            {
                remoteClient.SendCreateGroupReply(UUID.Zero, false, "A group with the same name already exists.");
                return UUID.Zero;
            }

            // check user level
            ScenePresence avatar = null;
            Scene scene = (Scene)remoteClient.Scene;
            scene.TryGetScenePresence(remoteClient.AgentId, out avatar);

            if (avatar != null)
            {
                if (avatar.UserLevel < m_levelGroupCreate)
                {
                    remoteClient.SendCreateGroupReply(UUID.Zero, false, "You have got insufficient permissions to create a group.");
                    return UUID.Zero;
                }
            }

            // check funds
            // is there is a money module present ?
            IMoneyModule money = scene.RequestModuleInterface<IMoneyModule>();
            if (money != null)
            {
                // do the transaction, that is if the agent has got sufficient funds
                if (!money.AmountCovered(remoteClient.AgentId, money.GroupCreationCharge)) {
                    remoteClient.SendCreateGroupReply(UUID.Zero, false, "You have got insufficient funds to create a group.");
                    return UUID.Zero;
                }
                money.ApplyCharge(GetRequestingAgentID(remoteClient), money.GroupCreationCharge, MoneyTransactionType.GroupCreate);
            }
            UUID groupID = m_groupData.CreateGroup(GetRequestingAgentID(remoteClient), name, charter, showInList, insigniaID, membershipFee, openEnrollment, allowPublish, maturePublish, GetRequestingAgentID(remoteClient));

            remoteClient.SendCreateGroupReply(groupID, true, "Group created successfullly");

            // Update the founder with new group information.
            SendAgentGroupDataUpdate(remoteClient, GetRequestingAgentID(remoteClient));

            return groupID;
        }

        public GroupNoticeData[] GroupNoticesListRequest(IClientAPI remoteClient, UUID groupID)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            // ToDo: check if agent is a member of group and is allowed to see notices?

            return m_groupData.GetGroupNotices(GetRequestingAgentID(remoteClient), groupID).ToArray();
        }

        /// <summary>
        /// Get the title of the agent's current role.
        /// </summary>
        public string GetGroupTitle(UUID avatarID)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            GroupMembershipData membership = m_groupData.GetAgentActiveMembership(UUID.Zero, avatarID);
            if (membership != null)
            {
                return membership.GroupTitle;
            }
            return string.Empty;
        }

        /// <summary>
        /// Change the current Active Group Role for Agent
        /// </summary>
        public void GroupTitleUpdate(IClientAPI remoteClient, UUID groupID, UUID titleRoleID)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            m_groupData.SetAgentActiveGroupRole(GetRequestingAgentID(remoteClient), GetRequestingAgentID(remoteClient), groupID, titleRoleID);

            // TODO: Not sure what all is needed here, but if the active group role change is for the group
            // the client currently has set active, then we need to do a scene presence update too
            // if (m_groupData.GetAgentActiveMembership(GetRequestingAgentID(remoteClient)).GroupID == GroupID)

            UpdateAllClientsWithGroupInfo(GetRequestingAgentID(remoteClient));
        }

        public void GroupRoleUpdate(IClientAPI remoteClient, UUID groupID, UUID roleID, string name, string description, string title, ulong powers, byte updateType)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            // Security Checks are handled in the Groups Service.

            switch ((OpenMetaverse.GroupRoleUpdate)updateType)
            {
                case OpenMetaverse.GroupRoleUpdate.Create:
                    m_groupData.AddGroupRole(GetRequestingAgentID(remoteClient), groupID, UUID.Random(), name, description, title, powers);
                    break;

                case OpenMetaverse.GroupRoleUpdate.Delete:
                    m_groupData.RemoveGroupRole(GetRequestingAgentID(remoteClient), groupID, roleID);
                    break;

                case OpenMetaverse.GroupRoleUpdate.UpdateAll:
                case OpenMetaverse.GroupRoleUpdate.UpdateData:
                case OpenMetaverse.GroupRoleUpdate.UpdatePowers:
                    if (m_debugEnabled)
                    {
                        GroupPowers gp = (GroupPowers)powers;
                        m_log.DebugFormat("[GROUPS]: Role ({0}) updated with Powers ({1}) ({2})", name, powers.ToString(), gp.ToString());
                    }
                    m_groupData.UpdateGroupRole(GetRequestingAgentID(remoteClient), groupID, roleID, name, description, title, powers);
                    break;

                case OpenMetaverse.GroupRoleUpdate.NoUpdate:
                default:
                    // No Op
                    break;

            }

            // TODO: This update really should send out updates for everyone in the role that just got changed.
            SendAgentGroupDataUpdate(remoteClient, GetRequestingAgentID(remoteClient));
        }

        public void GroupRoleChanges(IClientAPI remoteClient, UUID groupID, UUID roleID, UUID memberID, uint changes)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
            // Todo: Security check

            switch (changes)
            {
                case 0:
                    // Add
                    m_groupData.AddAgentToGroupRole(GetRequestingAgentID(remoteClient), memberID, groupID, roleID);

                    break;
                case 1:
                    // Remove
                    m_groupData.RemoveAgentFromGroupRole(GetRequestingAgentID(remoteClient), memberID, groupID, roleID);

                    break;
                default:
                    m_log.ErrorFormat("[GROUPS]: {0} does not understand changes == {1}", System.Reflection.MethodBase.GetCurrentMethod().Name, changes);
                    break;
            }

            // TODO: This update really should send out updates for everyone in the role that just got changed.
            SendAgentGroupDataUpdate(remoteClient, GetRequestingAgentID(remoteClient));
        }

        public void GroupNoticeRequest(IClientAPI remoteClient, UUID groupNoticeID)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            GroupNoticeInfo data = m_groupData.GetGroupNotice(GetRequestingAgentID(remoteClient), groupNoticeID);

            if (data != null)
            {
                GridInstantMessage msg = CreateGroupNoticeIM(remoteClient.AgentId, groupNoticeID, (byte)InstantMessageDialog.GroupNoticeRequested);

                OutgoingInstantMessage(msg, GetRequestingAgentID(remoteClient));
            }
        }

        public GridInstantMessage CreateGroupNoticeIM(UUID agentID, UUID groupNoticeID, byte dialog)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            GridInstantMessage msg = new GridInstantMessage();
            byte[] bucket;

            msg.imSessionID = groupNoticeID.Guid;
            msg.toAgentID = agentID.Guid;
            msg.dialog = dialog;
            msg.fromGroup = true;
            msg.offline = (byte)0;
            msg.ParentEstateID = 0;
            msg.Position = Vector3.Zero;
            msg.RegionID = UUID.Zero.Guid;

            GroupNoticeInfo info = m_groupData.GetGroupNotice(agentID, groupNoticeID);
            if (info != null)
            {
                msg.fromAgentID = info.GroupID.Guid;
                msg.timestamp = info.noticeData.Timestamp;
                msg.fromAgentName = info.noticeData.FromName;
                msg.message = info.noticeData.Subject + "|" + info.Message;

                if (info.BinaryBucket[0] > 0)
                {
                    //32 is due to not needing space for two of the UUIDs.
                    //(Don't need UUID of attachment or its owner in IM)
                    //50 offset gets us to start of attachment name.
                    //We are skipping the attachment flag, type, and
                    //the three UUID fields at the start of the bucket.
                    bucket = new byte[info.BinaryBucket.Length-32];
                    bucket[0] = 1;      //Has attachment
                    bucket[1] = info.BinaryBucket[1];
                    Array.Copy(info.BinaryBucket, 50,
                               bucket, 18, info.BinaryBucket.Length-50);
                }
                else
                {
                    bucket = new byte[19];
                    bucket[0] = 0;      //No attachment
                    bucket[1] = 0;      //Attachment type
                    bucket[18] = 0;     //NUL terminate name
                }

                info.GroupID.ToBytes(bucket, 2);
                msg.binaryBucket = bucket;
            }
            else
            {
                if (m_debugEnabled)
                    m_log.DebugFormat("[GROUPS]: Group Notice {0} not found, composing empty message.", groupNoticeID);

                msg.fromAgentID = UUID.Zero.Guid;
                msg.timestamp = (uint)Util.UnixTimeSinceEpoch();
                msg.fromAgentName = string.Empty;
                msg.message = string.Empty;
                msg.binaryBucket = new byte[0];
            }

            return msg;
        }

        public void SendAgentGroupDataUpdate(IClientAPI remoteClient)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            // Send agent information about his groups
            SendAgentGroupDataUpdate(remoteClient, GetRequestingAgentID(remoteClient));
        }

        public void JoinGroupRequest(IClientAPI remoteClient, UUID groupID)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            // Should check to see if OpenEnrollment, or if there's an outstanding invitation
            m_groupData.AddAgentToGroup(GetRequestingAgentID(remoteClient), GetRequestingAgentID(remoteClient), groupID, UUID.Zero);

            remoteClient.SendJoinGroupReply(groupID, true);

            // Should this send updates to everyone in the group?
            SendAgentGroupDataUpdate(remoteClient, GetRequestingAgentID(remoteClient));
        }

        public void LeaveGroupRequest(IClientAPI remoteClient, UUID groupID)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            m_groupData.RemoveAgentFromGroup(GetRequestingAgentID(remoteClient), GetRequestingAgentID(remoteClient), groupID);

            remoteClient.SendLeaveGroupReply(groupID, true);

            remoteClient.SendAgentDropGroup(groupID);

            // SL sends out notifcations to the group messaging session that the person has left
            // Should this also update everyone who is in the group?
            SendAgentGroupDataUpdate(remoteClient, GetRequestingAgentID(remoteClient));
        }

        public void EjectGroupMemberRequest(IClientAPI remoteClient, UUID groupID, UUID ejecteeID)
        {
            EjectGroupMember(remoteClient, GetRequestingAgentID(remoteClient), groupID, ejecteeID);
        }

        public void EjectGroupMember(IClientAPI remoteClient, UUID agentID, UUID groupID, UUID ejecteeID)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            // Todo: Security check?
            m_groupData.RemoveAgentFromGroup(agentID, ejecteeID, groupID);

            string agentName;
            RegionInfo regionInfo;

            // remoteClient provided or just agentID?
            if (remoteClient != null)
            {
                agentName = remoteClient.Name;
                regionInfo = remoteClient.Scene.RegionInfo;
                remoteClient.SendEjectGroupMemberReply(agentID, groupID, true);
            }
            else
            {
                IClientAPI client = GetActiveClient(agentID);

                if (client != null)
                {
                    agentName = client.Name;
                    regionInfo = client.Scene.RegionInfo;
                    client.SendEjectGroupMemberReply(agentID, groupID, true);
                }
                else
                {
                    regionInfo = m_sceneList[0].RegionInfo;
                    UserAccount acc = m_sceneList[0].UserAccountService.GetUserAccount(regionInfo.ScopeID, agentID);

                    if (acc != null)
                    {
                        agentName = acc.FirstName + " " + acc.LastName;
                    }
                    else
                    {
                        agentName = "Unknown member";
                    }
                }
            }

            GroupRecord groupInfo = m_groupData.GetGroupRecord(agentID, groupID, null);

            UserAccount account = m_sceneList[0].UserAccountService.GetUserAccount(regionInfo.ScopeID, ejecteeID);
            if ((groupInfo == null) || (account == null))
            {
                return;
            }

            // Send Message to Ejectee
            GridInstantMessage msg = new GridInstantMessage();

            msg.imSessionID = UUID.Zero.Guid;
            msg.fromAgentID = agentID.Guid;
            // msg.fromAgentID = info.GroupID;
            msg.toAgentID = ejecteeID.Guid;
            //msg.timestamp = (uint)Util.UnixTimeSinceEpoch();
            msg.timestamp = 0;
            msg.fromAgentName = agentName;
            msg.message = string.Format("You have been ejected from '{1}' by {0}.", agentName, groupInfo.GroupName);
            msg.dialog = (byte)OpenMetaverse.InstantMessageDialog.MessageFromAgent;
            msg.fromGroup = false;
            msg.offline = (byte)0;
            msg.ParentEstateID = 0;
            msg.Position = Vector3.Zero;
            msg.RegionID = regionInfo.RegionID.Guid;
            msg.binaryBucket = new byte[0];
            OutgoingInstantMessage(msg, ejecteeID);

            // Message to ejector
            // Interop, received special 210 code for ejecting a group member
            // this only works within the comms servers domain, and won't work hypergrid
            // TODO:FIXME: Use a presence server of some kind to find out where the
            // client actually is, and try contacting that region directly to notify them,
            // or provide the notification via xmlrpc update queue

            msg = new GridInstantMessage();
            msg.imSessionID = UUID.Zero.Guid;
            msg.fromAgentID = agentID.Guid;
            msg.toAgentID = agentID.Guid;
            msg.timestamp = 0;
            msg.fromAgentName = agentName;
            if (account != null)
            {
                msg.message = string.Format("{2} has been ejected from '{1}' by {0}.", agentName, groupInfo.GroupName, account.FirstName + " " + account.LastName);
            }
            else
            {
                msg.message = string.Format("{2} has been ejected from '{1}' by {0}.", agentName, groupInfo.GroupName, "Unknown member");
            }
            msg.dialog = (byte)210; //interop
            msg.fromGroup = false;
            msg.offline = (byte)0;
            msg.ParentEstateID = 0;
            msg.Position = Vector3.Zero;
            msg.RegionID = regionInfo.RegionID.Guid;
            msg.binaryBucket = new byte[0];
            OutgoingInstantMessage(msg, agentID);

            // SL sends out messages to everyone in the group
            // Who all should receive updates and what should they be updated with?
            UpdateAllClientsWithGroupInfo(ejecteeID);
        }

        public void InviteGroupRequest(IClientAPI remoteClient, UUID groupID, UUID invitedAgentID, UUID roleID)
        {
            InviteGroup(remoteClient, GetRequestingAgentID(remoteClient), groupID, invitedAgentID, roleID);
        }

        public void InviteGroup(IClientAPI remoteClient, UUID agentID, UUID groupID, UUID invitedAgentID, UUID roleID)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            string agentName;
            RegionInfo regionInfo;

            // remoteClient provided or just agentID?
            if (remoteClient != null)
            {
                agentName = remoteClient.Name;
                regionInfo = remoteClient.Scene.RegionInfo;
            }
            else
            {
                IClientAPI client = GetActiveClient(agentID);

                if (client != null)
                {
                    agentName = client.Name;
                    regionInfo = client.Scene.RegionInfo;
                }
                else
                {
                    regionInfo = m_sceneList[0].RegionInfo;
                    UserAccount account = m_sceneList[0].UserAccountService.GetUserAccount(regionInfo.ScopeID, agentID);

                    if (account != null)
                    {
                        agentName = account.FirstName + " " + account.LastName;
                    }
                    else
                    {
                        agentName = "Unknown member";
                    }
                }
            }

            // Todo: Security check, probably also want to send some kind of notification
            UUID InviteID = UUID.Random();

            m_groupData.AddAgentToGroupInvite(agentID, InviteID, groupID, roleID, invitedAgentID);

            // Check to see if the invite went through, if it did not then it's possible
            // the remoteClient did not validate or did not have permission to invite.
            GroupInviteInfo inviteInfo = m_groupData.GetAgentToGroupInvite(agentID, InviteID);

            if (inviteInfo != null)
            {
                if (m_msgTransferModule != null)
                {
                    Guid inviteUUID = InviteID.Guid;

                    GridInstantMessage msg = new GridInstantMessage();

                    msg.imSessionID = inviteUUID;

                    // msg.fromAgentID = agentID.Guid;
                    msg.fromAgentID = groupID.Guid;
                    msg.toAgentID = invitedAgentID.Guid;
                    //msg.timestamp = (uint)Util.UnixTimeSinceEpoch();
                    msg.timestamp = 0;
                    msg.fromAgentName = agentName;
                    msg.message = string.Format("{0} has invited you to join a group. There is no cost to join this group.", agentName);
                    msg.dialog = (byte)OpenMetaverse.InstantMessageDialog.GroupInvitation;
                    msg.fromGroup = true;
                    msg.offline = (byte)0;
                    msg.ParentEstateID = 0;
                    msg.Position = Vector3.Zero;
                    msg.RegionID = regionInfo.RegionID.Guid;
                    msg.binaryBucket = new byte[20];

                    OutgoingInstantMessage(msg, invitedAgentID);
                }
            }
        }

        public List<DirGroupsReplyData> FindGroups(IClientAPI remoteClient, string query)
        {
            return m_groupData.FindGroups(GetRequestingAgentID(remoteClient), query);
        }

        #endregion

        #region Client/Update Tools

        /// <summary>
        /// Try to find an active IClientAPI reference for agentID giving preference to root connections
        /// </summary>
        private IClientAPI GetActiveClient(UUID agentID)
        {
            IClientAPI child = null;

            // Try root avatar first
            foreach (Scene scene in m_sceneList)
            {
                ScenePresence sp = scene.GetScenePresence(agentID);
                if (sp != null)
                {
                    if (!sp.IsChildAgent)
                    {
                        return sp.ControllingClient;
                    }
                    else
                    {
                        child = sp.ControllingClient;
                    }
                }
            }

            // If we didn't find a root, then just return whichever child we found, or null if none
            return child;
        }

        /// <summary>
        /// Send 'remoteClient' the group membership 'data' for agent 'dataForAgentID'.
        /// </summary>
        private void SendGroupMembershipInfoViaCaps(IClientAPI remoteClient, UUID dataForAgentID, GroupMembershipData[] data)
        {
            if (m_debugEnabled) m_log.InfoFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            OSDArray AgentData = new OSDArray(1);
            OSDMap AgentDataMap = new OSDMap(1);
            AgentDataMap.Add("AgentID", OSD.FromUUID(dataForAgentID));
            AgentData.Add(AgentDataMap);

            OSDArray GroupData = new OSDArray(data.Length);
            OSDArray NewGroupData = new OSDArray(data.Length);

            foreach (GroupMembershipData membership in data)
            {
                if (GetRequestingAgentID(remoteClient) != dataForAgentID)
                {
                    if (!membership.ListInProfile)
                    {
                        // If we're sending group info to remoteclient about another agent,
                        // filter out groups the other agent doesn't want to share.
                        continue;
                    }
                }

                OSDMap GroupDataMap = new OSDMap(6);
                OSDMap NewGroupDataMap = new OSDMap(1);

                GroupDataMap.Add("GroupID", OSD.FromUUID(membership.GroupID));
                GroupDataMap.Add("GroupPowers", OSD.FromULong(membership.GroupPowers));
                GroupDataMap.Add("AcceptNotices", OSD.FromBoolean(membership.AcceptNotices));
                GroupDataMap.Add("GroupInsigniaID", OSD.FromUUID(membership.GroupPicture));
                GroupDataMap.Add("Contribution", OSD.FromInteger(membership.Contribution));
                GroupDataMap.Add("GroupName", OSD.FromString(membership.GroupName));
                NewGroupDataMap.Add("ListInProfile", OSD.FromBoolean(membership.ListInProfile));

                GroupData.Add(GroupDataMap);
                NewGroupData.Add(NewGroupDataMap);
            }

            OSDMap llDataStruct = new OSDMap(3);
            llDataStruct.Add("AgentData", AgentData);
            llDataStruct.Add("GroupData", GroupData);
            llDataStruct.Add("NewGroupData", NewGroupData);

            if (m_debugEnabled)
            {
                m_log.InfoFormat("[GROUPS]: {0}", OSDParser.SerializeJsonString(llDataStruct));
            }

            IEventQueue queue = remoteClient.Scene.RequestModuleInterface<IEventQueue>();

            if (queue != null)
            {
                queue.Enqueue(queue.BuildEvent("AgentGroupDataUpdate", llDataStruct), GetRequestingAgentID(remoteClient));
            }

        }

        private void SendScenePresenceUpdate(UUID AgentID, string Title)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: Updating scene title for {0} with title: {1}", AgentID, Title);

            ScenePresence presence = null;

            foreach (Scene scene in m_sceneList)
            {
                presence = scene.GetScenePresence(AgentID);
                if (presence != null)
                {
                    if (presence.Grouptitle != Title)
                    {
                        presence.Grouptitle = Title;

                        if (! presence.IsChildAgent)
                            presence.SendAvatarDataToAllClients();
                    }
                }
            }
        }

        /// <summary>
        /// Send updates to all clients who might be interested in groups data for dataForClientID
        /// </summary>
        private void UpdateAllClientsWithGroupInfo(UUID dataForClientID)
        {
            if (m_debugEnabled) m_log.InfoFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            // TODO: Probably isn't nessesary to update every client in every scene.
            // Need to examine client updates and do only what's nessesary.
            lock (m_sceneList)
            {
                foreach (Scene scene in m_sceneList)
                {
                    scene.ForEachClient(delegate(IClientAPI client) { SendAgentGroupDataUpdate(client, dataForClientID); });
                }
            }
        }

        /// <summary>
        /// Update remoteClient with group information about dataForAgentID
        /// </summary>
        private void SendAgentGroupDataUpdate(IClientAPI remoteClient, UUID dataForAgentID)
        {
            if (m_debugEnabled) m_log.InfoFormat("[GROUPS]: {0} called for {1}", System.Reflection.MethodBase.GetCurrentMethod().Name, remoteClient.Name);

            // TODO: All the client update functions need to be reexamined because most do too much and send too much stuff

            OnAgentDataUpdateRequest(remoteClient, dataForAgentID, UUID.Zero);

            // Need to send a group membership update to the client
            // UDP version doesn't seem to behave nicely.  But we're going to send it out here
            // with an empty group membership to hopefully remove groups being displayed due
            // to the core Groups Stub
            remoteClient.SendGroupMembership(new GroupMembershipData[0]);

            GroupMembershipData[] membershipArray = GetProfileListedGroupMemberships(remoteClient, dataForAgentID);
            SendGroupMembershipInfoViaCaps(remoteClient, dataForAgentID, membershipArray);
            remoteClient.SendAvatarGroupsReply(dataForAgentID, membershipArray);

            if (remoteClient.AgentId == dataForAgentID)
                remoteClient.RefreshGroupMembership();
        }

        /// <summary>
        /// Get a list of groups memberships for the agent that are marked "ListInProfile"
        /// (unless that agent has a godLike aspect, in which case get all groups)
        /// </summary>
        /// <param name="dataForAgentID"></param>
        /// <returns></returns>
        private GroupMembershipData[] GetProfileListedGroupMemberships(IClientAPI requestingClient, UUID dataForAgentID)
        {
            List<GroupMembershipData> membershipData = m_groupData.GetAgentGroupMemberships(requestingClient.AgentId, dataForAgentID);
            GroupMembershipData[] membershipArray;

            //  cScene and property accessor 'isGod' are in support of the opertions to bypass 'hidden' group attributes for
            // those with a GodLike aspect.
            Scene cScene = (Scene)requestingClient.Scene;
            bool isGod = cScene.Permissions.IsGod(requestingClient.AgentId);

            if (isGod)
            {
                membershipArray = membershipData.ToArray();
            }
            else
            {
                if (requestingClient.AgentId != dataForAgentID)
                {
                    Predicate<GroupMembershipData> showInProfile = delegate(GroupMembershipData membership)
                    {
                        return membership.ListInProfile;
                    };

                    membershipArray = membershipData.FindAll(showInProfile).ToArray();
                }
                else
                {
                    membershipArray = membershipData.ToArray();
                }
            }

            if (m_debugEnabled)
            {
                m_log.InfoFormat("[GROUPS]: Get group membership information for {0} requested by {1}", dataForAgentID, requestingClient.AgentId);
                foreach (GroupMembershipData membership in membershipArray)
                {
                    m_log.InfoFormat("[GROUPS]: {0} :: {1} - {2} - {3}", dataForAgentID, membership.GroupName, membership.GroupTitle, membership.GroupPowers);
                }
            }

            return membershipArray;
        }

        private void SendAgentDataUpdate(IClientAPI remoteClient, UUID dataForAgentID, UUID activeGroupID, string activeGroupName, ulong activeGroupPowers, string activeGroupTitle)
        {
            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            // TODO: All the client update functions need to be reexamined because most do too much and send too much stuff
            UserAccount account = m_sceneList[0].UserAccountService.GetUserAccount(remoteClient.Scene.RegionInfo.ScopeID, dataForAgentID);
            string firstname, lastname;
            if (account != null)
            {
                firstname = account.FirstName;
                lastname = account.LastName;
            }
            else
            {
                firstname = "Unknown";
                lastname = "Unknown";
            }

            remoteClient.SendAgentDataUpdate(dataForAgentID, activeGroupID, firstname,
                    lastname, activeGroupPowers, activeGroupName,
                    activeGroupTitle);
        }

        #endregion

        #region IM Backed Processes

        private void OutgoingInstantMessage(GridInstantMessage msg, UUID msgTo)
        {
            if (m_debugEnabled) m_log.InfoFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);

            IClientAPI localClient = GetActiveClient(msgTo);
            if (localClient != null)
            {
                if (m_debugEnabled) m_log.InfoFormat("[GROUPS]: MsgTo ({0}) is local, delivering directly", localClient.Name);
                localClient.SendInstantMessage(msg);
            }
            else if (m_msgTransferModule != null)
            {
                if (m_debugEnabled) m_log.InfoFormat("[GROUPS]: MsgTo ({0}) is not local, delivering via TransferModule", msgTo);
                m_msgTransferModule.SendInstantMessage(msg, delegate(bool success) { if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: Message Sent: {0}", success?"Succeeded":"Failed"); });
            }
        }

        public void NotifyChange(UUID groupID)
        {
            // Notify all group members of a chnge in group roles and/or
            // permissions
            //
        }

        #endregion

        private UUID GetRequestingAgentID(IClientAPI client)
        {
            UUID requestingAgentID = UUID.Zero;
            if (client != null)
            {
                requestingAgentID = client.AgentId;
            }
            return requestingAgentID;
        }
    }

    public class GroupNoticeInfo
    {
        public GroupNoticeData noticeData = new GroupNoticeData();
        public UUID GroupID = UUID.Zero;
        public string Message = string.Empty;
        public byte[] BinaryBucket = new byte[0];
    }
}


80 INSTRUCTORS OF THE ESF saint François LONGCHAMP WELCOME YOU Whatever are your desires and your level, the instructors and the instructors of the ESF, in professionals of the glide, will share with you their enthusiasm and their perfect knowledge of our ski area. In the ESF, instructors are technicians and teachers of the ski with whom you will progress in complete safety. They are also ambassadors of their country, men and women of mountains, who will be eager to share with their customers much more than a lesson of ski.
See you soon in the station.
From 22/12 to 14/04 between 9 am and 5.30 pm.


text:
Fresh from the biotech pipeline—2019
Chris Morrison1
The biopharmaceutical industry's positive regulatory momentum carried on through 2019, despite an early-year government shutdown, a data manipulation scandal around a high-profile approval, and many months without permanent leadership at the FDA.
The US Food and Drug Administration (FDA) approved 53 new drugs in 2019, comprising 48 new molecular entities (NMEs) through its Center for Drug Evaluation and Research, as well as two new therapies and three new vaccines through its Center for Biologics Evaluation and Research (Fig. 1). The agency was unable to keep pace with 2018's record 59 NME approvals (although the FDA's 1,100 generic drug approvals during its fiscal year ending 30 September 2019 is a record). Nonetheless, 2019's haul of innovative medicines is well above average and the biopharmaceutical industry's regulatory successes are piling up at a breathless pace. The new cohort of drugs is also rich with novelty; more than half the class of 2019 are first-in-class therapies and vaccines.
2019 FDA approvals.
All that novelty and success came, eventually, despite a slow start to the year: 2019's first NME approvals did not come until February. This was a consequence of the longest ever US federal government shutdown, which saw key agencies, including the FDA, unfunded for 35 days. At the time, then-Commissioner Scott Gottlieb called the shutdown "one of the most significant operational challenges in FDA's recent history," as the agency's Prescription Drug User Fee Act funding — the money the FDA collects from application fees — began to dwindle.
Zolgensma approval
By the time the FDA's typical late-year approval surge was in full swing, the shutdown was a distant memory. The biopharma industry racked up 16 regulatory nods in November and December alone, including public health boons, such as Merck's breakthrough vaccine (Ervebo) for Ebola virus infection, and landmark approvals in rare diseases (erythropoietic protoporphyria and urothelial cancer), including the second ever RNA interference (RNAi) approval (Vyondys for Duchenne's muscular dystrophy) and a pair of drugs to treat sickle cell disease (Oxbryta and Adakveo).
The FDA pushed onward through some controversy, as well. Approvals — often swift ones, months ahead of even accelerated deadlines mandated by priority reviews — continued to mount, even after a data manipulation issue (see below) threatened to derail one of the year's highest-profile approvals. Slightly ahead of schedule in late May, the FDA approved Basel, Switzerland-based Novartis's Zolgensma (onasemnogene abeparvovec-xioi), an adeno-associated virus serotype 9 (AAV9) gene therapy carrying the cDNA of the human survival motor neuron (SMN) gene under the control of a cytomegalovirus-enhanced chicken β-actin hybrid promotor, for the treatment of spinal muscular atrophy (SMA) type 1 in children under two years of age.
That landmark approval came with nearly every regulatory incentive in the FDA's arsenal: fast track designation, priority review, breakthrough therapy designation and orphan drug designation. And because SMA is a rare and deadly pediatric disease for which extra development incentives have been established, Novartis was also awarded a coveted priority review voucher (PRV), which will allow it to whisk a future drug through FDA review more quickly. The approval validated the Swiss pharma's $8.7 billion acquisition of Zolgensma developer AveXis, only a year before. The gene therapy now competes against Biogen's blockbuster Spinraza (nusinersen), the first therapy approved to treat SMA, which the FDA approved in the waning moments of 2016.
But in June, Novartis reported to the FDA that preclinical data included in the drug's application may have been manipulated. Center for Biologics Evaluation and Research head Peter Marks was careful to vouch for the product, despite the anomaly, noting that "these data do not change the agency's positive assessment of the information from the human clinical trials that were conducted as part of the development program" and citing the "compelling evidence" that supported the drugs' overall risk/benefit ratio. But Novartis's awareness of — but silence about — the problem before FDA's approval and the dismissal of two senior AveXis executives in the postapproval fallout cast a cloud over one of the agency's signature 2019 drug approvals.
Second acts, second chances
Zolgensma's approval added a second AAV-delivered gene therapy, behind Spark Therapeutics' Luxturna (voretigene neparvovec-rzyl), which was approved in 2017 for certain rare inherited retinal diseases. (Spark's gene therapy prowess led to its 2019 acquisition by Basel, Switzerland-based Roche for $4.3 billion.) Indeed, in 2019 the biopharma industry made a habit of building on the breakthrough approvals of the past two years, particularly among new therapeutic modalities. These advances illustrate the FDA's growing comfort with gene therapy and other oligonucleotide-based modalities like RNA interference (RNAi).
In November, the FDA approved Alnylam Pharmaceuticals' second RNAi drug in as many years, Givlaari (givosiran), roughly three months ahead of the already tight schedule afforded by the drug's breakthrough therapy designation and priority approval application. The siRNA therapy, a once-monthly subcutaneous injection of a N-acetylgalactosamine-conjugated siRNA, targets aminolevulinic acid synthase 1 (ALAS1) messenger RNA to treat patients with the rare and potentially fatal genetic disorder acute hepatic porphyria, which can lead to sudden pain and central nervous system problems. Givlaari follows 2018's approval of Onpattro (patisiran) for hereditary transthyretin-mediated amyloidosis and is Alnylam's first approved treatment that incorporates an N-acetylgalactosamine conjugate, a sugar that helps direct the oligonucleotide to the liver and allows subcutaneous delivery.
Sarepta Therapeutics also enjoyed a second approval for a new therapeutic modality: its exon-skipping antisense oligonucleotide Vyondys 53 (golodirsen) for a subset of patients with Duchenne's muscular dystrophy (DMD) received accelerated approval in December, with a priority review and orphan drug designation (it also earned a PRV). Sarepta's Exondys 51 (eteplirsen) DMD treatment was approved by the FDA in 2016; together, Exondys 51 and Vyondys 53 can potentially treat about a fifth of patients with DMD, the company says. Each drug has a convoluted approval backstory. Exondys 51 was approved despite a negative pivotal trial, regulatory delays and conspicuous FDA in-fighting about its future (https://www.nature.com/articles/nbt.3783). Vyondys 53 is one of only a handful of this year's approvals for drugs that had been previously rejected by the regulator. Sarepta had received a complete response letter from the agency in August, after it had asked for an accelerated approval for the drug. Compared with that of Exondys 51, there was less drama in the eventual outcome: the biotech requested a formal dispute resolution process from the FDA and its Office of New Drugs reversed the original decision only months later, in December, citing the life-threatening and debilitating nature of the disease and lack of available treatments.
Not every once-denied drug had such a swift turnaround. Amgen's Evenity (romosozumab-aqqg) was approved in April to treat osteoporosis in certain patients with high risk of fracture or who cannot tolerate other drugs for the disease. The FDA had originally rejected the antibody in 2017, despite its noteworthy efficacy, because of the cardiovascular risk baggage it carries (baggage now noted with a black-box warning on the drug's label).
Evenity is a first-in-class humanized immunoglobulin G2 (IgG2) monoclonal antibody (mAb) from Amgen that inhibits sclerostin, increasing bone formation (one of four novel mAbs approved in 2019; Table 1). It is one of more than two dozen first-in-class drugs approved by the FDA during 2019, a group that includes only one other mAb, Novartis's Adakveo (crizanlizumab-tmca) treatment to reduce the frequency of painful vaso-occlusive crises in sickle cell disease.
Table 1 Biologic drug approvals in 2019
Adakveo and Oxbryta (voxelotor), a small-molecule treatment from Global Blood Therapeutics approved ten days after Adakveo in November, represent the first advances in sickle-cell disease treatment in two decades. Adakveo, which Novartis acquired when it bought its biotech partner Selexys in 2016, inhibits the cell adhesion protein P-selectin and was shown to significantly reduce patients' rates of pain crises and hospitalization days. The drug was Novartis's sixth approved in 2019 and received FDA's green light two months ahead of its priority review schedule, with breakthrough designation. Global Blood Therapeutics' Oxbryta targets the root cause of the disease, inhibiting deoxygenated sickle hemoglobin polymerization — preventing red blood cells' sickle-shaped contortions and the clumping that are its hallmarks. The FDA granted the breakthrough-designated Oxbryta an accelerated approval three months ahead of its priority review schedule. Each new sickle cell drug received orphan designation.
The first-in-class group also includes two antibody-drug conjugates (ADCs): Roche's Polivy (polatuzumab vedotin-piiq), a humanized anti-CD79b IgG1 mAb conjugated to the antimitotic agent monomethyl auristatin E via a protease-cleavable peptide linker, for diffuse large B-cell lymphoma and Astellas (Tokyo) and Seattle Genetics' Padcev (enfortumab vedotin-ejfv), a fully human mAb against nectin-4 conjugated to monomethyl auristatin via a protease-cleavable linker, for locally advanced or metastatic urothelial cancer. A third ADC was approved in late December: Daiichi Sankyo (Tokyo) and AstraZeneca (Cambridge, UK)'s Enhertu (fam-trastuzumab deruxtecan-nxki), a humanized HER-2 antibody for HER2-positive breast cancer. Polivy and Padcev utilize Seattle Genetics' ADC technologies, while Enhertu incorporates Daiichi's proprietary ADC technology. Underscoring the latter drug's potential, AstraZeneca paid the Japanese pharma $1.35 billion up front for global co-development and co-commercialization rights to Enhertu in March 2019 and is on the hook for up to $5.55 billion in future milestone payments. Notably, each of the three ADCs received accelerated approval, priority review and breakthrough designation.
One first-in-class drug was also the first of a new modality. Cablivi (caplacizumab-yhdp), from Paris-based Sanofi, was approved after a priority review in February to treat acquired thrombotic thrombocytopenic purpura, an orphan indication in which small blood vessels become clogged with blood clots. Cablivi is both the first drug to target the clotting-cascade protein von Willebrand factor and the first antibody domain fragment approved by the FDA (https://www.nature.com/articles/d41573-019-00104-w). Sanofi acquired Cablivi's developer, its biotech partner Ablynx (Ghent, Belgium), for €3.9 billion ($4.5 billion) in 2018. Cablivi represents the first drug to emerge from Ablynx's llama-derived single-variable heavy chain (VHH) domain antibody platform since the company's inception in 2001.
Non-NME approvals
It's worth highlighting that 2019's total drug approval tally may be inflated somewhat by FDA's inclusion of four contrast agents in the NME category — two for use in positron emission topography (PET) imaging (Ga-68-Dotatoc for diagnosing neuroendocrine tumors and Fluorodopa F-18 for diagnosing Parkinson's disease), one for use in eye surgery (Brilliant Blue G) and one for use in ultrasound (ExEm Foam for fallopian tube imaging). But, on the flip side, not all the year's important drug approvals involved NMEs; ground-breaking and medically important reformulations and label expansions aren't reflected in the FDA's tallies of new approvals but can have significant implications for patients. This year a trio of drugs in that category may gain substantial momentum from FDA approvals in relatively large patient populations.
The first of these has in one sense been around for nearly 50 years. Johnson & Johnson's Spravato (esketamine) nasal spray received FDA's green light in March for treatment of depression in adults who do not benefit from existing antidepressants. The FDA approved Spravato's forerunner, the intravenous anesthetic ketamine, as a racemic mixture in 1970, but the drug is a strong sedative with hallucinogenic properties and is abused recreationally. Although the regulator doesn't consider the S-enantiomer Spravato a new molecular entity, the drug's promise in treatment-resistant depression and new delivery system earned it breakthrough therapy designation. Because of the risk of sedation associated with Spravato, it must be administered in a doctor's office and its distribution is restricted under an FDA Risk Evaluation and Mitigation Strategy, but nevertheless analysts have high hopes for the drug. Spravato revenue is expected to reach nearly $1.3 billion by 2024, according to forecasting data from Evaluate.
Bagsværd, Denmark-based Novo Nordisk's Rybelsus (semaglutide) is an orally available formulation of the glucagon-like peptide-1 (GLP-1) analog that Novo sells as the once-weekly injectable Ozempic for type 2 diabetes. The FDA approved Rybelsus in September, following a priority review garnered with the use of a PRV. An oral GLP-1 drug has long been a goal of diabetes drug developers, and Rybelsus is expected to quickly become a blockbuster. Ozempic, approved in December 2017, generated $562 million in sales in the first half of 2019 alone.
In mid-December, after a priority review, the FDA approved Dublin, Ireland-based Amarin's Vascepa (icosapent ethyl) in adults with high triglycerides who are taking statins and who have either diabetes or established cardiovascular disease. Vascepa has been on the market since 2012, but was only indicated for adults with severely elevated triglycerides. The drug's new label could expand its use dramatically, lifting its revenue from just over $400 million in 2019 to an expected "multiple billions of dollars" beyond 2020, according to the company.
Regulatory incentives at work
Mass-market drugs like Vascepa are increasingly rare thanks in part to regulatory, business and scientific incentives that steer R&D dollars toward rare diseases and the often enormous clinical trial programs that are necessary to underpin approval for the kind of drugs dispensed in a primary-care setting. And so, unsurprisingly, the 2019 batch of NME approvals contained a typically large proportion of therapies for rare diseases.
The FDA approved 21 drugs with orphan drug designation in 2019. That total is down substantially from 34 the prior year, but it's also the third-most since the 1983 Orphan Drug Act created the incentive. Some rare disease therapies seemed to come in pairs, such as Oxbryta and Adakveo in sickle cell disease, or Jazz Pharmaceuticals' (Dublin, Ireland) Sunosi (solriamfetol) and Harmony Biosciences' Wakix (pitolisant) for narcolepsy. And joining Alnylam's Givlaari in the porphyria therapeutic category, Clinuvel Pharmaceuticals (Melbourne, Australia) received FDA's green light for Scenesse (afamelanotide) after a priority review in October (https://www.nature.com/articles/s41587-019-0347-0). A first-in-class orphan drug, Scenesse is a melanocortin receptor agonist that stimulates melanin production in the skin and protects people who suffer from erythropoietic protoporphyria, a version of the disease in which patients experience painful reactions to light exposure.
Also typical of the modern FDA, the agency met or exceeded its review deadline for every approval. Once again, more than half the novel drugs approved (33) received FDA's expedited six-month priority review. Of those, 15 drugs were granted Breakthrough Designation by the agency, one more than even 2018's total for the superpriority class.
Four new antibiotics were approved with Qualified Infectious Disease Pathogen designation, the same as the previous year. Among those were two first-in-class advances: Fetroja (cefiderocol), an antibiotic developed by Shionogi (Osaka, Japan) to treat complicated urinary tract infections, and the anti-tuberculosis antibiotic pretomanid from The Global Alliance for TB Drug Development. Fetroja was approved following a priority review in November; the antibiotic uses iron-mediated active transport to penetrate the cell walls of Gram-negative bacteria and may be effective against drug-resistant infections. Pretomanid's priority review wrapped up in August; the drug — taken as part of a three-drug regimen with the already approved bedaquiline and linezolid — became the second treatment approved under FDA's Limited Population Pathway for Antibacterial and Antifungal Drugs, an abbreviated development pathway established by the 21st Century Cures Act in 2016 to speed development and approval of certain anti-infectives for life-threatening diseases.
The TB Alliance received a priority review voucher alongside the approval of pretomanid, one of eight such vouchers awarded in conjunction with 2019's FDA approvals under programs to incentivize drug development in the areas of neglected tropical diseases, rare pediatric diseases, and material threat countermeasures — for example, drugs to treat diseases that might be weaponized. The TB Alliance could choose to sell its transferable voucher; the going rate is a not-too-shabby $95 million, the price AstraZeneca paid Swedish Orphan Biovitrum (Stockholm) for an unused voucher in August 2019.
Nobody plays the PRV game better than Novartis, the company that earned and redeemed the first ever PRV in 2009 (unsuccessfully; the expanded indication it sought for its autoimmune disease treatment Ilaris (canakinumab) was rejected by FDA, albeit more quickly than it otherwise would have been). In 2019 alone, Novartis was awarded two PRVs and used two others to expedite standard-length approval processes. In March, it received a PRV alongside the approval of Egaten (triclabendazole), a drug to treat the parasitic infection fascioliasis, and in May, a second PRV with the approval of Zolgensma.
In all, nine drugs received accelerated approvals based on surrogate endpoints in 2019. Though not an unusually high amount by historical standards, that's the most since 2014 and more than twice as many as in 2018.
Cancer breakthroughs
Seven of the nine drugs receiving accelerated approval were for cancer indications. In addition to the three ADC therapies from Daiichi, Roche, and Astellas, highlights included Johnson & Johnson's metastatic bladder cancer treatment Balversa (erdafitinib), a small molecule targeting fibroblast growth factor receptor, and Beijing-based BeiGene's Brukinsa (zanubrutinib) for mantle cell lymphoma, a small molecule targeting Bruton's tyrosine kinase. Both drugs are expected to become blockbusters.
Nearly all the cancer drugs receiving accelerated approval were also deemed breakthrough therapies by the regulator. From a total novel-approvals standpoint, oncology drugs led the way with 12 (compared with 18 new cancer drugs in 2018). But even if that therapeutic category did not dominate with sheer numbers as it has done in years past (Fig. 2), more than a quarter of all breakthrough therapy designation requests are for cancer drugs, and nearly a third of breakthrough designations granted by the FDA are for cancer drugs, according to data presented by Khushboo Sharma, FDA deputy director for operations in the Office of New Drugs, at CBI's FDA/CMS Summit in early December.
2019 NME approvals by therapeutic category.
Meanwhile, the agency continues to find ways to review oncology drugs more quickly. In 2019, the FDA kicked off an international effort with regulators in Australia and Canada to speed cancer drugs through a collaborative review process in the three countries. The first approval under the program, which the FDA calls Project Orbis, came in September with the accelerated approval of Tokyo-based Eisai's multi-kinase inhibitor Lenvima (lenvatinib) in combination with Merck's anti-programmed cell death 1 (PD-1) mAb Keytruda (pembrolizumab) for a subset of patients with advanced endometrial carcinoma. The drugs were individually approved by the FDA in 2015 and 2014, respectively. The combination's approval was also whisked along by the FDA's Real-Time Oncology Review process, a pilot program rolled out in 2018 by the agency's Oncology Center of Excellence.
High expectations, high prices
Fourteen of 2019's novel drug approvals are expected to become $1-billion-plus revenue-generating blockbusters by 2024, according to consensus estimates from Evaluate (Table 2). That total includes five cancer drugs. It also includes three new therapies that are expected to reach blockbuster status in only their first full year on the market. All three are orphan drugs approved with breakthrough designation, and their anticipated success reflects their impressive efficacy and safety profiles and the pent-up demand by patients and families who have had few if any therapeutic options, as well as the high costs associated with such groundbreaking treatments.
Table 2 Emerging NME blockbusters approved in 2019
The trio comprises Novartis's SMA gene therapy Zolgensma ($2.1 million per patient), Pfizer's small-molecule treatment for cardiomyopathy caused by transthyretin-mediated amyloidosis (Vyndaqel; tafamidis meglumine; $225,000 per year) and Vertex Pharmaceuticals' triple small-molecule combination cystic fibrosis drug Trikafta (elexacaftor/ivacaftor/tezacaftor; $311,000 per year). Pfizer acquired Vyndaqel through the 2010 acquisition of its biotech partner FoldRx Pharmaceuticals; the drug works by stabilizing the protein transthyretin, preventing breakdown of transthyretin tetramers and the resulting accumulation of amyloid.
No drug approved in 2019 is expected to be more lucrative than Trikafta. The FDA approved Trikafta in October, nearly five months ahead of its March 2020 Prescription Drug User Fee Act–imposed deadline for priority review, setting a new bar for review speed and underscoring the drug's importance to the cystic fibrosis community. The breakthrough orphan therapy's approval also earned Vertex a PRV. Trikafta is indicated for the roughly 90% of patients with at least one F508del mutation in the cystic fibrosis transmembrane conductance regulator (CFTR) gene. Evaluate pegs Trikafta's 2024 consensus sales estimate at nearly $5.6 billion.
Biosimilars on the march
Interestingly, AbbVie's anti-interleukin-23 (IL-23) mAb Skyrizi (risankizumab-rzaa), approved in April to treat moderate-to-severe plaque psoriasis, and Novartis's anti-vascular endothelial growth factor single-chain antibody fragment Beovu (brolucizumab-dbll), approved in October to treat wet age-related macular degeneration, are the only mAbs or antibody-derived drugs on that blockbuster roster.
This anticipated revenue may be a boon for a few companies finally feeling, or that may soon begin to feel, the effects of biosimilar competition to some of their flagship biologics. In 2019, the FDA approved 10 biosimilars, as compared with seven in 2018, a record number. Indeed, every year since the pathway was legislated into existence with the Affordable Care Act has marked a new record for the number of biosimilar approvals (Fig. 3).
It's always a record year for biosimilars.
Not all these new biologics will hit the market in a timely fashion, due to legal skirmishes that tend to fizzle into legal settlements that delay biosimilar market entry. Most notably, biosimilars for AbbVie's industry-leading Humira (adalimumab) anti-tumor necrosis factor-α autoimmune disease treatment are already taking a substantial bite out of the drug's European revenue, but will have to wait until 2023 to launch in the United States. Newly approved adalimumab entrants from Incheon, South Korea-based Samsung Bioepis (Hadlima) and Pfizer (Abrilada) have joined an increasingly non-exclusive club: there are now five FDA-approved Humira biosimilars waiting in the wings.
Although the price declines associated with the entry of biosimilars can be difficult to discern immediately — thanks in large part to the opacity of differences between list prices for medicines and the actual net prices received by manufacturers — they are real. Biosimilars to Amgen's Neupogen (filgrastim, a form of the protein granulocyte-macrophage colony-stimulating factor) began hitting the US market in 2015, but the brand drugs' list prices only flattened out or even continued to rise. Net prices, however, have fallen by an average 7.7% year-on-year ever since, according to data published by University of Pittsburgh researchers in December 2019 in JAMA Network Open (https://jamanetwork.com/journals/jamanetworkopen/fullarticle/2757480) Similar trends were seen for Neulasta (pegfilgrastim; Amgen), Remicade (infliximab; Johnson & Johnson) and Lantus (insulin glargine; Sanofi).
Meanwhile, there were enough FDA commissioners in 2019 to fully staff a barbershop quartet. MD Anderson Cancer Center's Stephen Hahn became the 24th FDA commissioner with his confirmation by the US Senate on December 17. Hahn succeeds biopharma industry favorite Scott Gottlieb, who resigned his post in April, and the two acting commissioners in between, Norman Sharpless and Brett Giroir. This leadership shuffle didn't seem to jostle the agency's progress or the tide of new drug approvals during 2019. (In fact, the trickiest aspect of the transition continuum seems to have emerged in late December, when Hahn took over Gottlieb's official FDA commissioner Twitter account, keeping the many thousands of followers but deleting his predecessor's voluminous and colorful tweet history.)
The drugs on the docket in 2020 for Hahn's FDA are sure to add fuel to the drug pricing debate — not least because several of the year's expected approval decisions involve so-far ungenericizable therapeutic modalities that take these technologies into larger patient populations, as well as a high-profile drug candidate for Alzheimer's disease.
For example, The Medicines Company said that it planned to seek approval for its RNAi therapy inclisiran, an siRNA targeting proprotein convertase subtilisin/kexin type 9 (PCSK9) mRNA for lowering low-density lipoprotein cholesterol. Novartis agreed to acquire the biotech for $9.7 billion in November — placing an extraordinary value on inclisiran, the company's only clinical-stage asset, which was originally licensed from Alnylam. Alnylam, already two for two with FDA approvals itself, announced positive phase 3 results in mid-December for lumasiran, another N-acetylgalactosamine-conjugated siRNA targeting glycolate oxidase, in the rare kidney disease primary hyperoxaluria. Assuming positive regulatory outcomes, four new RNAi therapies may reach patients in the span of barely three years.
Additional gene therapies are also on the horizon. Bluebird Bio said it would begin a rolling biologics license application (BLA), under which it can submit the application in pieces to streamline the review, by the end of 2019 for its β-thalassemia gene therapy Zynteglo (autologous CD34+ cells encoding the βA-T87Q-globin gene). The ex vivo gene therapy, which requires harvesting stem cells from a patient's bone marrow, transducing them with a fetal globin gene that will restore hemoglobin function, and injecting them back into the patient, was approved by the European Medicines Agency in 2019 (https://www.nature.com/articles/d41587-019-00026-3). And BioMarin's AAV-delivered hemophilia A gene therapy valoctocogene roxaparvovec, already submitted to the European Medicines Agency, was submitted to the FDA at the end of December.
The FDA's most consequential decision in 2020 is likely to determine the fate of Biogen and Eisai's β-amyloid human IgG1 mAb aducanumab. In March 2019 after a routine futility analysis, an independent data monitoring committee recommended halting Biogen's phase 3 aducanumab trials in mild cognitive impairment and mild Alzheimer's disease dementia because they were unlikely to succeed. At the time, the decision was widely expected to further discredit if not entirely doom the so-called amyloid hypothesis — the idea that accumulating amyloid peptides cause Alzheimer's disease and that targeting and removing that amyloid could treat the disease (https://www.nature.com/articles/d41573-019-00064-1).
But in a year that didn't lack for regulatory plot twists, aducanumab stands out. In October, Biogen announced that the decision to stop the trials was the wrong one, that an analysis of a larger dataset unavailable to the monitoring committee in March suggested the drug was working, and that it would file a BLA for aducanumab in early 2020 (https://www.nature.com/articles/s41587-019-0352-3). Analysts are divided as to whether the FDA could or should approve aducanumab. In a December video to clients, Evercore ISI analyst Umer Raffat stressed that while "there are a lot of real statistical issues with the data … I think the drug is approvable." RW Baird analyst Brian Skorney has been vocal in his criticism of the drug, arguing a new trial would be necessary to determine whether the drug works. "The preponderance of the data indicate aducanumab doesn't provide a clinical benefit," he wrote in a December note to clients. "There are so many reasons we think aducanumab is getting rejected, our word count restrictions don't allow us to put them all here," he continued, before laying out his top ten.
The FDA, of course, cannot comment, although companies can always summarize their regulatory interactions, leaving tea leaves for patients, physicians and investors to read afterwards. On a conference call with analysts in October, Biogen executives several times noted that the FDA "thought it was reasonable" for the company to submit the BLA on the basis of the drug's available data. "That was the upside of the meeting," said Al Sandrock, Biogen executive vice president of R&D and chief medical officer. 'Reasonable to submit' does not equal 'approvable', per se, but a 2020 aducanumab approval is possible. The FDA's decision — thumbs up or thumbs down — will win it both vociferous critics and defenders ready to decry or celebrate any perceived shifting of the agency's standards.
Yardley, PA, USA
Chris Morrison
Morrison, C. Fresh from the biotech pipeline—2019. Nat Biotechnol 38, 126–131 (2020). https://doi.org/10.1038/s41587-019-0405-7
Opportunities in an Evolving Pharmaceutical Development Landscape: Product Differentiation of Biopharmaceutical Drug Products
Andrea Allmendinger
Pharmaceutical Research (2021)
Simultaneous development of zanubrutinib in the USA and China
Guanqiao Li
Xiaozhen Liu
Xiaoyuan Chen
Nature Reviews Clinical Oncology (2020)
Translating academic careers into industry healthcare professions
Sinje Gehr
Craig C. Garner
Karin N. Kleinhans
Nature Biotechnology (2020)

redpajama_set_name: RedPajamaCommonCrawl