* A library to interact with Virtual Worlds such as OpenSim

* Copyright (C) 2012  Jitendra Chauhan, Email: jitendra.chauhan@gmail.com

*

* This library is free software; you can redistribute it and/or modify it under

* the terms of the GNU Lesser General Public License as published by

* the Free Software Foundation; either version 2.1 of the License,

* or (at your option) any later version.

*

* This library is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

* See the GNU Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public License

* along with this library; if not, write to the Free Software Foundation,

* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

*/

///// Handles all network traffic related to reading and writing group

///// information

///// </summary>

    //region Structs

    /// <summary>

    /// Avatar group management

    /// </summary>

    public class GroupMember

    {

        /// <summary>Key of Group Member</summary>

        public UUID ID;

        /// <summary>Total land contribution</summary>

        public int Contribution;

        /// <summary>Online status information</summary>

        public String OnlineStatus;

        /// <summary>Abilities that the Group Member has</summary>

        public EnumSet<GroupPowers> Powers;

        /// <summary>Current group title</summary>

        public String Title;

        /// <summary>Is a group owner</summary>

        public boolean IsOwner;

    }

    /// <summary>

    /// Role manager for a group

    /// </summary>

    public class GroupRole

    {

        /// <summary>Key of the group</summary>

        public UUID GroupID;

        /// <summary>Key of Role</summary>

        public UUID ID;

        /// <summary>Name of Role</summary>

        public String Name;

        /// <summary>Group Title associated with Role</summary>

        public String Title;

        /// <summary>Description of Role</summary>

        public String Description;

        /// <summary>Abilities Associated with Role</summary>

        public EnumSet<GroupPowers> Powers;

        /// <summary>Returns the role's title</summary>

        /// <returns>The role's title</returns>

        @Override

        public String toString()

        {

            return Name;

        }

    }

    /// <summary>

    /// Class to represent Group Title

    /// </summary>

    public class GroupTitle

    {

        /// <summary>Key of the group</summary>

        public UUID GroupID;

        /// <summary>ID of the role title belongs to</summary>

        public UUID RoleID;

        /// <summary>Group Title</summary>

       

        public String Title;

        /// <summary>Whether title is Active</summary>

        public boolean Selected;

        /// <summary>Returns group title</summary>

        @Override

        public String toString()

        {

            return Title;

        }

    }

    /// <summary>

    /// Represents a group on the grid

    /// </summary>

    public class Group

    {

        /// <summary>Key of Group</summary>

        public UUID ID;

        /// <summary>Key of Group Insignia</summary>

        public UUID InsigniaID;

        /// <summary>Key of Group Founder</summary>

        public UUID FounderID;

        /// <summary>Key of Group Role for Owners</summary>

        public UUID OwnerRole;

        /// <summary>Name of Group</summary>

        public String Name;

        /// <summary>Text of Group Charter</summary>

        public String Charter;

        /// <summary>Title of "everyone" role</summary>

        public String MemberTitle;

        /// <summary>Is the group open for enrolement to everyone</summary>

        public boolean OpenEnrollment;

        /// <summary>Will group show up in search</summary>

        public boolean ShowInList;

        /// <summary></summary>

        public EnumSet<GroupPowers> Powers;

        /// <summary></summary>

        public boolean AcceptNotices;

        /// <summary></summary>

        public boolean AllowPublish;

        /// <summary>Is the group Mature</summary>

        public boolean MaturePublish;

        /// <summary>Cost of group membership</summary>

        public int MembershipFee;

        /// <summary></summary>

        public int Money;

        /// <summary></summary>

        public int Contribution;

        /// <summary>The total number of current members this group has</summary>

        public int GroupMembershipCount;

        /// <summary>The number of roles this group has configured</summary>

        public int GroupRolesCount;

        /// <summary>Show this group in agent's profile</summary>

        public boolean ListInProfile;

        /// <summary>Returns the name of the group</summary>

        /// <returns>A String containing the name of the group</returns>

        @Override

        public String toString()

        {

            return Name;

        }

    }

    /// <summary>

    /// A group Vote

    /// </summary>

    public class Vote

    {

        /// <summary>Key of Avatar who created Vote</summary>

        public UUID Candidate;

        /// <summary>Text of the Vote proposal</summary>

        public String VoteString;

        /// <summary>Total number of votes</summary>

        public int NumVotes;

    }

    /// <summary>

    /// A group proposal

    /// </summary>

    public class GroupProposal

    {

        /// <summary>The Text of the proposal</summary>

        public String VoteText;

        /// <summary>The minimum number of members that must vote before proposal passes or failes</summary>

        public int Quorum;

        /// <summary>The required ration of yes/no votes required for vote to pass</summary>

        /// <remarks>The three options are Simple Majority, 2/3 Majority, and Unanimous</remarks>

        /// TODO: this should be an enum

        public float Majority;

        /// <summary>The duration in days votes are accepted</summary>

        public int Duration;

    }

    /// <summary>

    ///

    /// </summary>

    public class GroupAccountSummary

    {

        /// <summary></summary>

        public int IntervalDays;

        /// <summary></summary>

        public int CurrentInterval;

        /// <summary></summary>

        public String StartDate;

        /// <summary></summary>

        public int Balance;

        /// <summary></summary>

        public int TotalCredits;

        /// <summary></summary>

        public int TotalDebits;

        /// <summary></summary>

        public int ObjectTaxCurrent;

        /// <summary></summary>

        public int LightTaxCurrent;

        /// <summary></summary>

        public int LandTaxCurrent;

        /// <summary></summary>

        public int GroupTaxCurrent;

        /// <summary></summary>

        public int ParcelDirFeeCurrent;

        /// <summary></summary>

        public int ObjectTaxEstimate;

        /// <summary></summary>

        public int LightTaxEstimate;

        /// <summary></summary>

        public int LandTaxEstimate;

        /// <summary></summary>

        public int GroupTaxEstimate;

        /// <summary></summary>

        public int ParcelDirFeeEstimate;

        /// <summary></summary>

        public int NonExemptMembers;

        /// <summary></summary>

        public String LastTaxDate;

        /// <summary></summary>

        public String TaxDate;

    }

    /// <summary>

    /// Struct representing a group notice

    /// </summary>

    public class GroupNotice

    {

        /// <summary></summary>

        public String Subject;

        /// <summary></summary>

        public String Message;

        /// <summary></summary>

        public UUID AttachmentID;

        /// <summary></summary>

        public UUID OwnerID;

        /// <summary>

        ///

        /// </summary>

        /// <returns></returns>

        public byte[] SerializeAttachment() throws Exception

        {

            if (OwnerID == UUID.Zero || AttachmentID == UUID.Zero)

                return Utils.EmptyBytes;

            OSDMap att = new OSDMap();

            att.put("item_id", OSD.FromUUID(AttachmentID));

            att.put("owner_id", OSD.FromUUID(OwnerID));

            return XmlLLSDOSDParser.SerializeLLSDXmlBytes(att);

            /*

            //I guess this is how this works, no gaurentees

            String lsd = "<llsd><item_id>" + AttachmentID.ToString() + "</item_id><owner_id>"

                + OwnerID.ToString() + "</owner_id></llsd>";

            return Utils.stringToBytesWithTrailingNullByte(lsd);

             */

        }

    }

    /// <summary>

    /// Struct representing a group notice list entry

    /// </summary>

    public class GroupNoticesListEntry

    {

        /// <summary>Notice ID</summary>

        public UUID NoticeID;

        /// <summary>Creation timestamp of notice</summary>

        //uint

        public long Timestamp;

        /// <summary>Agent name who created notice</summary>

        public String FromName;

        /// <summary>Notice subject</summary>

        public String Subject;

        /// <summary>Is there an attachment?</summary>

        public boolean HasAttachment;

        /// <summary>Attachment Type</summary>

        public Enums.AssetType AssetType;

    }

    /// <summary>

    /// Struct representing a member of a group chat session and their settings

    /// </summary>

    public static class ChatSessionMember

    {

        /// <summary>The <see cref="UUID"/> of the Avatar</summary>

        public UUID AvatarKey;

        /// <summary>True if user has voice chat enabled</summary>

        public boolean CanVoiceChat;

        /// <summary>True of Avatar has moderator abilities</summary>

        public boolean IsModerator;

        /// <summary>True if a moderator has muted this avatars chat</summary>

        public boolean MuteText;

        /// <summary>True if a moderator has muted this avatars voice</summary>

        public boolean MuteVoice;

    }

    //endregion Structs

    //region Enums

    /// <summary>

    /// Role update flags

    /// </summary>

    public enum GroupRoleUpdate

    {

        /// <summary></summary>

        NoUpdate((long)0),

        /// <summary></summary>

        UpdateData((long)1),

        /// <summary></summary>

        UpdatePowers((long)2),

        /// <summary></summary>

        UpdateAll((long)3),

        /// <summary></summary>

        Create((long)4),

        /// <summary></summary>

        Delete((long)5);

        private long index;

        GroupRoleUpdate(long index)

    {

      this.index = index;

    }    

    public long getIndex()

    {

      return index;

    } 

    private static final Map<Long,GroupRoleUpdate> lookup  = new HashMap<Long,GroupRoleUpdate>();

    static {

      for(GroupRoleUpdate s : EnumSet.allOf(GroupRoleUpdate.class))

        lookup.put(s.getIndex(), s);

    }

    public static GroupRoleUpdate get(Long index)

    {

      return lookup.get(index);

    }

    }

    public enum GroupPowers

    {

      //ulong

        /// <summary></summary>

        None((long)0),

        // Membership

        /// <summary>Can send invitations to groups default role</summary>

        Invite((long)1L << 1),

        /// <summary>Can eject members from group</summary>

        Eject((long)1L << 2),

        /// <summary>Can toggle 'Open Enrollment' and change 'Signup fee'</summary>

        ChangeOptions((long)1L << 3),

        /// <summary>Member is visible in the public member list</summary>

        MemberVisible((long)1L << 47),

        // Roles

        /// <summary>Can create new roles</summary>

        CreateRole((long)1L << 4),

        /// <summary>Can delete existing roles</summary>

        DeleteRole((long)1L << 5),

        /// <summary>Can change Role names, titles and descriptions</summary>

        RoleProperties((long)1L << 6),

        /// <summary>Can assign other members to assigners role</summary>

        AssignMemberLimited((long)1L << 7),

        /// <summary>Can assign other members to any role</summary>

        AssignMember((long)1L << 8),

        /// <summary>Can remove members from roles</summary>

        RemoveMember((long)1L << 9),

        /// <summary>Can assign and remove abilities in roles</summary>

        ChangeActions((long)1L << 10),

        // Identity

        /// <summary>Can change group Charter, Insignia, 'Publish on the web' and which

        /// members are publicly visible in group member listings</summary>

        ChangeIdentity((long)1L << 11),

        // Parcel management

        /// <summary>Can buy land or deed land to group</summary>

        LandDeed((long)1L << 12),

        /// <summary>Can abandon group owned land to Governor Linden on mainland, or Estate owner for

        /// private estates</summary>

        LandRelease((long)1L << 13),

        /// <summary>Can set land for-sale information on group owned parcels</summary>

        LandSetSale((long)1L << 14),

        /// <summary>Can subdivide and join parcels</summary>

        LandDivideJoin((long)1L << 15),

        // Chat

        /// <summary>Can join group chat sessions</summary>

        JoinChat((long)1L << 16),

        /// <summary>Can use voice chat in Group Chat sessions</summary>

        AllowVoiceChat((long)1L << 27),

        /// <summary>Can moderate group chat sessions</summary>

        ModerateChat((long)1L << 37),

        // Parcel identity

        /// <summary>Can toggle "Show in Find Places" and set search category</summary>

        FindPlaces((long)1L << 17),

        /// <summary>Can change parcel name, description, and 'Publish on web' settings</summary>

        LandChangeIdentity((long)1L << 18),

        /// <summary>Can set the landing point and teleport routing on group land</summary>

        SetLandingPoint((long)1L << 19),

        // Parcel settings

        /// <summary>Can change music and media settings</summary>

        ChangeMedia((long)1L << 20),

        /// <summary>Can toggle 'Edit Terrain' option in Land settings</summary>

        LandEdit((long)1L << 21),

        /// <summary>Can toggle various About Land > Options settings</summary>

        LandOptions((long)1L << 22),

        // Parcel powers

        /// <summary>Can always terraform land, even if parcel settings have it turned off</summary>

        AllowEditLand((long)1L << 23),

        /// <summary>Can always fly while over group owned land</summary>

        AllowFly((long)1L << 24),

        /// <summary>Can always rez objects on group owned land</summary>

        AllowRez((long)1L << 25),

        /// <summary>Can always create landmarks for group owned parcels</summary>

        AllowLandmark((long)1L << 26),

        /// <summary>Can set home location on any group owned parcel</summary>

        AllowSetHome((long)1L << 28),

        // Parcel access

        /// <summary>Can modify public access settings for group owned parcels</summary>

        LandManageAllowed((long)1L << 29),

        /// <summary>Can manager parcel ban lists on group owned land</summary>

        LandManageBanned((long)1L << 30),

        /// <summary>Can manage pass list sales information</summary>

        LandManagePasses((long)1L << 31),

        /// <summary>Can eject and freeze other avatars on group owned land</summary>

        LandEjectAndFreeze((long)1L << 32),

        // Parcel content

        /// <summary>Can return objects set to group</summary>

        ReturnGroupSet((long)1L << 33),

        /// <summary>Can return non-group owned/set objects</summary>

        ReturnNonGroup((long)1L << 34),

        /// <summary>Can return group owned objects</summary>

        ReturnGroupOwned((long)1L << 48),

        /// <summary>Can landscape using Linden plants</summary>

        LandGardening((long)1L << 35),

        // Objects

        /// <summary>Can deed objects to group</summary>

        DeedObject((long)1L << 36),

        /// <summary>Can move group owned objects</summary>

        ObjectManipulate((long)1L << 38),

        /// <summary>Can set group owned objects for-sale</summary>

        ObjectSetForSale((long)1L << 39),

        /// <summary>Pay group liabilities and receive group dividends</summary>

        Accountable((long)1L << 40),

        // Notices and proposals

        /// <summary>Can send group notices</summary>

        SendNotices((long)1L << 42),

        /// <summary>Can receive group notices</summary>

        ReceiveNotices((long)1L << 43),

        /// <summary>Can create group proposals</summary>

        StartProposal((long)1L << 44),

        /// <summary>Can vote on group proposals</summary>

        VoteOnProposal((long)1L << 45);

      private long index;

      GroupPowers(long index)

    {

      this.index = index;

    }    

    public long getIndex()

    {

      return index;

    }

   

    private static final Map<Long,GroupPowers> lookup  = new HashMap<Long,GroupPowers>();

   

    static {

      for(GroupPowers s : EnumSet.allOf(GroupPowers.class))

        lookup.put(s.getIndex(), s);

    }

    public static EnumSet<GroupPowers> get(Long index)

    {

      EnumSet<GroupPowers> enumsSet = EnumSet.allOf(GroupPowers.class);

      for(Entry<Long,GroupPowers> entry: lookup.entrySet())

      {

        if((entry.getKey().longValue() | index) != index)

        {

          enumsSet.remove(entry.getValue());

        }

      }

      return enumsSet;

    }

   

    public static long getIndex(EnumSet<GroupPowers> enumSet)

    {

      long ret = 0;

      for(GroupPowers s: enumSet)

      {

        ret |= s.getIndex();

      }

      return ret;

    }

    }

    //endregion Enums

