/* 

 * 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.

 */

// $Id$

#import "AIInterfaceController.h"

#import <Adium/AIAccountControllerProtocol.h>

#import <Adium/AIContactControllerProtocol.h>

#import <Adium/AIChatControllerProtocol.h>

#import <Adium/AIContentControllerProtocol.h>

#import <Adium/AIMenuControllerProtocol.h>

#import <Adium/AIAuthorizationRequestsWindowController.h>

#import <AIUtilities/AIAttributedStringAdditions.h>

#import <AIUtilities/AIColorAdditions.h>

#import <AIUtilities/AIFontAdditions.h>

#import <AIUtilities/AIImageDrawingAdditions.h>

#import <AIUtilities/AIMenuAdditions.h>

#import <AIUtilities/AIStringAdditions.h>

#import <AIUtilities/AITooltipUtilities.h>

#import <AIUtilities/AIWindowAdditions.h>

#import <AIUtilities/AITextAttributes.h>

#import <AIUtilities/AIWindowControllerAdditions.h>

#import <Adium/AIChat.h>

#import <Adium/AIListContact.h>

#import <Adium/AIListGroup.h>

#import <Adium/AIListObject.h>

#import <Adium/AIMetaContact.h>

#import <Adium/AIService.h>

#import <Adium/AIServiceIcons.h>

#import <Adium/AISortController.h>

#import "AIMessageTabViewItem.h"

#import "KNShelfSplitview.h"

#import <Adium/AIContactList.h>

#import "AIMessageViewController.h"

#define ERROR_MESSAGE_WINDOW_TITLE		AILocalizedString(@"Adium : Error","Error message window title")

#define LABEL_ENTRY_SPACING				4.0

#define DISPLAY_IMAGE_ON_RIGHT			NO

#define PREF_GROUP_FORMATTING			@"Formatting"

#define KEY_FORMATTING_FONT				@"Default Font"

#define MESSAGES_WINDOW_MENU_TITLE		AILocalizedString(@"Chats","Title for the messages window menu item")

//#define	LOG_RESPONDER_CHAIN

@interface AIInterfaceController ()

- (void)_resetOpenChatsCache;

- (void)_addItemToMainMenuAndDock:(NSMenuItem *)item;

- (NSAttributedString *)_tooltipTitleForObject:(AIListObject *)object;

- (NSAttributedString *)_tooltipBodyForObject:(AIListObject *)object;

- (void)_pasteWithPreferredSelector:(SEL)preferredSelector sender:(id)sender;

- (void)updateCloseMenuKeys;

- (void)saveContainers;

- (void)restoreSavedContainers;

//Window Menu

- (void)updateActiveWindowMenuItem;

- (void)buildWindowMenu;

- (AIChat *)mostRecentActiveChat;

@end

/*!

 * @class AIInterfaceController

 * @brief Interface controller

 *

 * Chat window related requests, such as opening and closing chats, are routed through the interface controller

 * to the appropriate component. The interface controller keeps track of the most recently active chat, handles chat

 * cycling (switching between chats), chat sorting, and so on.  The interface controller also handles switching to

 * an appropriate window or chat when the dock icon is clicked for a 'reopen' event.

 *

 * Contact list window requests, such as toggling window visibilty are routed to the contact list controller component.

 *

 * Error messages are routed through the interface controller.

 *

 * Tooltips, such as seen on hover in the contact list are generated and displayed here.  Tooltip display components and

 * plugins register with the interface controller to be queried for contact information when a tooltip is displayed.

 *

 * When displays in Adium flash, such as in the dock or the contact list for unviewed content, the interface controller

 * manages keeping the flashing synchronized.

 *

 * Finally, the interface controller manages many menu items, providing better menu item validation and target routing

 * than the responder chain alone would do.

 */

@implementation AIInterfaceController

- (id)init

{

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

		contactListViewArray = [[NSMutableArray alloc] init];

		messageViewArray = [[NSMutableArray alloc] init];

		contactListTooltipEntryArray = [[NSMutableArray alloc] init];

		contactListTooltipSecondaryEntryArray = [[NSMutableArray alloc] init];

		closeMenuConfiguredForChat = NO;

		_cachedOpenChats = nil;

		mostRecentActiveChat = nil;

		activeChat = nil;

		tooltipListObject = nil;

		tooltipTitle = nil;

		tooltipBody = nil;

		tooltipImage = nil;

		flashObserverArray = nil;

		flashTimer = nil;

		flashState = 0;

		windowMenuArray = nil;

#ifdef LOG_RESPONDER_CHAIN

		[NSTimer scheduledTimerWithTimeInterval:2.0 target:self selector:@selector(reportResponderChain:) userInfo:nil repeats:YES];

#endif

	}

	return self;

}

