/* 

  * 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/AIAbstractAccount.h>

 #import <Adium/AIAccount.h>

 #import <Adium/AIListContact.h>

 #import <Adium/AIListGroup.h>

 #import <Adium/AIContentMessage.h>

 #import <Adium/AIContentNotification.h>

 #import <Adium/AIService.h>

 #import <Adium/AIChat.h>

 #import <Adium/ESFileTransfer.h>

 #import "AIStatusItem.h"

 #import "AIStatus.h"

 #import "AdiumAccounts.h"

 #import <Adium/AIContactControllerProtocol.h>

 #import <Adium/AIContentControllerProtocol.h>

 #import <Adium/AIAccountControllerProtocol.h>

 #import "DCJoinChatViewController.h"

 #import "AIChatControllerProtocol.h"

 #import "AIMessageWindowController.h"

 #import "AIMessageWindow.h"

 #import "AIInterfaceControllerProtocol.h"

 #import "AIStatusControllerProtocol.h"

 #define NEW_ACCOUNT_DISPLAY_TEXT			AILocalizedString(@"<New Account>", "Placeholder displayed as the name of a new account")

 @interface AIAccountDeletionDialog : NSObject <AIAccountControllerRemoveConfirmationDialog> {

 	AIAccount *account;

 	NSAlert *alert;

 	id userData;

 }

 - (id)initWithAccount:(AIAccount*)ac alert:(NSAlert*)al;

 @property (readwrite, retain, nonatomic) id userData;

 - (void)alertDidEnd:(NSAlert *)alert returnCode:(int)returnCode contextInfo:(void *)contextInfo;

 @end

 @implementation AIAccountDeletionDialog

 - (id)initWithAccount:(AIAccount*)ac alert:(NSAlert*)al {

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

 		account = ac;

 		alert = [al retain];

 	}

 	return self;

 }

 - (void)dealloc {

 	[alert release];

 	[userData release];

 	[super dealloc];

 }

 @synthesize userData;

 - (void)runModal {

 	[self alertDidEnd:alert returnCode:[alert runModal] contextInfo:NULL];

 }

 - (void)beginSheetModalForWindow:(NSWindow*)window {

 	[alert beginSheetModalForWindow:window modalDelegate:self didEndSelector:@selector(alertDidEnd:returnCode:contextInfo:) contextInfo:NULL];

 }

 - (void)alertDidEnd:(NSAlert *)alert returnCode:(int)returnCode contextInfo:(void *)contextInfo {

 	[account alertForAccountDeletion:self didReturn:returnCode];

 }

 @end

 //Proxy types for applescript

 typedef enum

 {

 	Adium_Proxy_HTTP_AS = 'HTTP',

 	Adium_Proxy_SOCKS4_AS = 'SCK4',

 	Adium_Proxy_SOCKS5_AS = 'SCK5',

 	Adium_Proxy_Default_HTTP_AS = 'DHTP',

 	Adium_Proxy_Default_SOCKS4_AS = 'DSK4',

 	Adium_Proxy_Default_SOCKS5_AS = 'DSK5',

 	Adium_Proxy_None_AS = 'NONE'

 } AdiumProxyTypeApplescript;

 @interface AIAccount(AppleScriptPRIVATE)

 - (AdiumProxyType)proxyTypeFromApplescript:(AdiumProxyTypeApplescript)proxyTypeAS;

 - (AdiumProxyTypeApplescript)applescriptProxyType:(AdiumProxyType)proxyType;

 @end

 /*!

  * @class AIAccount

  * @brief An account

  *

  * This abstract class represents an account the user has setup in Adium.  Subclass this for every service.

  */

 @implementation AIAccount

 /*!

  * @brief Init Account

  *

  * Init this account instance

  */

 - (void)initAccount

 {

 }

 /*!

  * @brief Connect

  *

  * Connect the account, transitioning it into an online state.

  */

 - (void)connect

 {

 	//We are connecting

 	[self setValue:[NSNumber numberWithBool:YES] forProperty:@"Connecting" notify:NotifyNow];

 }

 /*!

  * @brief rejoinChat

  * 

  * Rejoin the open group chats after disconnect

  */

 -(BOOL)rejoinChat:(AIChat*)chat

 {

 	return NO;

 }	

 /*!

  * @brief Do group chats support topics?

  */

 - (BOOL)groupChatsSupportTopic

 {

 	return NO;

 }

 /*!

  * @brief Set a chat's topic

  *

  * This only has an effect on group chats.

  */

 - (void)setTopic:(NSString *)topic forChat:(AIChat *)chat

 {

 }

 /*!

  * @brief Disconnect

  *

  * Disconnect the account, transitioning it into an offline state.

  */

 - (void)disconnect

 {

 	[self cancelAutoReconnect];

 	[self setValue:nil forProperty:@"Connecting" notify:NotifyLater];

 	[self notifyOfChangedPropertiesSilently:NO];

 }

 /*!

  * @brief Disconnect as a result of the network connection dropping out

  *

  * The default implementation is identical to [self disconect], but subclasses may want to act differently

  * if the network connection is gone than if the user chose to disconnect.

  *

  * Subclasses should call super's implementation.

  */

 - (void)disconnectFromDroppedNetworkConnection

 {

 	[self disconnect];

 }

 /*!

  * @brief Register an account

  *

  * Register an account on this service using the currently entered information.  This is for services which support

  * in-client registration such as jabber.

  */

 - (void)performRegisterWithPassword:(NSString *)inPassword

 {

 }

 /*!

  * @brief The UID will be changed. The account has a chance to perform modifications

  *

  * For example, MSN adds \@hotmail.com to the proposedUID and returns the new value

  *

  * @param proposedUID The proposed, pre-filtered UID (filtered means it has no characters invalid for this servce)

  * @result The UID to use; the default implementation just returns proposedUID.

  */

 - (NSString *)accountWillSetUID:(NSString *)proposedUID

 {

 	return proposedUID;

 }

 /*!

  * @brief The account's UID changed

  */

 - (void)didChangeUID

 {

 }

 /*!

  * @brief The account will be deleted

  *

  * The default implementation disconnects the account.  Subclasses should call super's implementation.

  * If asynchronous behavior is required, the next three methods should be overridden instead.

  */

 - (void)willBeDeleted

 {

 	[self setShouldBeOnline:NO];

 	//Remove our contacts immediately.

 	[self removeAllContacts];

 }

 /*!

  * @brief Perform the deletion of this account

  *

  * This should be called only after proper confirmation has been made by the user.

  */

 - (void)performDelete

 {

 	[adium.accountController deleteAccount:self];

 }

 - (id<AIAccountControllerRemoveConfirmationDialog>)confirmationDialogForAccountDeletion

 {

 	//Will be released in alertForAccountDeletion:didReturn:

 	return [[AIAccountDeletionDialog alloc] initWithAccount:self alert:[self alertForAccountDeletion]];

 }

 /*!

  * @brief The alert used for confirming the account deletion

  *

  * Meant for subclassers. By default, returns the dialog that asks the user if the account should really be deleted (and how).

  */

 - (NSAlert*)alertForAccountDeletion

 {

 	return [NSAlert alertWithMessageText:AILocalizedString(@"Delete Account",nil)

 						   defaultButton:AILocalizedString(@"Delete",nil)

 						 alternateButton:AILocalizedString(@"Cancel",nil)

 							 otherButton:nil

 			   informativeTextWithFormat:AILocalizedString(@"Delete the account %@?",nil), ([self.formattedUID length] ? self.formattedUID : NEW_ACCOUNT_DISPLAY_TEXT)];

 }

 /*!

  * @brief The dialog asking for confirmation for deleting the account did return.

  *

  * @param dialog The dialog that has completed

  * @param returnCode One of the regular NSAlert return codes

  *

  * This method should be overridden when alertForAccountDeletion: was overridden, and/or asynchronous behavior is required.

  * This implementation disconnects and deletes the account from the accounts list when returnCode == NSAlertDefaultReturn.

  *

  * If this implementation is not called, dialog should be released by the subclass.

  */

 - (void)alertForAccountDeletion:(id<AIAccountControllerRemoveConfirmationDialog>)dialog didReturn:(int)returnCode

 {

 	if(returnCode == NSAlertDefaultReturn) {

 		[self performDelete];

 	}

 	[(AIAccountDeletionDialog*)dialog release];

 }

 /*!

  * @brief A formatted UID which may include additional necessary identifying information.

  *

  * For example, an AIM account (tekjew) and a .Mac account (tekjew@mac.com, entered only as tekjew) may appear identical

  * without service information (tekjew). The explicit formatted UID is therefore tekjew@mac.com

  */

 - (NSString *)explicitFormattedUID

 {

 	return self.formattedUID;

 }

 /*!

  * @brief Use our host for the servername when storing password

  *

  * This should be YES for services which depend upon server information. For example, a password for an IRC account

  * is uniqued by what server it is on.

  */

 - (BOOL)useHostForPasswordServerName

 {

 	return NO;

 }

 /*!

  * @brief Use our internal object ID for the username when storing password

  *

  * For accounts whose signup process may not be contingent upon the UID. For example, a Twitter account using OAuth might

  * not know its UID when it wants to save itself.

  */

 - (BOOL)useInternalObjectIDForPasswordName

 {

 	return NO;

 }

 //Properties -----------------------------------------------------------------------------------------------------------

 #pragma mark Properties

 /*!

  * @brief Send Autoresponses while away

  *

  * Subclass to alter the behavior of this account with regards to autoresponses.  Certain services expect the client to

  * auto-respond with away messages.  Adium will provide this behavior automatically if desired.

  */

 - (BOOL)supportsAutoReplies

 {

 	return NO;

 }

 /*!

  * @brief Disconnect on fast user switch

  *

  * It may be required for a service to disconnect when logged in users change.  If this is the case, subclass this

  * method to return YES and Adium will automatically disconnect and reconnect on FUS events.

  */

 - (BOOL)disconnectOnFastUserSwitch

 {

 	return NO;

 }

 /*!

  * @brief Connectivity based on network reachability

  *

  * By default, accounts are automatically disconnected and reconnected when network reachability changes.  Accounts

  * that do not require persistent network connections can choose to disable this by returning NO from this method.

  */

 - (BOOL)connectivityBasedOnNetworkReachability

 {

 	return YES;

 }

 /*!

  * @brief Suppress typing notifications after send

  *

  * Some protocols require a 'Stopped typing' notification to be sent along with an instant message.  Other protocols

  * implicitly assume that typing has stopped with an incoming message and the extraneous typing notification may cause

  * strange behavior.  Return YES from this method to suppress the sending of a stopped typing notification along with

  * messages.

  */

 - (BOOL)suppressTypingNotificationChangesAfterSend

 {

 	return NO;

 }

 /*!

  * @brief Support server-side storing of messages to offline users?

  *

  * Some protocols store messages to offline contacts on the server. Subclasses may return YES if their service supports 

  * this. Adium will not store the message as an Event, and will just send it along to the server. This may cause a Gaim

  * error on Jabber if the Jabber server they are using is down.

  */

 - (BOOL)canSendOfflineMessageToContact:(AIListContact *)inContact

 {

 	return NO;

 }

 /*!

  * @brief Support messaging invisible contacts?

  *

  * This will only be called if the protocol returns NO to -[self canSendOfflineMessageToContact:] 

  * If invisible contacts exist and can be messaged, return YES.

  * If the protocol has no concept of invisible contacts, or invisible contacts can't be messaged, return NO.

  */

 - (BOOL)maySendMessageToInvisibleContact:(AIListContact *)inContact

 {

 	return YES;

 }

 /*!

  * @brief Should offline messages be sent without prompting the user?

  *

  * If -[self canSendOfflineMessageToContact:] returns YES, Adium typically asks the user whether or not to send a message

  * to be stored on the server. If sendOfflineMessagesWithoutPrompting returns YES, this prompt is always suppressed.

  *

  * This should only be true if offline messaging is a well-established expectation for the service. We assume that

  * this is the case by default.

  */

 - (BOOL)sendOfflineMessagesWithoutPrompting

 {

 	return YES;

 }

 /*!

  * @brief Does the account itself display file transfer messages in chat windows?

  *

  * If YES, Adium won't attempt to display messages in chat windows regarding file transfers.

  * If NO, Adium automatically displays appropriate messages in open chats.

  */

 - (BOOL)accountDisplaysFileTransferMessages

 {

 	return NO;

 }

 /*!

  * @brief Does the account manage its own cache of serverside contact icons?

  */

 - (BOOL)managesOwnContactIconCache

 {

 	return NO;

 }

 /*!

  * @brief Called once the display name has been properly filtered

  *

  * Subclasses may override to pass this name on to the server if appropriate.

  * Super's implementation should then be called.

  */

 - (void)gotFilteredDisplayName:(NSAttributedString *)attributedDisplayName

 {

 	[self updateLocalDisplayNameTo:attributedDisplayName];

 }

 - (NSImage *)userIcon

 {

 	NSData	*iconData = [self userIconData];

 	return (iconData ? [[[NSImage alloc] initWithData:iconData] autorelease] : nil);

 }

 @synthesize isTemporary;

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

 #pragma mark Status

 /*!

  * @brief Supported properties

  *

  * Returns an array of properties supported by this account.  This account will not be informed of changes to keys

  * it does not support.  Available keys are:

  *   @"Display Name", @"Online", @"Offline", @"IdleSince", @"IdleManuallySet", @"User Icon"

  *   @"TextProfile", @"DefaultUserIconFilename", @"StatusState"

  * @return NSSet of supported keys

  */

 - (NSSet *)supportedPropertyKeys

 {

 	static	NSSet	*supportedPropertyKeys = nil;

 	if (!supportedPropertyKeys) {

 		supportedPropertyKeys = [[NSSet alloc] initWithObjects:

 			@"Online",

 			@"FormattedUID",

 			KEY_ACCOUNT_DISPLAY_NAME,

 			@"Display Name",

 			@"StatusState",

 			KEY_USE_USER_ICON, KEY_USER_ICON, KEY_DEFAULT_USER_ICON,

 			@"Enabled",

 			nil];

 	}

 	return supportedPropertyKeys;

 }

 /*!

  * @brief Status for key

  *

  * Returns the status this account should be for a specific key

  * @param key Property

  * @return id Status value

  */

 - (id)statusForKey:(NSString *)key

 {

 	return [self preferenceForKey:key group:GROUP_ACCOUNT_STATUS];

 }

 /*!

  * @brief Update account status

  *

  * Update account status for the changed key.  This is called when account status changes Adium-side and the account

  * code should update status account/server side in response.  The new value for the key can be accessed using

  * the statusForKey method.

  * @param key The updated property

  */

 - (void)updateStatusForKey:(NSString *)key

 {

 	[self updateCommonStatusForKey:key];

 }

 /*!

  * @brief Update contact status

  *

  * Adium is requesting that the account update a contact's status.  This method is primarily called by the get info

  * window.  Since this is called sparsely, accounts may choose to look up additional information such as profiles

  * in response to this.  Adium guards this method to prevent it from being called too rapidly, so expensive lookups

  * are not a problem if the delayedUpdateStatusInterval is set correctly.

  */

 - (void)delayedUpdateContactStatus:(AIListContact *)inContact

 {

 }

 /*!

  * @brief Update contact interval

  *

  * Specifies the mininum interval at which delayedUpdateContactStatus will be called.  If the account code is performing

  * expensive operations (such as profile or web lookups) in response to updateContactStatus, it can guard against

  * the lookups being performed too frequently by returning an interval here.

  */

 - (float)delayedUpdateStatusInterval

 {

 	return 0.5;

 }

 /*!

  * @brief Perform the setting of a status state

  *

  * Sets the account to a passed status state.  The account should set itself to best possible status given the return

  * values of statusState's accessors.  The passed statusMessage has been filtered; it should be used rather than

  * statusState.statusMessage, which returns an unfiltered statusMessage.

  *

  * @param statusState The state to enter

  * @param statusMessage The filtered status message to use.

  */

 - (void)setStatusState:(AIStatus *)statusState usingStatusMessage:(NSAttributedString *)statusMessage

 {

 }

 /*!

  * @brief Set the social networking status message for this account

  *

  * This will only be called if [self.service isSocialNetworkingService] returns TRUE.

  *

  * @param statusMessage The status message, which has already been filtered.

  */

 - (void)setSocialNetworkingStatusMessage:(NSAttributedString *)statusMessage

 {

 }

 /*!

  * @brief Should the autorefreshing attributed string associated with a key be updated at the moment?

  *

  * The default implementation causes all dynamic strings which need updating to be updated if the account is

  * online.  Subclasses may choose to implement more complex logic; for example, a nickname seen only in a chat

  * might be updated only if a chat is open.

  */

 - (BOOL)shouldUpdateAutorefreshingAttributedStringForKey:(NSString *)inKey

 {

 	return self.online;

 }

 //Messaging, Chatting, Strings -----------------------------------------------------------------------------------------

 #pragma mark Messaging, Chatting, Strings

 /*!

  * @brief Available for sending content

  *

  * Returns YES if the contact is available for receiving content of the specified type.  If contact is nil, instead

  * check for the availiability to send any content of the given type.

  *

  * The default implementation indicates the account, if online, can send messages to any online contact.

  * It can also send files to any online contact if the account subclass conforms to the AIAccount_Files protocol.

  *

  * @param inType A string content type

  * @param inContact The destination contact, or nil to check global availability

  */

 - (BOOL)availableForSendingContentType:(NSString *)inType toContact:(AIListContact *)inContact

 {

 	if ([inType isEqualToString:CONTENT_MESSAGE_TYPE] ||

 		[inType isEqualToString:CONTENT_NOTIFICATION_TYPE]) {

 		return (self.online &&

 				(!inContact || inContact.online || inContact.isStranger || [self canSendOfflineMessageToContact:inContact]));

 	} else if ([inType isEqualToString:CONTENT_FILE_TRANSFER_TYPE]) {

 		return (self.online && [self conformsToProtocol:@protocol(AIAccount_Files)] &&

 				(!inContact || inContact.online || inContact.isStranger));

 	}

 	return NO;

 }

 /*!

  * @brief Open a chat

  *

  * Open the passed chat account-side.  Depending on the protocol, account code may need to establish a connection in

  * response to this method or perhaps make no actions at all.  This method is used by both one-on-one chats and

  * multi-user chats.

  * @param chat The chat to open

  * @return YES on success

  */

 - (BOOL)openChat:(AIChat *)chat

 {

 	return NO;

 }

 /*!

  * @brief Close a chat

  *

  * Close the passed chat account-side.  Depending on the protocol, account code may need to close a connection in

  * response to this method or perhaps make no actions at all.  This method is used by both one-on-one chats and

  * multi-user chats.

  *

  * This method should *only* be called by a core controller.  Call [adium.interfaceController closeChat:chat] to perform a close from other code.

  *

  * @param chat The chat to close

  * @return YES on success

  */

 - (BOOL)closeChat:(AIChat *)chat

 {

 	return NO;

 }

 /*!

  * @brief Invite a contact to an open chat

  *

  * Invite a contact to the passed chat, if supported by the protocol and the specific chat instance.  An invite

  * message is provided as a convenience to protocols that require or support one.

  * @param contact AIListObject to invite

  * @param chat AIChat they are being invited to

  * @param inviteMessage NSString invite message for the invited contact

  * @return YES on success

  */

 - (BOOL)inviteContact:(AIListObject *)contact toChat:(AIChat *)chat withMessage:(NSString *)inviteMessage

 {

 	NSLog(@"invite contact to chat with message");

 	return NO;

 }

 /*!

  * @brief Send a typing object

  *

  * The content object contains all the necessary information for sending,

  * including the destination contact.

  */

 - (void)sendTypingObject:(AIContentTyping *)inTypingObject

 {

 }

 /*!

  * @brief Send a message

  *

  * The content object contains all the necessary information for sending,

  * including the destination contact. [inMessageObject encodedMessage] contains the NSString which should be sent.

  */

 - (BOOL)sendMessageObject:(AIContentMessage *)inMessageObject

 {

 	return NO;

 }

 /*!

  * @brief Does the account support sending notifications?

  */

 - (BOOL)supportsSendingNotifications

 {

 	return NO;

 }

 /*!

  * @brief Send a notification

  */

 - (BOOL)sendNotificationObject:(AIContentNotification *)inContentNotification

 {

 	return NO;

 }

 /*!

  * @brief Encode attributed string (generic)

  *

  * Encode an NSAttributedString into a NSString for this account.  Accounts that support formatted text or require

  * special encoding on strings should do that work here.  For example, HTML based accounts should convert the 

  * NSAttributedString to HTML appropriate for their protocol (Adium can help with this).

  * @param inAttributedString String to encode

  * @param inListObject List object associated with the string; nil if the string is not associated with a particular list object, which is the case if encoding for a status message or a group chat message.

  * @return NSString result from encoding

  */

 - (NSString *)encodedAttributedString:(NSAttributedString *)inAttributedString forListObject:(AIListObject *)inListObject

 {

     return [inAttributedString string];

 }

 /*!

  * @brief Encode attributed string to send as a message

  */

 - (NSString *)encodedAttributedStringForSendingContentMessage:(AIContentMessage *)inContentMessage

 {

     return [self encodedAttributedString:inContentMessage.message forListObject:[inContentMessage destination]];

 }

 /*!

  * @brief Should an autoreply be sent to this message?

  *

  * This will only be called if the generic algorithm determines that an autoreply is appropriate. The account

  * gets an opportunity to suppress sending the autoreply, e.g. on the basis of the message's content or source.

  */

 - (BOOL)shouldSendAutoreplyToMessage:(AIContentMessage *)message

 {

 	return YES;

 }

 //Presence Tracking ----------------------------------------------------------------------------------------------------

 #pragma mark Presence Tracking

 /*!

  * @brief Contact list editable?

  *

  * @return YES if the contact list is currently editable

  */

 - (BOOL)contactListEditable

 {

 	return NO;

 }

 /*!

  * @brief Add contacts

  *

  * Add contacts to a group on this account.  Create the group if it doesn't already exist.

  * @param objects NSArray of AIListContact objects to add

  * @param group AIListGroup destination for contacts

  */

 - (void)addContact:(AIListContact *)contact toGroup:(AIListGroup *)group

 {

 	//XXX - Our behavior for duplicate contacts isn't specified here.  Should we handle that adium-side automatically? -ai

 }

 /*!

  * @brief Remove contacts

  *

  * Remove contacts from this account.

  * @param objects NSArray of AIListContact objects to remove

  * @param groups NSArray of AIListGroup objects to remove from.

  */

 - (void)removeContacts:(NSArray *)objects fromGroups:(NSArray *)groups

 {

 }

 /*!

  * @brief Remove a group

  *

  * Remove a group from this account.

  * @param group AIListGroup to remove

  */

 - (void)deleteGroup:(AIListGroup *)group

 {

 	//XXX - Adium's current behavior is to delete all the contacts within a group, and then delete the group.  This is innefficient on protocols which support deleting groups. -ai

 }

 /*!

  * @brief Move contacts

  *

  * Move existing contacts to a specific group on this account.  The passed contacts should already exist somewhere on

  * this account.

  * @param objects NSArray of AIListContact objects to remove

  * @param oldGroups NSSet of AIListGroup source for contacts

  * @param group NSSet of AIListGroup destination for contacts

  */

 - (void)moveListObjects:(NSArray *)objects fromGroups:(NSSet *)oldGroups toGroups:(NSSet *)groups

 {

 	NSAssert(NO, @"Should not be reached");

 }

 /*!

  * @brief Rename a group

  *

  * Rename a group on this account.

  * @param group AIListGroup to rename

  * @param newName NSString name for the group

  */

 - (void)renameGroup:(AIListGroup *)group to:(NSString *)newName

 {

 	NSAssert(NO, @"Should not be reached");

 }

 /*!

  * @brief Menu items for contact

  *

  * Returns an array of menu items for a contact on this account.  This is the best place to add protocol-specific

  * actions that aren't otherwise supported by Adium.

  * @param inContact AIListContact for menu items

  * @return NSArray of NSMenuItem instances for the passed contact

  */

 - (NSArray *)menuItemsForContact:(AIListContact *)inContact

 {

 	return nil;

 }

 /*!

  * @brief Menu items for chat

  *

  * Returns an array of menu items for a chat on this account.  This is the best place to add protocol-specific

  * actions that aren't otherwise supported by Adium.

  * @param inChat AIChat for menu items

  * @return NSArray of NSMenuItem instances for the passed contact

  */

 - (NSArray *)menuItemsForChat:(AIChat *)inChat

 {

 	return nil;

 }

 /*!

  * @brief Menu items for the account's actions

  *

  * Returns an array of menu items for account-specific actions.  This is the best place to add protocol-specific

  * actions that aren't otherwise supported by Adium.  It will only be queried if the account is online.

  * @return NSArray of NSMenuItem instances for this account

  */

 - (NSArray *)accountActionMenuItems

 {

 	return nil;

 }

 /*!

  * @brief The account menu item was updated

  *

  * This method allows the opportunity to update the account menu item, e.g. to add information to it

  */

 - (void)accountMenuDidUpdate:(NSMenuItem*)menuItem

 {

 }

 /*!

  * @brief Is a contact on the contact list intentionally listed?

  *

  * By default, it is assumed that any contact on the list is intended be there.

  * This is used by AIListContact to determine if the prescence of itself on the list is indicative of a degree

  * of trust, for preferences such as "automatically accept files from contacts on my contact list".

  */

 - (BOOL)isContactIntentionallyListed:(AIListContact *)contact

 {

 	return YES;

 }

 /*!

  * @brief Return the data for the serverside icon for a contact

  */

 - (NSData *)serversideIconDataForContact:(AIListContact *)contact

 {

 	return nil;

 }

 #pragma mark Secure messsaging

 /*!

  * @brief Allow secure messaging toggling on a chat?

  *

  * Returns YES if secure (encrypted) messaging's status for this chat should be able to be changed.

  * This allows the account to determine on a per-chat basis whether the chat's initial security setting should be permanently

  * maintained.  If it returns NO, the user can not request for the chat to become encrypted or unencrypted.

  * This is currently implemented by Gaim accounts to return YES for one-on-one chats and NO for group chats to indicate

  * the functionality provided by Off-the-Record Messaging (OTR).

  *

  * @param inChat The query chat 

  * @result Should the state of secure messaging be allowed to change?

  */

 - (BOOL)allowSecureMessagingTogglingForChat:(AIChat *)inChat

 {

 	//Allow secure messaging via OTR for one-on-one chats

 	return !inChat.isGroupChat;

 }

 /*!

  * @brief Provide a localized description of the encryption this account provides

  *

  * Returns a localized string which describes the encryption this account supports.

  *

  * @result An <tt>NSString</tt> describing the encryption offerred by this account, if any.

  */

 - (NSString *)aboutEncryption

 {

 	return [NSString stringWithFormat:

 		AILocalizedStringFromTableInBundle(@"Adium provides encryption, authentication, deniability, and perfect forward secrecy over %@ via Off-the-Record Messaging (OTR). If your contact is not using an OTR-compatible messaging system, your contact will be sent a link to the OTR web site when you attempt to connect. For more information on OTR, visit http://www.cypherpunks.ca/otr/.", nil, [NSBundle bundleForClass:[AIAccount class]], nil),

 		[self.service shortDescription]];

 }

 /*!

  * @brief Start or stop secure messaging in a chat

  *

  * @param inSecureMessaging The desired state of the chat in terms of encryption

  * @param inChat The chat to change

  */

 - (void)requestSecureMessaging:(BOOL)inSecureMessaging

 						inChat:(AIChat *)inChat

 {

 	[adium.contentController requestSecureOTRMessaging:inSecureMessaging

 												  inChat:inChat];

 }

 /*!

  * @brief Allow the user to verify (or unverify) the identity being used for encryption in a chat

  *

  * It is an error to call this on a chat which is not currently encrypted.

  *

  * @param inChat The chat

  */

 - (void)promptToVerifyEncryptionIdentityInChat:(AIChat *)inChat

 {

 	[adium.contentController promptToVerifyEncryptionIdentityInChat:inChat];

 }

 #pragma mark Image sending

 /*!

  * @brief Can the account send images inline within a chat?

  */

 - (BOOL)canSendImagesForChat:(AIChat *)inChat