//        //region Delegates

    private EventObservable<CurrentGroupsEventArgs> onCurrentGroups = new EventObservable<CurrentGroupsEventArgs>();

    public void registerOnCurrentGroups(EventObserver<CurrentGroupsEventArgs> o)

    {

      onCurrentGroups.addObserver(o);

    }

    public void unregisterOnCurrentGroups(EventObserver<CurrentGroupsEventArgs> o)

    {

      onCurrentGroups.deleteObserver(o);

    }

    private EventObservable<GroupNamesEventArgs> onGroupNamesReply = new EventObservable<GroupNamesEventArgs>();

    public void registerOnGroupNamesReply(EventObserver<GroupNamesEventArgs> o)

    {

      onGroupNamesReply.addObserver(o);

    }

    public void unregisterOnGroupNamesReply(EventObserver<GroupNamesEventArgs> o)

    {

      onGroupNamesReply.deleteObserver(o);

    }

    private EventObservable<GroupProfileEventArgs> onGroupProfile = new EventObservable<GroupProfileEventArgs>();

    public void registerOnGroupProfile(EventObserver<GroupProfileEventArgs> o)

    {

      onGroupProfile.addObserver(o);

    }

    public void unregisterOnGroupProfile(EventObserver<GroupProfileEventArgs> o)

    {

      onGroupProfile.deleteObserver(o);

    }

    private EventObservable<GroupMembersReplyEventArgs> onGroupMembersReply = new EventObservable<GroupMembersReplyEventArgs>();

    public void registerOnGroupMembersReply(EventObserver<GroupMembersReplyEventArgs> o)

    {

      onGroupMembersReply.addObserver(o);

    }

    public void unregisterOnGroupMembersReply(EventObserver<GroupMembersReplyEventArgs> o)

    {

      onGroupMembersReply.deleteObserver(o);

    }

    private EventObservable<GroupRolesDataReplyEventArgs> onGroupRoleDataReply = new EventObservable<GroupRolesDataReplyEventArgs>();

    public void registerOnGroupRoleDataReply(EventObserver<GroupRolesDataReplyEventArgs> o)

    {

      onGroupRoleDataReply.addObserver(o);

    }

    public void unregisterOnGroupRoleDataReply(EventObserver<GroupRolesDataReplyEventArgs> o)

    {

      onGroupRoleDataReply.deleteObserver(o);

    }

    private EventObservable<GroupRolesMembersReplyEventArgs> onGroupRoleMembersReply = new EventObservable<GroupRolesMembersReplyEventArgs>();

    public void registerOnGroupRoleMembersReply(EventObserver<GroupRolesMembersReplyEventArgs> o)

    {

      onGroupRoleMembersReply.addObserver(o);

    }

    public void unregisterOnGroupRoleMembersReply(EventObserver<GroupRolesMembersReplyEventArgs> o)

    {

      onGroupRoleMembersReply.deleteObserver(o);

    }

    private EventObservable<GroupTitlesReplyEventArgs> onGroupTitlesReply = new EventObservable<GroupTitlesReplyEventArgs>();

    public void registerOnGroupTitlesReply(EventObserver<GroupTitlesReplyEventArgs> o)

    {

      onGroupTitlesReply.addObserver(o);

    }

    public void unregisterOnGroupTitlesReply(EventObserver<GroupTitlesReplyEventArgs> o)

    {

      onGroupTitlesReply.deleteObserver(o);

    }

    private EventObservable<GroupAccountSummaryReplyEventArgs> onGroupAccountSummaryReply = new EventObservable<GroupAccountSummaryReplyEventArgs>();

    public void registerOnGroupAccountSummaryReply(EventObserver<GroupAccountSummaryReplyEventArgs> o)

    {

      onGroupAccountSummaryReply.addObserver(o);

    }

    public void unregisterOnGroupAccountSummaryReply(EventObserver<GroupAccountSummaryReplyEventArgs> o)

    {

      onGroupAccountSummaryReply.deleteObserver(o);

    }

    private EventObservable<GroupCreatedReplyEventArgs> onGroupCreatedReply = new EventObservable<GroupCreatedReplyEventArgs>();

    public void registerOnGroupCreatedReply(EventObserver<GroupCreatedReplyEventArgs> o)

    {

      onGroupCreatedReply.addObserver(o);

    }

    public void unregisterOnGroupCreatedReply(EventObserver<GroupCreatedReplyEventArgs> o)

    {

      onGroupCreatedReply.deleteObserver(o);

    }

    private EventObservable<GroupOperationEventArgs> onGroupJoinedReply = new EventObservable<GroupOperationEventArgs>();

    public void registerOnGroupJoinedReply(EventObserver<GroupOperationEventArgs> o)

    {

      onGroupJoinedReply.addObserver(o);

    }

    public void unregisterOnGroupJoinedReply(EventObserver<GroupOperationEventArgs> o)

    {

      onGroupJoinedReply.deleteObserver(o);

    }

    private EventObservable<GroupOperationEventArgs> onGroupLeaveReply = new EventObservable<GroupOperationEventArgs>();

    public void registerOnGroupLeaveReply(EventObserver<GroupOperationEventArgs> o)

    {

      onGroupLeaveReply.addObserver(o);

    }

    public void unregisterOnGroupLeaveReply(EventObserver<GroupOperationEventArgs> o)

    {

      onGroupLeaveReply.deleteObserver(o);

    }

    private EventObservable<GroupDroppedEventArgs> onGroupDropped = new EventObservable<GroupDroppedEventArgs>();

    public void registerOnGroupDropped(EventObserver<GroupDroppedEventArgs> o)

    {

      onGroupDropped.addObserver(o);

    }

    public void unregisterOnGroupDropped(EventObserver<GroupDroppedEventArgs> o)

    {

      onGroupDropped.deleteObserver(o);

    }

    private EventObservable<GroupOperationEventArgs> onGroupMemberEjected = new EventObservable<GroupOperationEventArgs>();

    public void registerOnGroupMemberEjected(EventObserver<GroupOperationEventArgs> o)

    {

      onGroupMemberEjected.addObserver(o);

    }

    public void unregisterOnGroupMemberEjected(EventObserver<GroupOperationEventArgs> o)

    {

      onGroupMemberEjected.deleteObserver(o);

    }

    private EventObservable<GroupNoticesListReplyEventArgs> onGroupNoticesListReply = new EventObservable<GroupNoticesListReplyEventArgs>();

    public void registerOnGroupNoticesListReply(EventObserver<GroupNoticesListReplyEventArgs> o)

    {

      onGroupNoticesListReply.addObserver(o);

    }

    public void unregisterOnGroupNoticesListReply(EventObserver<GroupNoticesListReplyEventArgs> o)

    {

      onGroupNoticesListReply.deleteObserver(o);

    }

    private EventObservable<GroupInvitationEventArgs> onGroupInvitation = new EventObservable<GroupInvitationEventArgs>();

    public void registerOnGroupInvitation(EventObserver<GroupInvitationEventArgs> o)

    {

      onGroupInvitation.addObserver(o);

    }

    public void unregisterOnGroupInvitation(EventObserver<GroupInvitationEventArgs> o)

    {

      onGroupInvitation.deleteObserver(o);

    }

   

   

