/* 

 * Adium is the legal property of its developers, whose names are listed in the copyright file included

 * with this source distribution.

 * 

 * This program is free software; you can redistribute it and/or modify it under the terms of the GNU

 * General Public License as published by the Free Software Foundation; either version 2 of the License,

 * or (at your option) any later version.

 * 

 * This program 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 General

 * Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License along with this program; if not,

 * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

 */

#import <Adium/AIAccount.h>

#import <Adium/AIChat.h>

#import <Adium/AIContentMessage.h>

#import <Adium/AIContentTopic.h>

#import <Adium/AIListContact.h>

#import <Adium/AIService.h>

#import <Adium/ESFileTransfer.h>

#import <Adium/AIHTMLDecoder.h>

#import <Adium/AIServiceIcons.h>

#import <Adium/AIUserIcons.h>

#import <Adium/AIContactHidingController.h>

#import <Adium/AIContactControllerProtocol.h>

#import <Adium/AIContentControllerProtocol.h>

#import <Adium/AIChatControllerProtocol.h>

#import <Adium/AIInterfaceControllerProtocol.h>

#import <Adium/AISortController.h>

#import <AIUtilities/AIArrayAdditions.h>

#import <AIUtilities/AIMutableOwnerArray.h>

#import <AIUtilities/AIAttributedStringAdditions.h>

#import "AIMessageWindowController.h"

#import "AIMessageWindow.h"

#import "AIInterfaceControllerProtocol.h"

#import "AIWebKitMessageViewController.h"

@interface AIChat ()

- (id)initForAccount:(AIAccount *)inAccount;

- (void)clearUniqueChatID;

- (void)clearListObjectStatuses;

@end

@implementation AIChat

static int nextChatNumber = 0;

+ (id)chatForAccount:(AIAccount *)inAccount

{

    return [[[self alloc] initForAccount:inAccount] autorelease];

}

- (id)initForAccount:(AIAccount *)inAccount

{

    if ((self = [super init])) {

		name = nil;

		account = [inAccount retain];

		participatingContacts = [[NSMutableArray alloc] init];

		participatingContactsFlags = [[NSMutableDictionary alloc] init];

		participatingContactsAliases = [[NSMutableDictionary alloc] init];

		dateOpened = [[NSDate date] retain];

		uniqueChatID = nil;

		ignoredListContacts = nil;

		isOpen = NO;

		isGroupChat = NO;

		expanded = YES;

		customEmoticons = nil;

		hasSentOrReceivedContent = NO;

		showJoinLeave = YES;

		pendingOutgoingContentObjects = [[NSMutableArray alloc] init];

		AILog(@"[AIChat: %x initForAccount]",self);

	}

    return self;

}

/*!

 * @brief Deallocate

 */

- (void)dealloc

{

	AILog(@"[%@ dealloc]",self);

	[account release];

	[self removeAllParticipatingContactsSilently];

	[participatingContacts release];

	[participatingContactsFlags release];

	[participatingContactsAliases release];

	[dateOpened release];

	[ignoredListContacts release];

	[pendingOutgoingContentObjects release];

	[uniqueChatID release]; uniqueChatID = nil;

	[customEmoticons release]; customEmoticons = nil;

	[topic release]; [topicSetter release];

	[super dealloc];

}

//Big image

- (NSImage *)chatImage

{

	AIListContact 	*listObject = self.listObject;

	NSImage			*image = nil;

	if (listObject) {

		image = listObject.parentContact.userIcon;

		if (!image) image = [AIServiceIcons serviceIconForObject:listObject type:AIServiceIconLarge direction:AIIconNormal];

	} else {

		image = [AIServiceIcons serviceIconForObject:self.account type:AIServiceIconLarge direction:AIIconNormal];

	}

	return image;

}

//lil image

- (NSImage *)chatMenuImage

{

	AIListObject 	*listObject = self.listObject;

	NSImage			*chatMenuImage = nil;

	if (listObject) {

		chatMenuImage = [AIUserIcons menuUserIconForObject:listObject];

	} else {

		chatMenuImage = [AIServiceIcons serviceIconForObject:account

														type:AIServiceIconSmall

												   direction:AIIconNormal];

	}

	return chatMenuImage;

}

//Associated Account ---------------------------------------------------------------------------------------------------

#pragma mark Associated Account

- (AIAccount *)account

{

    return account;

}

- (void)setAccount:(AIAccount *)inAccount

{

	if (inAccount != account) {

		[account release];

		account = [inAccount retain];

		//The uniqueChatID may depend upon the account, so clear it

		[self clearUniqueChatID];

		[[NSNotificationCenter defaultCenter] postNotificationName:Chat_SourceChanged object:self]; //Notify

	}

}

/*@brief: holds information passed upon the creation of the chat:

 * handle, server, etc.

 */