#ifdef LOG_RESPONDER_CHAIN

//Can be called by a timer to periodically log the responder chain

//[NSTimer scheduledTimerWithTimeInterval:2.0 target:self selector:@selector(reportResponderChain:) userInfo:nil repeats:YES];

- (void)reportResponderChain:(NSTimer *)inTimer

{

	NSMutableString	*responderChain = [NSMutableString string];

	NSWindow	*keyWindow = [[NSApplication sharedApplication] keyWindow];

#warning 64BIT: Check formatting arguments

	[responderChain appendFormat:@"%@ (%i): ",keyWindow,[keyWindow respondsToSelector:@selector(print:)]];

	NSResponder	*responder = [keyWindow firstResponder];

	//First, walk down the responder chain looking for a responder which can handle the preferred selector

	while (responder) {

#warning 64BIT: Check formatting arguments

		[responderChain appendFormat:@"%@ (%i)",responder,[responder respondsToSelector:@selector(print:)]];

		responder = [responder nextResponder];

		if (responder) [responderChain appendString:@" -> "];

	}

	NSLog(responderChain);

}

#endif

- (void)controllerDidLoad

{

    //Load the interface

    [interfacePlugin openInterface];

	//Open the contact list window

    [self showContactList:nil];

	//Userlist show/hide item

	menuItem_toggleUserlist = [[NSMenuItem allocWithZone:[NSMenu menuZone]] initWithTitle:AILocalizedString(@"Toggle User List", nil)

																							 target:self

																							 action:@selector(toggleUserlist:)

																					  keyEquivalent:@"/"];

	[menuItem_toggleUserlist setKeyEquivalentModifierMask:(NSCommandKeyMask | NSAlternateKeyMask)];

	[adium.menuController addMenuItem:menuItem_toggleUserlist toLocation:LOC_Display_General];

	menuItem_toggleUserlistSide = [[NSMenuItem allocWithZone:[NSMenu menuZone]] initWithTitle:AILocalizedString(@"Toggle User List Side", nil)

																				   target:self

																				   action:@selector(toggleUserlistSide:)

																			keyEquivalent:@""];

	[adium.menuController addMenuItem:menuItem_toggleUserlistSide toLocation:LOC_Display_General];

	NSMenuItem *menuItem = [[[NSMenuItem allocWithZone:[NSMenu menuZone]] initWithTitle:AILocalizedString(@"Toggle User List", nil)

																				target:self

																				action:@selector(toggleUserlist:)

																		 keyEquivalent:@""] autorelease];

	[adium.menuController addContextualMenuItem:menuItem toLocation:Context_GroupChat_Action];

	// Clear display

	menuItem_clearDisplay = [[NSMenuItem allocWithZone:[NSMenu menuZone]] initWithTitle:AILocalizedString(@"Clear Display", nil)

																				 target:self

																				 action:@selector(clearDisplay:)

																		  keyEquivalent:@""];

	[adium.menuController addMenuItem:menuItem_clearDisplay toLocation:LOC_Display_MessageControl];

	//Contact list menu item

	menuItem = [[NSMenuItem allocWithZone:[NSMenu menuZone]] initWithTitle:AILocalizedString(@"Contact List","Name of the window which lists contacts")

																				target:self

																				action:@selector(toggleContactList:)

																		 keyEquivalent:@"/"];

	[adium.menuController addMenuItem:menuItem toLocation:LOC_Window_Fixed];

	[adium.menuController addMenuItem:[[menuItem copy] autorelease] toLocation:LOC_Dock_Status];

	[menuItem release];

	menuItem = [[NSMenuItem allocWithZone:[NSMenu menuZone]] initWithTitle:AILocalizedString(@"Close Chat","Title for the close chat menu item")

																	target:self

																	action:@selector(closeContextualChat:)

															 keyEquivalent:@""];

	[adium.menuController addContextualMenuItem:menuItem toLocation:Context_Tab_Action];

	[menuItem release];

	// Authorization requests menu item

	menuItem = [[NSMenuItem alloc] initWithTitle:AILocalizedStringFromTableInBundle(@"Authorization Requests",nil, [NSBundle bundleForClass:[AIAuthorizationRequestsWindowController class]], nil)

										  target:self

										  action:@selector(openAuthorizationWindow:)

								   keyEquivalent:@""];

	[adium.menuController addMenuItem:menuItem toLocation:LOC_Window_Auxiliary];

	[menuItem release];

    //Observe content so we can open chats as necessary

    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(didReceiveContent:) 

									   name:CONTENT_MESSAGE_RECEIVED object:nil];

    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(didReceiveContent:) 

									   name:CONTENT_MESSAGE_RECEIVED_GROUP object:nil];

	//Observe Adium finishing loading so we can do things which may require other components or plugins

	[[NSNotificationCenter defaultCenter] addObserver:self

								   selector:@selector(adiumDidFinishLoading:)

									   name:AIApplicationDidFinishLoadingNotification

									 object:nil];

	//Observe quits so we can save containers.

	[[NSNotificationCenter defaultCenter] addObserver:self

								   selector:@selector(saveContainersOnQuit:)

									   name:AIAppWillTerminateNotification

									 object:nil];

}

