groupmanager.mm

lumaqq

		m_dirty = YES;
	}
}

- (void)setSubjects:(UInt32)clusterInternalId subjects:(NSArray*)subjects {
	Cluster* c = [self cluster:clusterInternalId];
	if(c) {
		NSEnumerator* e = [subjects objectEnumerator];
		while(SubCluster* sc = [e nextObject]) {
			if(![m_tempClusterRegistry objectForKey:[NSNumber numberWithUnsignedInt:[sc internalId]]]) {
				Cluster* sub = [[Cluster alloc] initWithInternalId:[sc internalId] domain:m_domain];
				[sub setParentId:[c internalId]];
				[sub setName:[sc name]];
				[sub setPermanent:NO];
				[sub setTempType:kQQTempClusterTypeSubject];
				[c addSubCluster:sub];
				[m_tempClusterRegistry setObject:sub forKey:[NSNumber numberWithUnsignedInt:[sub internalId]]];
				[sub release];
				
				m_dirty = YES;
			}
		}
	}
}

- (void)setMembers:(UInt32)internalId members:(NSArray*)members {
	Cluster* c = [self cluster:internalId];
	if(c) {
		NSEnumerator* e = [members objectEnumerator];
		while(Member* member = [e nextObject]) {
			// get a user or create a new one
			User* user = [m_userRegistry objectForKey:[NSNumber numberWithUnsignedInt:[member QQ]]];
			if(user == nil) {
				user = [[User alloc] initWithQQ:[member QQ] domain:m_domain];
				[m_userRegistry setObject:user forKey:[NSNumber numberWithUnsignedInt:[user QQ]]];
			} else
				[user retain];
			
			// set role and organization
			if([c permanent]) {
				[user setRoleFlag:internalId role:[member roleFlag]];
				[user setOrganization:internalId organization:[member organization]];
			}

			// add it to cluster
			[c addMember:user];
			
			// release
			[user release];
		}
	}
}

- (void)setClusterNameCards:(UInt32)internalId nameCards:(NSArray*)nameCards {
	NSEnumerator* e = [nameCards objectEnumerator];
	while(ClusterNameCard* card = [e nextObject]) {
		User* user = [self user:[card QQ]];
		ClusterSpecificInfo* info = [user getClusterSpecificInfo:internalId];
		[info setNameCard:card];
	}
}

- (void)setOrganizations:(UInt32)internalId organizations:(NSArray*)organizations {
	Cluster* c = [self cluster:internalId];
	if(c) {
		NSEnumerator* e = [organizations objectEnumerator];
		while(QQOrganization* qqOrg = [e nextObject]) {
			Organization* org = [[Organization alloc] initWithQQOrganization:qqOrg];
			[c addOrganization:org];
			[org release];
			m_dirty = YES;
		}		
	}
}

- (void)setMemberInfos:(NSArray*)memberInfos {
	NSEnumerator* e = [memberInfos objectEnumerator];
	while(Friend* f = [e nextObject]) {
		User* u = [self user:[f QQ]];
		if(u) {
			[u copyWithFriend:f];
			m_dirty = YES;
		}			
	}
}

- (void)setOnlineMembers:(NSArray*)onlineMembers {
	NSEnumerator* e = [onlineMembers objectEnumerator];
	while(NSNumber* qq = [e nextObject]) {
		User* u = [self user:[qq intValue]];
		if(u)
			[u setStatus:kQQStatusOnline];
	}
}

- (BOOL)removeUser:(User*)user {
	Group* g = [self group:[user groupIndex]];
	if(g == nil)
		return NO;
	
	// remove
	[g removeUser:user];
	[user setGroupIndex:kGroupIndexUndefined];
	m_dirty = YES;
	m_changed = YES;
	
	// post notification
	[[NSNotificationCenter defaultCenter] postNotificationName:kUserDidRemovedNotificationName
														object:user
													  userInfo:[NSDictionary dictionaryWithObjectsAndKeys:g, kUserInfoFromGroup, m_domain, kUserInfoDomain, nil]];		

	// return
	return YES;
}

- (BOOL)removeCluster:(Cluster*)cluster {
	[cluster setMessageCount:0];
	if([cluster permanent]) {
		[m_clusterGroup removeCluster:cluster];
		[m_clusterRegistry removeObjectForKey:[NSNumber numberWithUnsignedInt:[cluster internalId]]];
	} else {
		if([cluster isDialog])
			[m_dialogs removeObject:cluster];
		else if([cluster isSubject]) {
			Cluster* parentCluster = [self cluster:[cluster parentId]];
			if(parentCluster)
				[parentCluster removeSubCluster:cluster];
		}
		[m_tempClusterRegistry removeObjectForKey:[NSNumber numberWithUnsignedInt:[cluster internalId]]];
	}

	m_dirty = YES;
	return YES;
}

- (BOOL)removeGroup:(Group*)group {
	return [self removeGroupAt:[self indexOfGroup:group]];
}