- (NSDictionary *)chatCreationDictionary

{

	return [self valueForProperty:@"ChatCreationInfo"];

}

- (void)setChatCreationDictionary:(NSDictionary *)inDict

{

	[self setValue:inDict

				   forProperty:@"ChatCreationInfo"

				   notify:NotifyNever];

}

@synthesize hasSentOrReceivedContent, isOpen, dateOpened;

//Status ---------------------------------------------------------------------------------------------------------------

#pragma mark Status

//Status

- (void)didModifyProperties:(NSSet *)keys silent:(BOOL)silent

{

	[adium.chatController chatStatusChanged:self

						   modifiedStatusKeys:keys

									   silent:silent];	

}

- (void)object:(id)inObject didChangeValueForProperty:(NSString *)key notify:(NotifyTiming)notify

{

	//If our unviewed content changes or typing status changes, and we have a single list object, 

	//apply the change to that object as well so it can be cleanly reflected in the contact list.

	if ([key isEqualToString:KEY_UNVIEWED_CONTENT] ||

		[key isEqualToString:KEY_TYPING]) {

		AIListObject	*listObject = nil;

		if (self.isGroupChat) {

			listObject = (AIListContact *)[adium.contactController existingBookmarkForChat:self];

		} else {

			listObject = self.listObject;

		}

		if (listObject) [listObject setValue:[self valueForProperty:key] forProperty:key notify:notify];

	}

	[super object:inObject didChangeValueForProperty:key notify:notify];

}

- (void)clearListObjectStatuses

{

	AIListObject	*listObject = self.listObject;

	if (listObject) {

		[listObject setValue:nil forProperty:KEY_UNVIEWED_CONTENT notify:NotifyLater];

		[listObject setValue:nil forProperty:KEY_TYPING notify:NotifyLater];

		[listObject notifyOfChangedPropertiesSilently:NO];

	}

}

//Secure chatting ------------------------------------------------------------------------------------------------------

- (void)setSecurityDetails:(NSDictionary *)securityDetails

{

	[self setValue:securityDetails

				   forProperty:@"SecurityDetails"

				   notify:NotifyNow];

}

- (NSDictionary *)securityDetails

{

	return [self valueForProperty:@"SecurityDetails"];

}

- (BOOL)isSecure

{	

	return self.encryptionStatus != EncryptionStatus_None;

}

- (AIEncryptionStatus)encryptionStatus

{

	AIEncryptionStatus	encryptionStatus = EncryptionStatus_None;

	NSDictionary		*securityDetails = self.securityDetails;

	if (securityDetails) {

		NSNumber *detailsStatus;

		if ((detailsStatus = [securityDetails objectForKey:@"EncryptionStatus"])) {

			encryptionStatus = [detailsStatus intValue];

		} else {

			/* If we don't have a specific encryption status, but do have security details, assume

			 * encrypted and verified.

			 */

			encryptionStatus = EncryptionStatus_Verified;

		}

	}

	return encryptionStatus;

}

- (BOOL)supportsSecureMessagingToggling

{

	return [account allowSecureMessagingTogglingForChat:self];

}

//Name  ----------------------------------------------------------------------------------------------------------------

#pragma mark Name

@synthesize name;

/*!

 * @brief An identifier which can be used to look up this chat later

 *

 * Use uniqueChatID as a unique identifier for a contact-service combination.

 * Only an account which created a chat should specify the identifier; it has no useful meaning outside that context.

 */

@synthesize identifier;

- (NSString *)displayName

{

    NSString	*outName = [self displayArrayObjectForKey:@"Display Name"];

    return outName ? outName : (name ? name : self.listObject.displayName);

}

- (void)setDisplayName:(NSString *)inDisplayName

{

	[[self displayArrayForKey:@"Display Name"] setObject:inDisplayName

											   withOwner:self

										   priorityLevel:Highest_Priority];

	//The display array doesn't cause an attribute update; fake it.

	[adium.chatController chatStatusChanged:self

						 modifiedStatusKeys:[NSSet setWithObject:@"Display Name"]

									 silent:NO];

}

//Participating ListObjects --------------------------------------------------------------------------------------------

#pragma mark Participating ListObjects

/*!

 * @brief The display name for the contact in this chat.

 *

 * @param contact The AIListObject whose display name should be created

 *

 * If the user has an alias set, the alias is used, otherwise the display name.

 *

 * @returns Display name

 */

- (NSString *)displayNameForContact:(AIListObject *)contact

{

	return [self aliasForContact:contact] ?: contact.displayName;

}

/*!

 * @brief The flags for a given contact.

 */

- (AIGroupChatFlags)flagsForContact:(AIListObject *)contact

{

	return [[participatingContactsFlags objectForKey:contact.UID] integerValue];

}

/*!

 * @brief The alias for a given contact

 */

- (NSString *)aliasForContact:(AIListObject *)contact