- (void)controllerWillClose

{

    [contactListPlugin closeContactList];

    [interfacePlugin closeInterface];

}

// Dealloc

- (void)dealloc

{

    [contactListViewArray release]; contactListViewArray = nil;

    [messageViewArray release]; messageViewArray = nil;

    [interfaceArray release]; interfaceArray = nil;

    [tooltipListObject release]; tooltipListObject = nil;

	[tooltipTitle release]; tooltipTitle = nil;

	[tooltipBody release]; tooltipBody = nil;

	[tooltipImage release]; tooltipImage = nil;

	[[NSNotificationCenter defaultCenter] removeObserver:self];

	[adium.preferenceController unregisterPreferenceObserver:self];

    [super dealloc];

}

- (void)adiumDidFinishLoading:(NSNotification *)inNotification

{

	//Observe preference changes. This will also restore saved containers if appropriate.

	[adium.preferenceController registerPreferenceObserver:self forGroup:PREF_GROUP_INTERFACE];

	[[NSNotificationCenter defaultCenter] removeObserver:self

										  name:AIApplicationDidFinishLoadingNotification

										object:nil];

}

//Registers code to handle the interface

- (void)registerInterfaceController:(id <AIInterfaceComponent>)inController

{

	if (!interfacePlugin) interfacePlugin = [inController retain];

}

//Register code to handle the contact list

- (void)registerContactListController:(id <AIContactListComponent>)inController

{

	if (!contactListPlugin) contactListPlugin = [inController retain];

}

//Preferences changed

- (void)preferencesChangedForGroup:(NSString *)group key:(NSString *)key

							object:(AIListObject *)object preferenceDict:(NSDictionary *)prefDict firstTime:(BOOL)firstTime

{

	if (!object) {

		//Update prefs

		tabbedChatting = [[prefDict objectForKey:KEY_TABBED_CHATTING] boolValue];

		groupChatsByContactGroup = [[prefDict objectForKey:KEY_GROUP_CHATS_BY_GROUP] boolValue];

		saveContainers = [[prefDict objectForKey:KEY_SAVE_CONTAINERS] boolValue];

		if (firstTime) {

			if (saveContainers) {

				//Restore saved containers

				[self restoreSavedContainers];	

			} else if ([prefDict objectForKey:KEY_CONTAINERS]) {

				/* We've loaded without wanting to save containers; clear any saved

				 * from a previous session.

				 */

				[adium.preferenceController setPreference:nil

													 forKey:KEY_CONTAINERS

													  group:PREF_GROUP_INTERFACE];

			}

		}

	}

}

//Handle a reopen/dock icon click

- (BOOL)handleReopenWithVisibleWindows:(BOOL)visibleWindows