- (BOOL)removeGroupAt:(int)groupIndex {
	if(groupIndex < 0 || groupIndex >= [m_groups count])
		return NO;
	
	Group* group = [m_groups objectAtIndex:groupIndex];
	if([group userCount] > 0)
		return NO;
	
	// remove
	[m_groups removeObjectAtIndex:groupIndex];
	
	// adjust user's groupindex
	NSEnumerator* e = [m_userRegistry objectEnumerator];
	while(User* u = [e nextObject]) {
		int oldIndex = [u groupIndex];
		if(oldIndex > groupIndex)
			[u setGroupIndex:(oldIndex - 1)];
	}
	
	// dirty flag
	m_dirty = YES;
	m_changed = YES;
	
	return YES;
}

- (void)addUser:(User*)user group:(Group*)group {
	// check user
	User* tmp = [self user:[user QQ]];
	if(tmp)
		user = tmp;
	
	// add it
	if(group) {
		[group addUser:user];
		[user setGroupIndex:[self indexOfGroup:group]];
		m_changed = YES;
	}

	// register it
	[m_userRegistry setObject:user forKey:[NSNumber numberWithUnsignedInt:[user QQ]]];
	
	// dirty flag
	m_dirty = YES;
}

- (void)addUser:(User*)user groupIndex:(int)groupIndex {
	// check group
	Group* g = [self group:groupIndex];	
	[self addUser:user group:g];
}

- (int)moveUser:(User*)user toGroupIndex:(int)groupIndex {
	// get new group
	Group* newGroup = [self group:groupIndex];
	if(newGroup == nil)
		return kGroupIndexUndefined;
	
	return [self moveUser:user toGroup:newGroup];
}

- (int)moveUser:(User*)user toGroup:(Group*)group {
	// check user
	if([self user:[user QQ]] == nil)
		return kGroupIndexUndefined;
	
	// remove from old group
	[user retain];
	int oldGroupIndex = [user groupIndex];
	Group* g = [self group:oldGroupIndex];
	if(g)
		[g removeUser:user];
	
	// add to new group
	[group addUser:user];
	[user setGroupIndex:[self indexOfGroup:group]];	
	[user release];
	
	// sort
	[group sort];
	
	// dirty flag
	m_dirty = YES;
	m_changed = YES;
	
	// post notification
	[[NSNotificationCenter defaultCenter] postNotificationName:kUserDidMovedNotificationName
														object:user
													  userInfo:[NSDictionary dictionaryWithObjectsAndKeys:group, kUserInfoToGroup, g, kUserInfoFromGroup, m_domain, kUserInfoDomain, nil]];
	
	// return
	return oldGroupIndex;
}

- (void)moveAllUsersFrom:(int)fromGroup to:(int)toGroup {
	Group* srcGroup = [self group:fromGroup];
	if(srcGroup == nil)
		return;
	
	Group* destGroup = [self group:toGroup];
	if(destGroup == nil)
		return;
	
	// move
	NSEnumerator* e = [srcGroup userEnumerator];
	while(User* u = [e nextObject]) {
		[destGroup addUser:u];
		[u setGroupIndex:toGroup];
	}
	
	[srcGroup clearUsers];
	
	// sort
	[destGroup sort];
	
	// dirty flag
	m_dirty = YES;
	m_changed = YES;
}

- (void)addCluster:(Cluster*)cluster {
	if([cluster permanent]) {
		// check cluster
		Cluster* tmp = [self cluster:[cluster internalId]];
		if(tmp)
			cluster = tmp;
		
		// add it
		[m_clusterGroup addCluster:cluster];
		
		// register it
		[m_clusterRegistry setObject:cluster forKey:[NSNumber numberWithUnsignedInt:[cluster internalId]]];
	} else {
		// get parent cluster, if parnet id is 0, add to dialogs
		if([cluster parentId] == 0)
			[m_dialogs addObject:cluster];
		else {
			Cluster* parentCluster = [self cluster:[cluster parentId]];
			if(parentCluster)
				[parentCluster addSubCluster:cluster];
			else
				return;
		}
		
		// add to registry
		[m_tempClusterRegistry setObject:cluster forKey:[NSNumber numberWithUnsignedInt:[cluster internalId]]];
	}
	
	// dirty flag
	m_dirty = YES;
}

- (Group*)addFriendlyGroup:(NSString*)name {
	Group* group = [[[Group alloc] initWithFlag:(kGroupUser | kGroupFriendly) name:name] autorelease];
	[m_groups addObject:group];
	m_dirty = YES;
	m_changed = YES;
	
	// get new group index
	int groupIndex = [m_groups count] - 1;
	
	// adjust user's groupindex
	NSEnumerator* e = [m_userRegistry objectEnumerator];
	while(User* u = [e nextObject]) {
		int oldIndex = [u groupIndex];
		if(oldIndex >= groupIndex)
			[u setGroupIndex:(oldIndex + 1)];
	}
	
	return group;
}

- (void)setGroupName:(Group*)group name:(NSString*)name {
	[group setName:name];
	m_dirty = YES;
}

- (void)addMobile:(Mobile*)mobile {
	[m_mobileGroup addMobile:mobile];
	m_dirty = YES;
}