//        private EventHandler<CurrentGroupsEventArgs> m_CurrentGroups;

//

//        /// <summary>Raises the CurrentGroups event</summary>

//        /// <param name="e">A CurrentGroupsEventArgs object containing the

//        /// data sent from the simulator</param>

//        protected virtual void OnCurrentGroups(CurrentGroupsEventArgs e)

//        {

//            EventHandler<CurrentGroupsEventArgs> handler = m_CurrentGroups;

//            if (handler != null)

//                handler(this, e);

//        }

//

//        /// <summary>Thread sync lock object</summary>

//        private readonly object m_CurrentGroupsLock = new object();

//

//        /// <summary>Raised when the simulator sends us data containing

//        /// our current group membership</summary>

//        public event EventHandler<CurrentGroupsEventArgs> CurrentGroups

//        {

//            add { lock (m_CurrentGroupsLock) { m_CurrentGroups += value; } }

//            remove { lock (m_CurrentGroupsLock) { m_CurrentGroups -= value; } }

//        }

//

//        /// <summary>The event subscribers. null if no subcribers</summary>

//        private EventHandler<GroupNamesEventArgs> m_GroupNames;

//

//        /// <summary>Raises the GroupNamesReply event</summary>

//        /// <param name="e">A GroupNamesEventArgs object containing the