{

	if (![self contactListIsVisibleAndMain] && [[interfacePlugin openContainerIDs] count] == 0) {

		//The contact list is not visible, and there are no chat windows. Make the contact list visible.

		[self showContactList:nil];

	} else {

		AIChat	*mostRecentUnviewedChat;

		//If windows are open, try switching to a chat with unviewed content

		if ((mostRecentUnviewedChat = [adium.chatController mostRecentUnviewedChat])) {

			if ([mostRecentActiveChat unviewedContentCount]) {

				//If the most recently active chat has unviewed content, ensure it is in the front

				[self setActiveChat:mostRecentActiveChat];

			} else {

				//Otherwise, switch to the chat which most recently received content

				[self setActiveChat:mostRecentUnviewedChat];

			}

		} else {

			NSWindow *targetWindow = nil;

			BOOL	 unMinimizedWindows = 0;

			//If there was no unviewed content, ensure that atleast one of Adium's windows is unminimized

			for (NSWindow *window in [NSApp windows]) {

				//Check stylemask to rule out the system menu's window (Which reports itself as visible like a real window)

				if (([window styleMask] & (NSTitledWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask))) {

					if (!targetWindow) targetWindow = window;

					if (![window isMiniaturized]) unMinimizedWindows++;

				}

			}

			//If there are no unminimized windows, unminimize the last one

			if (unMinimizedWindows == 0 && targetWindow) {

				[targetWindow deminiaturize:nil];

			}

		}

	}

	return YES; 

}

//Contact List ---------------------------------------------------------------------------------------------------------

#pragma mark Contact list

/*!

 * @brief Toggles contact list between visible and hiden

 */

- (IBAction)toggleContactList:(id)sender

{

    if ([self contactListIsVisibleAndMain]) {

		[self closeContactList:nil];

    } else {

		[[NSApplication sharedApplication] activateIgnoringOtherApps:YES];

		[self showContactList:nil];

    } 

}

/*!

 * @brief Brings contact list to the front

 */

- (IBAction)showContactList:(id)sender

{

	[contactListPlugin showContactListAndBringToFront:YES];

}

/*!

 * @brief Show the contact list window and bring Adium to the front

 */

- (IBAction)showContactListAndBringToFront:(id)sender

{

	[contactListPlugin showContactListAndBringToFront:YES];

	[[NSApplication sharedApplication] activateIgnoringOtherApps:YES];

}

/*!

 * @brief Close the contact list window

 */

- (IBAction)closeContactList:(id)sender

{

	[contactListPlugin closeContactList];

}

/*!

 * @returns YES if contact list is visible and selected, otherwise NO

 */

- (BOOL)contactListIsVisibleAndMain

{

	return [contactListPlugin contactListIsVisibleAndMain];

}

/*!

* @returns YES if contact list is visible, otherwise NO

 */

- (BOOL)contactListIsVisible

{

	return [contactListPlugin contactListIsVisible];

}

//Detachable Contact List ----------------------------------------------------------------------------------------------

#pragma mark Detachable Contact List

/*!

 * @returns Created contact list controller for detached contact list

 */

- (AIListWindowController *)detachContactList:(AIContactList *)aContactList

{

	return [contactListPlugin detachContactList:aContactList];

}

#pragma mark Container Saving

/*!

 * @brief Restores containers saved from a previous session

 */

- (void)restoreSavedContainers

{

	NSData				*savedData = [adium.preferenceController preferenceForKey:KEY_CONTAINERS

																	group:PREF_GROUP_INTERFACE];

	// If there's no data, we can't restore anything.

	if (!savedData)

		return;

	for (NSDictionary *dict in [NSKeyedUnarchiver unarchiveObjectWithData:savedData]) {

		AIMessageWindowController *windowController = [self openContainerWithID:[dict objectForKey:@"ID"]

																 name:[dict objectForKey:@"Name"]];

		AIChat *containerActiveChat = nil;

		// Position the container where it was last saved (using -savedFrameFromString: to prevent going offscreen)

		[[windowController window] setFrame:[windowController savedFrameFromString:[dict objectForKey:@"Frame"]] display:YES];

		for (NSDictionary *chatDict in [dict objectForKey:@"Content"]) {

			AIChat			*chat = nil;

			AIService		*service = [adium.accountController firstServiceWithServiceID:[chatDict objectForKey:@"serviceID"]];

			AIAccount		*account = [adium.accountController accountWithInternalObjectID:[chatDict objectForKey:@"AccountID"]];

			if ([[chatDict objectForKey:@"IsGroupChat"] boolValue]) {

				chat = [adium.chatController chatWithName:[chatDict objectForKey:@"Name"]

												 identifier:nil

												  onAccount:account

										   chatCreationInfo:[chatDict objectForKey:@"ChatCreationInfo"]];

			} else {

				AIListContact		*contact = [adium.contactController contactWithService:service

																					account:account

																						UID:[chatDict objectForKey:@"UID"]];

				chat = [adium.chatController chatWithContact:contact];

			}

			// Tag the chat as restored.

			[chat setValue:[NSNumber numberWithBool:YES]

			   forProperty:@"Restored Chat"

					notify:NotifyNow];

			if ([[chatDict objectForKey:@"ActiveChat"] boolValue]) {

				containerActiveChat = chat;

			}

			// Open the chat into the container we've created above.

			[self openChat:chat inContainerWithID:[dict objectForKey:@"ID"] atIndex:-1];

		}

		if (containerActiveChat)

			[self setActiveChat:containerActiveChat];

	}

}