- (void)removeMobile:(Mobile*)mobile {
	[mobile setMessageCount:0];
	[m_mobileGroup removeMobile:mobile];
	m_dirty = YES;
}

#pragma mark -
#pragma mark read-only methods

- (BOOL)dirty {
	return m_dirty;
}

- (void)setDirty:(BOOL)flag {
	m_dirty = flag;
}

- (BOOL)changed {
	return m_changed;
}

- (void)setChanged:(BOOL)flag {
	m_changed = flag;
}

- (int)userCount {
	return [m_userRegistry count];
}

- (int)userCount:(int)groupIndex {
	Group* g = [self group:groupIndex];
	return [g userCount];
}

- (int)friendCount {
	NSEnumerator* e = [m_groups objectEnumerator];
	if(e) {
		int count = 0;
		Group* g = nil;
		while(g = [e nextObject])
			count += [g userCount];
		return count;
	} else
		return 0;	
}

- (int)clusterCount {
	return [m_clusterRegistry count];
}

- (int)mobileCount {
	return [m_mobileGroup mobileCount];
}

- (int)tempClusterCount {
	return [m_tempClusterRegistry count];
}

- (int)userGroupCount {
	return [m_groups count] + 2;
}

- (int)friendlyGroupCount {
	return [m_groups count];
}

- (Dummy*)dialogsDummy {
	return m_dialogsDummy;
}

- (int)strangerGroupIndex {
	return [m_groups count];
}

- (int)blacklistGroupIndex {
	return [m_groups count] + 1;
}

- (BOOL)hasUser:(UInt32)QQ {
	return [m_userRegistry objectForKey:[NSNumber numberWithUnsignedInt:QQ]] != nil;
}

- (NSArray*)allUsers {
	return [m_userRegistry allValues];
}

- (NSArray*)allUserQQs {
	return [m_userRegistry allKeys];
}

- (NSArray*)allClusters {
	return [m_clusterRegistry allValues];
}

- (NSArray*)allClusterInternalIds {
	return [m_clusterRegistry allKeys];
}

- (NSArray*)allUserGroups {
	NSMutableArray* array = [NSMutableArray arrayWithArray:m_groups];
	[array addObject:m_strangerGroup];
	[array addObject:m_blacklistGroup];
	return array;
}

- (NSArray*)friendlyGroupNamesExceptMyFriends {
	int count = [m_groups count];
	NSMutableArray* array = [NSMutableArray arrayWithCapacity:(count - 1)];
	for(int i = 1; i < count; i++) {
		[array addObject:[[m_groups objectAtIndex:i] name]];
	}
	return array;
}

- (NSArray*)friendlyGroups {
	return m_groups;
}

- (NSDictionary*)friendGroupMapping {
	NSMutableDictionary* mapping = [NSMutableDictionary dictionary];
	NSEnumerator* e = [m_userRegistry objectEnumerator];
	while(User* u = [e nextObject]) {
		if([u groupIndex] >= 0 && [u groupIndex] < [m_groups count])
			[mapping setObject:[NSNumber numberWithInt:[u groupIndex]] forKey:[NSNumber numberWithUnsignedInt:[u QQ]]];
	}
	return mapping;
}

- (Mobile*)mobileAtIndex:(int)index {
	if(index < 0 || index >= [self mobileCount])
		return nil;
	return [m_mobileGroup mobile:index];
}

- (Mobile*)mobile:(NSString*)mobile {
	return [m_mobileRegistry objectForKey:mobile];
}

- (User*)user:(UInt32)QQ {
	return [m_userRegistry objectForKey:[NSNumber numberWithUnsignedInt:QQ]];
}

- (Cluster*)cluster:(UInt32)internalId {
	NSNumber* key = [NSNumber numberWithUnsignedInt:internalId];
	Cluster* c = [m_clusterRegistry objectForKey:key];
	if(c == nil)
		c = [m_tempClusterRegistry objectForKey:key];
	return c;
}

- (Cluster*)clusterByExternalId:(UInt32)externalId {
	NSEnumerator* e = [m_clusterRegistry objectEnumerator];
	while(Cluster* c = [e nextObject]) {
		if([c externalId] == externalId)
			return c;
	}
	return nil;
}

- (Cluster*)tempCluster:(UInt32)internalId {
	return [m_tempClusterRegistry objectForKey:[NSNumber numberWithUnsignedInt:internalId]];
}

- (int)dialogCount {
	return [m_dialogs count];
}

- (Cluster*)dialog:(UInt32)internalId {
	return [m_tempClusterRegistry objectForKey:[NSNumber numberWithUnsignedInt:internalId]];
}

- (Cluster*)dialogAtIndex:(int)index {
	return [m_dialogs objectAtIndex:index];
}

- (int)indexOfGroup:(Group*)group {
	if(group == m_strangerGroup)
		return [m_groups count];
	else if(group == m_blacklistGroup)
		return [m_groups count] + 1;
	else if(group == m_clusterGroup)
		return kGroupIndexUndefined;
	else
		return [m_groups indexOfObject:group];
}

@end