//        /// data response from the simulator</param>

//        protected virtual void OnGroupNamesReply(GroupNamesEventArgs e)

//        {

//            EventHandler<GroupNamesEventArgs> handler = m_GroupNames;

//            if (handler != null)

//                handler(this, e);

//        }

//

//        /// <summary>Thread sync lock object</summary>

//        private readonly object m_GroupNamesLock = new object();

//

//        /// <summary>Raised when the simulator responds to a RequestGroupName

//        /// or RequestGroupNames request</summary>

//        public event EventHandler<GroupNamesEventArgs> GroupNamesReply

//        {

//            add { lock (m_GroupNamesLock) { m_GroupNames += value; } }

//            remove { lock (m_GroupNamesLock) { m_GroupNames -= value; } }

//        }

//

//        /// <summary>The event subscribers. null if no subcribers</summary>

//        private EventHandler<GroupProfileEventArgs> m_GroupProfile;

//

//        /// <summary>Raises the GroupProfile event</summary>

//        /// <param name="e">An GroupProfileEventArgs object containing the

//        /// data returned from the simulator</param>

//        protected virtual void OnGroupProfile(GroupProfileEventArgs e)

//        {

//            EventHandler<GroupProfileEventArgs> handler = m_GroupProfile;

//            if (handler != null)