/*!

 * @brief Saves open container information with their content when Adium quits

 */

- (void)saveContainersOnQuit:(NSNotification *)notification

{

	[self saveContainers];

}

/*!

 * @brief Save opened containers and windows

 *

 * @param withContent Save the current buffer of the window to restore at a later point

 */

- (void)saveContainers

{

	if (!saveContainers) {

		// Don't save anything if we're not set to.

		return;

	}

	// Save active containers.

	NSMutableArray		*savedContainers = [NSMutableArray array];

	for (NSDictionary *dict in [interfacePlugin openContainersAndChats]) {

		NSMutableArray		*containerContents = [NSMutableArray array];

		for (AIChat *chat in [dict objectForKey:@"Content"]) {

			NSMutableDictionary		*newContainerDict = [NSMutableDictionary dictionary];

			[newContainerDict setObject:chat.account.internalObjectID forKey:@"AccountID"];

			// Save chat-specific information.

			if (chat.isGroupChat) {

				// -chatCreationDictionary may be nil, so put it last.

				[newContainerDict addEntriesFromDictionary:[NSDictionary dictionaryWithObjectsAndKeys:

															[NSNumber numberWithBool:YES], @"IsGroupChat",

															[NSNumber numberWithBool:([dict objectForKey:@"ActiveChat"] == chat)], @"ActiveChat",

															chat.name, @"Name",

															[chat chatCreationDictionary], @"ChatCreationInfo",nil]];

			} else {

				[newContainerDict addEntriesFromDictionary:[NSDictionary dictionaryWithObjectsAndKeys:

															[NSNumber numberWithBool:([dict objectForKey:@"ActiveChat"] == chat)], @"ActiveChat",

															chat.listObject.UID, @"UID",

															chat.account.service.serviceID, @"serviceID",

															chat.account.internalObjectID, @"AccountID",nil]];

			}

			[containerContents addObject:newContainerDict];

		}

		// Replace the "Content" key in -openContainersAndChats with our version of the content.

		// Remove the ActiveChat reference

		// We use the same keys otherwise that -openContainersAndChats provides (Name, ID, Frame)

		NSMutableDictionary *saveDict = [[dict mutableCopy] autorelease];

		[saveDict removeObjectForKey:@"ActiveChat"];

		[saveDict setObject:containerContents

					 forKey:@"Content"];

		[savedContainers addObject:saveDict];

	}

	[adium.preferenceController setPreference:[NSKeyedArchiver archivedDataWithRootObject:savedContainers]

										 forKey:KEY_CONTAINERS

										  group:PREF_GROUP_INTERFACE];

}

//Messaging ------------------------------------------------------------------------------------------------------------

//Methods for instructing the interface to provide a representation of chats, and to determine which chat has user focus

#pragma mark Messaging

/*!

 * @brief Opens window for chat

 */

- (void)openChat:(AIChat *)inChat

{

	NSArray		*containerIDs = [interfacePlugin openContainerIDs];

	NSString	*containerID = nil;

	NSString	*containerName = nil;

	//Determine the correct container for this chat

	if (!tabbedChatting) {

		//We're not using tabs; each chat starts in its own container, based on the destination object or the chat name

		if ([inChat listObject]) {

			containerID = inChat.listObject.internalObjectID;

		} else {

			containerID = inChat.name;

		}

	} else if (groupChatsByContactGroup) {

		if (inChat.isGroupChat) {

			containerID = AILocalizedString(@"Group Chats",nil);

		} else {

			//XXX multiple containers: this is "correct" but maybe not desirable, as it is non-deterministic

			AIListGroup	*group = inChat.listObject.parentContact.groups.anyObject;