{

	NSString *alias = [participatingContactsAliases objectForKey:contact.UID];

	if (!alias && self.isGroupChat) {

		alias = [self.account fallbackAliasForContact:(AIListContact *)contact inChat:self];

	}

	return alias;

}

/*!

 * @brief Set the flags for a contact

 *

 * Note that this doesn't set the bitwise or; this directly sets the value passed.

 */

- (void)setFlags:(AIGroupChatFlags)flags forContact:(AIListObject *)contact

{

	[participatingContactsFlags setObject:[NSNumber numberWithInteger:flags]

								   forKey:contact.UID];

}

/*!

 * @brief Set the alias for a contact.

 */

- (void)setAlias:(NSString *)alias forContact:(AIListObject *)contact

{

	[participatingContactsAliases setObject:alias

									 forKey:contact.UID];

}

AIGroupChatFlags highestFlag(AIGroupChatFlags flags)

{

	if ((flags & AIGroupChatFounder) == AIGroupChatFounder)

		return AIGroupChatFounder;

	if ((flags & AIGroupChatOp) == AIGroupChatOp)

		return AIGroupChatOp;

	if ((flags & AIGroupChatHalfOp) == AIGroupChatHalfOp)

		return AIGroupChatHalfOp;

	if ((flags & AIGroupChatVoice) == AIGroupChatVoice)

		return AIGroupChatVoice;

	return AIGroupChatNone;

}

NSComparisonResult userListSort (id objectA, id objectB, void *context)

{

	AIChat *chat = (AIChat *)context;

	AIGroupChatFlags flagA = highestFlag([chat flagsForContact:objectA]), flagB = highestFlag([chat flagsForContact:objectB]);

	if(flagA > flagB) {

		return NSOrderedAscending;

	} else if (flagA < flagB) {

		return NSOrderedDescending;

	} else {

		return [[chat displayNameForContact:objectA] caseInsensitiveCompare:[chat displayNameForContact:objectB]];

	}

}

/*!

 * @brief Resorts our participants

 *

 * This is called when our list objects change.

 */

- (void)resortParticipants

{

	[participatingContacts sortUsingFunction:userListSort context:self];

}

/*!

 * @brief Remove the saved values for a contact

 *

 * Removes any values which are dependent upon the contact, such as

 * its flags or alias.

*/

- (void)removeSavedValuesForContactUID:(NSString *)contactUID

{

	[participatingContactsFlags removeObjectForKey:contactUID];

	[participatingContactsAliases removeObjectForKey:contactUID];

}

- (void)addParticipatingListObject:(AIListContact *)inObject notify:(BOOL)notify

{

	[self addParticipatingListObjects:[NSArray arrayWithObject:inObject] notify:notify];

}

- (void)addParticipatingListObjects:(NSArray *)inObjects notify:(BOOL)notify

{

	NSMutableArray *contacts = [[inObjects mutableCopy] autorelease];

	for (AIListObject *obj in inObjects) {

		if ([self containsObject:obj] || ![self canContainObject:obj])

			[contacts removeObject:obj];

	}

	[participatingContacts addObjectsFromArray:contacts];

	[adium.chatController chat:self addedListContacts:contacts notify:notify];

}

// Invite a list object to join the chat. Returns YES if the chat joins, NO otherwise

- (BOOL)inviteListContact:(AIListContact *)inContact withMessage:(NSString *)inviteMessage

{

	return ([self.account inviteContact:inContact toChat:self withMessage:inviteMessage]);

}

@synthesize preferredListObject = preferredContact;

//If this chat only has one participating list object, it is returned.  Otherwise, nil is returned

- (AIListContact *)listObject

{

	if (self.countOfContainedObjects == 1 && !self.isGroupChat) {

		return [self.containedObjects objectAtIndex:0];

	}

	return nil;

}

- (void)setListObject:(AIListContact *)inListObject

{

	if (inListObject != self.listObject) {

		if (self.countOfContainedObjects) {

			[participatingContacts removeObjectAtIndex:0];

		}

		[self addParticipatingListObject:inListObject notify:YES];

		//Clear any local caches relying on the list object

		[self clearListObjectStatuses];

		[self clearUniqueChatID];

		//Notify once the destination has been changed

		[[NSNotificationCenter defaultCenter] postNotificationName:Chat_DestinationChanged object:self];

	}

}

- (NSString *)uniqueChatID

{

	if (!uniqueChatID) {

		if (self.isGroupChat) {

			uniqueChatID = [[NSString alloc] initWithFormat:@"%@.%i", self.name, nextChatNumber++];

		} else {			

			uniqueChatID = [self.listObject.internalObjectID retain];

		}

		if (!uniqueChatID) {

			uniqueChatID = [[NSString alloc] initWithFormat:@"UnknownChat.%i", nextChatNumber++];

			NSLog(@"Warning: Unknown chat %p",self);

		}

	}

	return uniqueChatID;

}