//                handler(this, e);

//        }

//

//        /// <summary>Thread sync lock object</summary>

//        private readonly object m_GroupProfileLock = new object();

//

//        /// <summary>Raised when the simulator responds to a <see cref="RequestGroupProfile"/> request</summary>

//        public event EventHandler<GroupProfileEventArgs> GroupProfile

//        {

//            add { lock (m_GroupProfileLock) { m_GroupProfile += value; } }

//            remove { lock (m_GroupProfileLock) { m_GroupProfile -= value; } }

//        }

//

//        /// <summary>The event subscribers. null if no subcribers</summary>

//        private EventHandler<GroupMembersReplyEventArgs> m_GroupMembers;

//

//        /// <summary>Raises the GroupMembers event</summary>

//        /// <param name="e">A GroupMembersEventArgs object containing the

//        /// data returned from the simulator</param>

//        protected virtual void OnGroupMembersReply(GroupMembersReplyEventArgs e)

//        {

//            EventHandler<GroupMembersReplyEventArgs> handler = m_GroupMembers;

//            if (handler != null)

//                handler(this, e);

//        }

//

//        /// <summary>Thread sync lock object</summary>

//        private readonly object m_GroupMembersLock = new object();

//

//        /// <summary>Raised when the simulator responds to a <see cref="RequestGroupMembers"/> request</summary>

//        public event EventHandler<GroupMembersReplyEventArgs> GroupMembersReply

//        {

//            add { lock (m_GroupMembersLock) { m_GroupMembers += value; } }

//            remove { lock (m_GroupMembersLock) { m_GroupMembers -= value; } }

//        }

//

//        /// <summary>The event subscribers. null if no subcribers</summary>

//        private EventHandler<GroupRolesDataReplyEventArgs> m_GroupRoles;

//

//        /// <summary>Raises the GroupRolesDataReply event</summary>

//        /// <param name="e">A GroupRolesDataReplyEventArgs object containing the

//        /// data returned from the simulator</param>

//        protected virtual void OnGroupRoleDataReply(GroupRolesDataReplyEventArgs e)

//        {

//            EventHandler<GroupRolesDataReplyEventArgs> handler = m_GroupRoles;

//            if (handler != null)

//                handler(this, e);

//        }

//

//        /// <summary>Thread sync lock object</summary>

//        private readonly object m_GroupRolesLock = new object();

//

//        /// <summary>Raised when the simulator responds to a <see cref="RequestGroupRoleData"/> request</summary>

//        public event EventHandler<GroupRolesDataReplyEventArgs> GroupRoleDataReply

//        {

//            add { lock (m_GroupRolesLock) { m_GroupRoles += value; } }

//            remove { lock (m_GroupRolesLock) { m_GroupRoles -= value; } }

//        }

//

//        /// <summary>The event subscribers. null if no subcribers</summary>

//        private EventHandler<GroupRolesMembersReplyEventArgs> m_GroupRoleMembers;

//

//        /// <summary>Raises the GroupRoleMembersReply event</summary>

//        /// <param name="e">A GroupRolesRoleMembersReplyEventArgs object containing the

//        /// data returned from the simulator</param>

//        protected virtual void OnGroupRoleMembers(GroupRolesMembersReplyEventArgs e)

//        {

//            EventHandler<GroupRolesMembersReplyEventArgs> handler = m_GroupRoleMembers;

//            if (handler != null)

//                handler(this, e);

//        }

//

//        /// <summary>Thread sync lock object</summary>

//        private readonly object m_GroupRolesMembersLock = new object();

//

//        /// <summary>Raised when the simulator responds to a <see cref="RequestGroupRolesMembers"/> request</summary>

//        public event EventHandler<GroupRolesMembersReplyEventArgs> GroupRoleMembersReply

//        {

//            add { lock (m_GroupRolesMembersLock) { m_GroupRoleMembers += value; } }

//            remove { lock (m_GroupRolesMembersLock) { m_GroupRoleMembers -= value; } }

//        }

//

//        /// <summary>The event subscribers. null if no subcribers</summary>

//        private EventHandler<GroupTitlesReplyEventArgs> m_GroupTitles;

//

//

//        /// <summary>Raises the GroupTitlesReply event</summary>

//        /// <param name="e">A GroupTitlesReplyEventArgs object containing the

//        /// data returned from the simulator</param>

//        protected virtual void OnGroupTitles(GroupTitlesReplyEventArgs e)

//        {

//            EventHandler<GroupTitlesReplyEventArgs> handler = m_GroupTitles;

//            if (handler != null)

//                handler(this, e);

//        }

//

//        /// <summary>Thread sync lock object</summary>

//        private readonly object m_GroupTitlesLock = new object();

//

//        /// <summary>Raised when the simulator responds to a <see cref="RequestGroupTitles"/> request</summary>

//        public event EventHandler<GroupTitlesReplyEventArgs> GroupTitlesReply

//        {

//            add { lock (m_GroupTitlesLock) { m_GroupTitles += value; } }

//            remove { lock (m_GroupTitlesLock) { m_GroupTitles -= value; } }

//        }

//

//        /// <summary>The event subscribers. null if no subcribers</summary>

//        private EventHandler<GroupAccountSummaryReplyEventArgs> m_GroupAccountSummary;

//

//        /// <summary>Raises the GroupAccountSummary event</summary>

//        /// <param name="e">A GroupAccountSummaryReplyEventArgs object containing the

//        /// data returned from the simulator</param>

//        protected virtual void OnGroupAccountSummaryReply(GroupAccountSummaryReplyEventArgs e)

//        {

//            EventHandler<GroupAccountSummaryReplyEventArgs> handler = m_GroupAccountSummary;

//            if (handler != null)

//                handler(this, e);

//        }

//

//        /// <summary>Thread sync lock object</summary>

//        private readonly object m_GroupAccountSummaryLock = new object();

//

//        /// <summary>Raised when a response to a RequestGroupAccountSummary is returned

//        /// by the simulator</summary>

//        public event EventHandler<GroupAccountSummaryReplyEventArgs> GroupAccountSummaryReply

//        {

//            add { lock (m_GroupAccountSummaryLock) { m_GroupAccountSummary += value; } }

//            remove { lock (m_GroupAccountSummaryLock) { m_GroupAccountSummary -= value; } }

//        }

//

//        /// <summary>The event subscribers. null if no subcribers</summary>

//        private EventHandler<GroupCreatedReplyEventArgs> m_GroupCreated;

//

//        /// <summary>Raises the GroupCreated event</summary>

//        /// <param name="e">An GroupCreatedEventArgs object containing the

//        /// data returned from the simulator</param>

//        protected virtual void OnGroupCreatedReply(GroupCreatedReplyEventArgs e)

//        {

//            EventHandler<GroupCreatedReplyEventArgs> handler = m_GroupCreated;

//            if (handler != null)

//                handler(this, e);

//        }

//        /// <summary>Thread sync lock object</summary>

//        private readonly object m_GroupCreatedLock = new object();

//

//        /// <summary>Raised when a request to create a group is successful</summary>

//        public event EventHandler<GroupCreatedReplyEventArgs> GroupCreatedReply

//        {

//            add { lock (m_GroupCreatedLock) { m_GroupCreated += value; } }

//            remove { lock (m_GroupCreatedLock) { m_GroupCreated -= value; } }

//        }

//

//        /// <summary>The event subscribers. null if no subcribers</summary>

//        private EventHandler<GroupOperationEventArgs> m_GroupJoined;

//

//        /// <summary>Raises the GroupJoined event</summary>

//        /// <param name="e">A GroupOperationEventArgs object containing the

//        /// result of the operation returned from the simulator</param>

//        protected virtual void OnGroupJoinedReply(GroupOperationEventArgs e)

//        {

//            EventHandler<GroupOperationEventArgs> handler = m_GroupJoined;

//            if (handler != null)

//                handler(this, e);

//        }

//        /// <summary>Thread sync lock object</summary>

//        private readonly object m_GroupJoinedLock = new object();

//

//        /// <summary>Raised when a request to join a group either

//        /// fails or succeeds</summary>

//        public event EventHandler<GroupOperationEventArgs> GroupJoinedReply

//        {

//            add { lock (m_GroupJoinedLock) { m_GroupJoined += value; } }

//            remove { lock (m_GroupJoinedLock) { m_GroupJoined -= value; } }

//        }

//

//        /// <summary>The event subscribers. null if no subcribers</summary>

//        private EventHandler<GroupOperationEventArgs> m_GroupLeft;

//

//        /// <summary>Raises the GroupLeft event</summary>

//        /// <param name="e">A GroupOperationEventArgs object containing the

//        /// result of the operation returned from the simulator</param>

//        protected virtual void OnGroupLeaveReply(GroupOperationEventArgs e)

//        {

//            EventHandler<GroupOperationEventArgs> handler = m_GroupLeft;

//            if (handler != null)

//                handler(this, e);

//        }

//        /// <summary>Thread sync lock object</summary>

//        private readonly object m_GroupLeftLock = new object();

//

//        /// <summary>Raised when a request to leave a group either

//        /// fails or succeeds</summary>

//        public event EventHandler<GroupOperationEventArgs> GroupLeaveReply

//        {

//            add { lock (m_GroupLeftLock) { m_GroupLeft += value; } }

//            remove { lock (m_GroupLeftLock) { m_GroupLeft -= value; } }

//        }

//

//        /// <summary>The event subscribers. null if no subcribers</summary>

//        private EventHandler<GroupDroppedEventArgs> m_GroupDropped;

//

//        /// <summary>Raises the GroupDropped event</summary>

//        /// <param name="e">An GroupDroppedEventArgs object containing the

//        /// the group your agent left</param>

//        protected virtual void OnGroupDropped(GroupDroppedEventArgs e)

//        {

//            EventHandler<GroupDroppedEventArgs> handler = m_GroupDropped;

//            if (handler != null)

//                handler(this, e);

//        }

//        /// <summary>Thread sync lock object</summary>

//        private readonly object m_GroupDroppedLock = new object();

//

//        /// <summary>Raised when A group is removed from the group server</summary>