- (void)clearUniqueChatID

{

	[uniqueChatID release]; uniqueChatID = nil;

}

- (NSString *)internalObjectID

{

	return self.uniqueChatID;

}

//Content --------------------------------------------------------------------------------------------------------------

#pragma mark Content

/*!

 * @brief Informs the chat that the core and the account are ready to begin filtering and sending a content object

 *

 * If there is only one object in pendingOutgoingContentObjects after adding inObject, we should send immedaitely.

 * However, if other objects are in it, we should wait for them to be removed, as they are chronologically first.

 * If we are asked if we should begin sending the earliest object in pendingOutgoingContentObjects, the answer is YES.

 *

 * @param inObject The object being sent

 * @result YES if the object should be sent immediately; NO if another object is in process so we should wait

 */

- (BOOL)shouldBeginSendingContentObject:(AIContentObject *)inObject

{

	NSInteger	currentIndex = [pendingOutgoingContentObjects indexOfObjectIdenticalTo:inObject];

	//Don't add the object twice when we are called from -[AIChat finishedSendingContentObject]

	if (currentIndex == NSNotFound) {

		[pendingOutgoingContentObjects addObject:inObject];		

	}

	return pendingOutgoingContentObjects.count == 1 || currentIndex == 0;

}

/*!

 * @brief Informs the chat that an outgoing content object was sent and dispalyed.

 *

 * It is no longer pending, so we remove it from that array.

 * If there are more pending objects, trigger sending the next.

 *

 * @param inObject The object with which we are finished

 */

- (void)finishedSendingContentObject:(AIContentObject *)inObject

{

	[pendingOutgoingContentObjects removeObjectIdenticalTo:inObject];

	if (pendingOutgoingContentObjects.count) {

		[adium.contentController sendContentObject:[pendingOutgoingContentObjects objectAtIndex:0]];

	}

}

- (AIChatSendingAbilityType)messageSendingAbility

{

	AIChatSendingAbilityType sendingAbilityType;

	if (self.isGroupChat) {

		if (self.account.online) {

			//XXX Liar!

			sendingAbilityType = AIChatCanSendMessageNow;

		} else {

			sendingAbilityType = AIChatCanNotSendMessage;

		}

	} else {

		if (self.account.online) {

			AIListContact *listObject = self.listObject;

			if (listObject.online || listObject.isStranger) {

				sendingAbilityType = AIChatCanSendMessageNow;

			} else if ([self.account canSendOfflineMessageToContact:listObject]) {

				sendingAbilityType = AIChatCanSendViaServersideOfflineMessage;				

			} else if ([self.account maySendMessageToInvisibleContact:listObject]) {

				sendingAbilityType = AIChatMayNotBeAbleToSendMessage;	

			} else {

				sendingAbilityType = AIChatCanNotSendMessage;

			}

		} else {

			sendingAbilityType = AIChatCanNotSendMessage;

		}		

	}

	return sendingAbilityType;

}

- (BOOL)canSendImages

{

	return [self.account canSendImagesForChat:self];

}

- (NSUInteger)unviewedContentCount

{

	return [self integerValueForProperty:KEY_UNVIEWED_CONTENT];

}

- (NSUInteger)unviewedMentionCount

{

	return [self integerValueForProperty:KEY_UNVIEWED_MENTION];	

}

- (void)incrementUnviewedContentCount

{

	int currentUnviewed = [self integerValueForProperty:KEY_UNVIEWED_CONTENT];

	[self setValue:[NSNumber numberWithInt:(currentUnviewed+1)]

					 forProperty:KEY_UNVIEWED_CONTENT

					 notify:NotifyNow];

}

- (void)incrementUnviewedMentionCount

{

	int currentUnviewed = [self integerValueForProperty:KEY_UNVIEWED_MENTION];

	[self setValue:[NSNumber numberWithInt:(currentUnviewed+1)]

	   forProperty:KEY_UNVIEWED_MENTION

			notify:NotifyNow];

}

- (void)clearUnviewedContentCount

{

	// We also want to clear mention for the same situations we clear normal content.

	[self setValue:nil forProperty:KEY_UNVIEWED_MENTION notify:NotifyNow];

	[self setValue:nil forProperty:KEY_UNVIEWED_CONTENT notify:NotifyNow];

}

#pragma mark Logging

- (BOOL)shouldLog

{

	return [self.account shouldLogChat:self];

}

#pragma mark AIContainingObject protocol

//AIContainingObject protocol

- (NSArray *)visibleContainedObjects

{

	return self.containedObjects;

}

- (NSArray *)containedObjects

{

	return [[participatingContacts copy] autorelease];

}

- (NSUInteger)countOfContainedObjects

{

	return [participatingContacts count];

}