//        public event EventHandler<GroupDroppedEventArgs> GroupDropped

//        {

//            add { lock (m_GroupDroppedLock) { m_GroupDropped += value; } }

//            remove { lock (m_GroupDroppedLock) { m_GroupDropped -= value; } }

//        }

//

//        /// <summary>The event subscribers. null if no subcribers</summary>

//        private EventHandler<GroupOperationEventArgs> m_GroupMemberEjected;

//

//        /// <summary>Raises the GroupMemberEjected event</summary>

//        /// <param name="e">An GroupMemberEjectedEventArgs object containing the

//        /// data returned from the simulator</param>

//        protected virtual void OnGroupMemberEjected(GroupOperationEventArgs e)

//        {

//            EventHandler<GroupOperationEventArgs> handler = m_GroupMemberEjected;

//            if (handler != null)

//                handler(this, e);

//        }

//        /// <summary>Thread sync lock object</summary>

//        private readonly object m_GroupMemberEjectedLock = new object();

//

//        /// <summary>Raised when a request to eject a member from a group either

//        /// fails or succeeds</summary>

//        public event EventHandler<GroupOperationEventArgs> GroupMemberEjected

//        {

//            add { lock (m_GroupMemberEjectedLock) { m_GroupMemberEjected += value; } }

//            remove { lock (m_GroupMemberEjectedLock) { m_GroupMemberEjected -= value; } }

//        }

//

//        /// <summary>The event subscribers. null if no subcribers</summary>

//        private EventHandler<GroupNoticesListReplyEventArgs> m_GroupNoticesListReply;

//

//        /// <summary>Raises the GroupNoticesListReply event</summary>

//        /// <param name="e">An GroupNoticesListReplyEventArgs object containing the

//        /// data returned from the simulator</param>

//        protected virtual void OnGroupNoticesListReply(GroupNoticesListReplyEventArgs e)

//        {

//            EventHandler<GroupNoticesListReplyEventArgs> handler = m_GroupNoticesListReply;

//            if (handler != null)

//                handler(this, e);

//        }

//

//        /// <summary>Thread sync lock object</summary>

//        private readonly object m_GroupNoticesListReplyLock = new object();

//

//        /// <summary>Raised when the simulator sends us group notices</summary>

//        /// <seealso cref="RequestGroupNoticesList"/>

//        public event EventHandler<GroupNoticesListReplyEventArgs> GroupNoticesListReply

//        {

//            add { lock (m_GroupNoticesListReplyLock) { m_GroupNoticesListReply += value; } }

//            remove { lock (m_GroupNoticesListReplyLock) { m_GroupNoticesListReply -= value; } }

//        }

//

//        /// <summary>The event subscribers. null if no subcribers</summary>

//        private EventHandler<GroupInvitationEventArgs> m_GroupInvitation;

//

//        /// <summary>Raises the GroupInvitation event</summary>

//        /// <param name="e">An GroupInvitationEventArgs object containing the

//        /// data returned from the simulator</param>

//        protected virtual void OnGroupInvitation(GroupInvitationEventArgs e)

//        {

//            EventHandler<GroupInvitationEventArgs> handler = m_GroupInvitation;

//            if (handler != null)

//                handler(this, e);

//        }

//

//        /// <summary>Thread sync lock object</summary>

//        private readonly object m_GroupInvitationLock = new object();

//

//        /// <summary>Raised when another agent invites our avatar to join a group</summary>

//        public event EventHandler<GroupInvitationEventArgs> GroupInvitation

//        {

//            add { lock (m_GroupInvitationLock) { m_GroupInvitation += value; } }

//            remove { lock (m_GroupInvitationLock) { m_GroupInvitation -= value; } }

//        }

//        //endregion Delegates

//

//        //region Events

//

//        //endregion Events

//

        /// <summary>A reference to the current <seealso cref="GridClient"/> instance</summary>

        private GridClient Client;

        /// <summary>Currently-active group members requests</summary>

        private List<UUID> GroupMembersRequests;

        /// <summary>Currently-active group roles requests</summary>

        private List<UUID> GroupRolesRequests;

        /// <summary>Currently-active group role-member requests</summary>

        private List<UUID> GroupRolesMembersRequests;

        /// <summary>Dictionary keeping group members while request is in progress</summary>

        private InternalDictionary<UUID, Map<UUID, GroupMember>> TempGroupMembers;

        /// <summary>Dictionary keeping mebmer/role mapping while request is in progress</summary>

        private InternalDictionary<UUID, List<KeyValuePair<UUID, UUID>>> TempGroupRolesMembers;

        /// <summary>Dictionary keeping GroupRole information while request is in progress</summary>

        private InternalDictionary<UUID, Map<UUID, GroupRole>> TempGroupRoles;

        /// <summary>Caches group name lookups</summary>

        public InternalDictionary<UUID, String> GroupName2KeyCache;

        /// <summary>

        /// Construct a new instance of the GroupManager class

        /// </summary>

        /// <param name="client">A reference to the current <seealso cref="GridClient"/> instance</param>

        public GroupManager(GridClient client)

        {

            Client = client;

            TempGroupMembers = new InternalDictionary<UUID, Map<UUID, GroupMember>>();

            GroupMembersRequests = new ArrayList<UUID>();

            TempGroupRoles = new InternalDictionary<UUID, Map<UUID, GroupRole>>();

            GroupRolesRequests = new ArrayList<UUID>();

            TempGroupRolesMembers = new InternalDictionary<UUID, List<KeyValuePair<UUID, UUID>>>();

            GroupRolesMembersRequests = new ArrayList<UUID>();

            GroupName2KeyCache = new InternalDictionary<UUID, String>();

            // Client.Self.IM += Self_IM;

          Client.self.registerIM(new EventObserver<InstantMessageEventArgs>()

              {

            @Override

            public void handleEvent(Observable o,

                InstantMessageEventArgs arg) {

              try {

                Self_IM(o, arg);}

              catch(Exception e) {JLogger.warn(Utils.getExceptionStackTraceAsString(e));}

            }

              });

                       

            //Client.network.RegisterEventCallback("AgentGroupDataUpdate", new Caps.EventQueueCallback(AgentGroupDataUpdateMessageHandler);

          Client.network.RegisterEventCallback("AgentGroupDataUpdate", new EventObserver<CapsEventObservableArg>()

              {

            @Override

            public void handleEvent(Observable o,CapsEventObservableArg arg) {

              try{ AgentGroupDataUpdateMessageHandler(arg.getCapsKey(), arg.getMessage(), arg.getSimulator());}

              catch(Exception e) {JLogger.warn(Utils.getExceptionStackTraceAsString(e));}

            }}

              );

         

          //deprecated in simulator v1.27

            //Client.network.RegisterCallback(PacketType.AgentDropGroup, AgentDropGroupHandler);

            Client.network.RegisterCallback(PacketType.AgentDropGroup, new EventObserver<PacketReceivedEventArgs>()

                {

              @Override

              public void handleEvent(Observable o,PacketReceivedEventArgs arg) {

                try{ AgentDropGroupHandler(o, arg);}

                catch(Exception e) {JLogger.warn(Utils.getExceptionStackTraceAsString(e));}

              }}

                );

            //Client.network.RegisterCallback(PacketType.GroupTitlesReply, GroupTitlesReplyHandler);

            Client.network.RegisterCallback(PacketType.GroupTitlesReply, new EventObserver<PacketReceivedEventArgs>()

                {

              @Override

              public void handleEvent(Observable o,PacketReceivedEventArgs arg) {

                try{ GroupTitlesReplyHandler(o, arg);}

                catch(Exception e) {JLogger.warn(Utils.getExceptionStackTraceAsString(e));}

              }}

                );

            //Client.network.RegisterCallback(PacketType.GroupProfileReply, GroupProfileReplyHandler);

            Client.network.RegisterCallback(PacketType.GroupProfileReply, new EventObserver<PacketReceivedEventArgs>()

                {

              @Override

              public void handleEvent(Observable o,PacketReceivedEventArgs arg) {

                try{ GroupProfileReplyHandler(o, arg);}

                catch(Exception e) {JLogger.warn(Utils.getExceptionStackTraceAsString(e));}

              }}

                );

            //Client.network.RegisterCallback(PacketType.GroupMembersReply, GroupMembersHandler);

            Client.network.RegisterCallback(PacketType.GroupMembersReply, new EventObserver<PacketReceivedEventArgs>()

                {

              @Override

              public void handleEvent(Observable o,PacketReceivedEventArgs arg) {

                try{ GroupMembersHandler(o, arg);}

                catch(Exception e) {JLogger.warn(Utils.getExceptionStackTraceAsString(e));}

              }}

                );

            //Client.network.RegisterCallback(PacketType.GroupRoleDataReply, GroupRoleDataReplyHandler);

            Client.network.RegisterCallback(PacketType.GroupRoleDataReply, new EventObserver<PacketReceivedEventArgs>()

                {

              @Override

              public void handleEvent(Observable o,PacketReceivedEventArgs arg) {

                try{ GroupRoleDataReplyHandler(o, arg);}

                catch(Exception e) {JLogger.warn(Utils.getExceptionStackTraceAsString(e));}

              }}

                );

            //Client.network.RegisterCallback(PacketType.GroupRoleMembersReply, GroupRoleMembersReplyHandler);

            Client.network.RegisterCallback(PacketType.GroupRoleMembersReply, new EventObserver<PacketReceivedEventArgs>()

                {

              @Override

              public void handleEvent(Observable o,PacketReceivedEventArgs arg) {

                try{ GroupRoleMembersReplyHandler(o, arg);}

                catch(Exception e) {JLogger.warn(Utils.getExceptionStackTraceAsString(e));}

              }}

                );

            //Client.network.RegisterCallback(PacketType.GroupActiveProposalItemReply, GroupActiveProposalItemHandler);

            Client.network.RegisterCallback(PacketType.GroupActiveProposalItemReply, new EventObserver<PacketReceivedEventArgs>()

                {

              @Override

              public void handleEvent(Observable o,PacketReceivedEventArgs arg) {

                try{ GroupActiveProposalItemHandler(o, arg);}

                catch(Exception e) {JLogger.warn(Utils.getExceptionStackTraceAsString(e));}

              }}

                );

            //Client.network.RegisterCallback(PacketType.GroupVoteHistoryItemReply, GroupVoteHistoryItemHandler);

            Client.network.RegisterCallback(PacketType.GroupVoteHistoryItemReply, new EventObserver<PacketReceivedEventArgs>()

                {

              @Override

              public void handleEvent(Observable o,PacketReceivedEventArgs arg) {

                try{ GroupVoteHistoryItemHandler(o, arg);}

                catch(Exception e) {JLogger.warn(Utils.getExceptionStackTraceAsString(e));}

              }}

                );

            //Client.network.RegisterCallback(PacketType.GroupAccountSummaryReply, GroupAccountSummaryReplyHandler);

            Client.network.RegisterCallback(PacketType.GroupAccountSummaryReply, new EventObserver<PacketReceivedEventArgs>()

                {

              @Override

              public void handleEvent(Observable o,PacketReceivedEventArgs arg) {

                try{ GroupAccountSummaryReplyHandler(o, arg);}

                catch(Exception e) {JLogger.warn(Utils.getExceptionStackTraceAsString(e));}

              }}

                );

            //Client.network.RegisterCallback(PacketType.CreateGroupReply, CreateGroupReplyHandler);

            Client.network.RegisterCallback(PacketType.CreateGroupReply, new EventObserver<PacketReceivedEventArgs>()

                {

              @Override

              public void handleEvent(Observable o,PacketReceivedEventArgs arg) {

                try{ CreateGroupReplyHandler(o, arg);}

                catch(Exception e) {JLogger.warn(Utils.getExceptionStackTraceAsString(e));}