/* 

 * 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 "AIDualWindowInterfacePlugin.h"

#import <Adium/AIInterfaceControllerProtocol.h>

#import <Adium/AIMenuControllerProtocol.h>

#import "AIMessageTabViewItem.h"

#import "AIMessageViewController.h"

#import "AIMessageWindowController.h"

#import "AIDockController.h"

#import <Adium/AIToolbarControllerProtocol.h>

#import <Adium/AIAccountControllerProtocol.h>

#import <AIUtilities/AIApplicationAdditions.h>

#import <AIUtilities/AIAttributedStringAdditions.h>

#import <AIUtilities/AIImageAdditions.h>

#import <AIUtilities/AIStringAdditions.h>

#import <AIUtilities/AIToolbarUtilities.h>

#import <AIUtilities/AIArrayAdditions.h>

#import <AIUtilities/AIWindowAdditions.h>

#import <Adium/AIChat.h>

#import <Adium/AIListContact.h>

#import <Adium/AIListObject.h>

#import <PSMTabBarControl/PSMTabBarControl.h>

#import <PSMTabBarControl/PSMOverflowPopUpButton.h>

#import <PSMTabBarControl/PSMAdiumTabStyle.h>

#import <PSMTabBarControl/PSMTabStyle.h>

#import "AIMessageTabSplitView.h"

#import <Adium/AIStatusIcons.h>

#define KEY_MESSAGE_WINDOW_POSITION 			@"Message Window"

#define AIMessageTabDragBeganNotification		@"AIMessageTabDragBeganNotification"

#define AIMessageTabDragEndedNotification    	@"AIMessageTabDragEndedNotification"

#define	MESSAGE_WINDOW_NIB                      @"MessageWindow"			//Filename of the message window nib

#define TAB_BAR_FPS                             20.0

#define TAB_BAR_STEP                            0.6

#define TOOLBAR_MESSAGE_WINDOW					@"AdiumMessageWindow"			//Toolbar identifier

#define HORIZONTAL_TAB_BAR_TO_VIEW_SPACING		7

#define KEY_VERTICAL_TABS_WIDTH					@"Vertical Tabs Width"

#define VERTICAL_DIVIDER_THICKNESS				4

#define VERTICAL_TAB_BAR_TO_VIEW_SPACING		3

@interface AIMessageWindowController ()

- (id)initWithWindowNibName:(NSString *)windowNibName interface:(AIDualWindowInterfacePlugin *)inInterface containerID:(NSString *)inContainerID containerName:(NSString *)inName;

- (void)_configureToolbar;

- (void)_updateWindowTitleAndIcon;

- (NSString *)_frameSaveKey;

- (void)_reloadContainedChats;

@end

//Used to squelch compiler warnings on this private call

@interface NSWindow (AISecretWindowDocumentIconAdditions)

- (void)addDocumentIconButton;

@end

@implementation AIMessageWindowController

//Create a new message window controller

+ (AIMessageWindowController *)messageWindowControllerForInterface:(AIDualWindowInterfacePlugin *)inInterface

															withID:(NSString *)inContainerID

															  name:(NSString *)inName

{

    return [[[self alloc] initWithWindowNibName:MESSAGE_WINDOW_NIB

									  interface:inInterface

									containerID:inContainerID

										   containerName:inName] autorelease];

}

//init

- (id)initWithWindowNibName:(NSString *)windowNibName

				  interface:(AIDualWindowInterfacePlugin *)inInterface

				containerID:(NSString *)inContainerID

					   containerName:(NSString *)inName

{

	if ((self = [super initWithWindowNibName:windowNibName])) {

		NSWindow	*myWindow;

		interface = [inInterface retain];

		containerName = [inName retain];

		containerID = [inContainerID retain];

		m_containedChats = [[NSMutableArray alloc] init];

		hasShownDocumentButton = NO;

		//Load our window

		myWindow = [self window];

		[[NSNotificationCenter defaultCenter] addObserver:self

												 selector:@selector(tabDraggingNotificationReceived:)

													 name:PSMTabDragDidBeginNotification

												   object:nil];

		[[NSNotificationCenter defaultCenter] addObserver:self

												 selector:@selector(tabDraggingNotificationReceived:)

													 name:PSMTabDragDidEndNotification

												   object:nil];

		[[NSNotificationCenter defaultCenter] addObserver:self

												 selector:@selector(tabBarFrameChanged:)

													 name:NSViewFrameDidChangeNotification

												   object:tabView_tabBar];

		[[NSNotificationCenter defaultCenter] addObserver:self 

												 selector:@selector(windowWillMiniaturize:)

													 name:NSWindowWillMiniaturizeNotification

												   object:myWindow];

		//Prefs

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

		//Register as a tab drag observer so we know when tabs are dragged over our window and can show our tab bar

		[myWindow registerForDraggedTypes:[NSArray arrayWithObject:@"PSMTabBarControlItemPBType"]];

	}

    return self;

}

//dealloc

- (void)dealloc

{

	[[NSNotificationCenter defaultCenter] removeObserver:self];

	/* Ensure our window is quite clear we have no desire to ever hear from it again.  sendEvent: with a flags changed

	 * event is being sent to this AIMessageWindowController instance by the window after dallocing, for some reason.

	 * It seems likely a double-release is involved.  I can't reproduce this locally, either... but calling

	 * [self setWindow:nil] appears to fix the problem where it was being experienced..

	 *

	 * Something is wrong elsewhere that this could be necessary, but this doesn't hurt I don't believe.

	 */

	[[self window] setDelegate:nil];

	[self setWindow:nil];

    [tabView_tabBar setDelegate:nil];

	[self.containedChats release];

	[toolbarItems release];

	[containerName release];

	[containerID release];

	[adium.preferenceController unregisterPreferenceObserver:self];

    [super dealloc];

}

//Human readable container name

- (NSString *)name

{

	return containerName;

}

//Internal container ID

- (NSString *)containerID

{

	return containerID;

}

//PSMTabBarControl accessor

- (PSMTabBarControl *)tabBar

{

	return tabView_tabBar;

}

- (NSString *)adiumFrameAutosaveName

{

	return [self _frameSaveKey];

}

//Setup our window before it is displayed

- (void)windowDidLoad

{

	[super windowDidLoad];

	NSWindow	*theWindow = [self window];

    //Exclude this window from the window menu (since we add it manually)

    [theWindow setExcludedFromWindowsMenu:YES];

	[theWindow useOptimizedDrawing:YES];

	[self _configureToolbar];

    //Remove any tabs from our tab view, it needs to start out empty

    while ([tabView_messages numberOfTabViewItems] > 0) {

        [tabView_messages removeTabViewItem:[tabView_messages tabViewItemAtIndex:0]];

    }

	//Setup the tab bar

	tabView_tabStyle = [[[PSMAdiumTabStyle alloc] init] autorelease];

	[tabView_tabBar setStyle:tabView_tabStyle];

	[tabView_tabBar setCanCloseOnlyTab:YES];

	[tabView_tabBar setUseOverflowMenu:NO];

	[tabView_tabBar setAllowsResizing:NO];

	[tabView_tabBar setSizeCellsToFit:YES];

	[tabView_tabBar setHideForSingleTab:!alwaysShowTabs];

	[tabView_tabBar setSelectsTabsOnMouseDown:YES];

	[tabView_tabBar setAutomaticallyAnimates:NO];

	[tabView_tabBar setAllowsScrubbing:YES];

	[tabView_tabBar setAllowsBackgroundTabClosing:[[NSUserDefaults standardUserDefaults] boolForKey:@"AIAllowBackgroundTabClosing"]];

	[tabView_tabBar setTearOffStyle:PSMTabBarTearOffAlphaWindow];

}

//Frames

- (NSString *)_frameSaveKey

{

	if ([[adium.preferenceController preferenceForKey:KEY_TABBED_CHATTING

												  group:PREF_GROUP_INTERFACE] boolValue] &&

		![[adium.preferenceController preferenceForKey:KEY_GROUP_CHATS_BY_GROUP

												   group:PREF_GROUP_INTERFACE] boolValue]) {

		return KEY_MESSAGE_WINDOW_POSITION;

	} else {

		//Not using tabbed chatting, or we're tabbing by groups: Save the window position on a per-container basis

		return [NSString stringWithFormat:@"%@ %@",KEY_MESSAGE_WINDOW_POSITION, containerID];	

	}

}

- (BOOL)shouldCascadeWindows

{

	if ([[adium.preferenceController preferenceForKey:KEY_TABBED_CHATTING  group:PREF_GROUP_INTERFACE] boolValue])

		return NO;

	else //Not using tabbed chatting: Cascade if we have no frame

		return ([self savedFrameString] == nil);

}

//Close the message window

- (IBAction)closeWindow:(id)sender

{

	windowIsClosing = YES;

	[[self window] performClose:nil];

}

/*!

 * @brief Confirm if we should close the window.

 */

- (BOOL)windowShouldClose:(id)window

{

	if (!windowIsClosing

		&& self.containedChats.count > 1

		&& [[adium.preferenceController preferenceForKey:KEY_CONFIRM_MSG_CLOSE group:PREF_GROUP_CONFIRMATIONS] boolValue]) {

		NSString *suppressionText = nil;

		NSInteger unreadCount = 0;

		for (AIChat *chat in self.containedChats) {

			if (chat.unviewedContentCount) {

				unreadCount++;

			}

		}

		switch ([[adium.preferenceController preferenceForKey:KEY_CONFIRM_MSG_CLOSE_TYPE group:PREF_GROUP_CONFIRMATIONS] integerValue]) {

			case AIMessageCloseAlways:

				suppressionText = AILocalizedString(@"Do not warn when closing multiple chats", nil);

				break;

			case AIMessageCloseUnread:

				if (unreadCount) {

					suppressionText = AILocalizedString(@"Do not warn when closing unread chats", nil);

				}

				break;

		}

		NSString *question = nil;

		if (unreadCount) {

			if (unreadCount == 1) {

				question = [NSString stringWithFormat:AILocalizedString(@"%u chats are open in this window, 1 of which has unviewed messages. Do you want to close this window anyway?",nil),

							self.containedChats.count];

			} else {

				question = [NSString stringWithFormat:AILocalizedString(@"%u chats are open in this window, %u of which have unviewed messages. Do you want to close this window anyway?",nil),

							self.containedChats.count,

							unreadCount];	

			}

		} else {

			question = [NSString stringWithFormat:AILocalizedString(@"%u chats are open in this window. Do you want to close this window anyway?",nil),

						self.containedChats.count];

		}

		if (suppressionText) {

			NSAlert *alert = [NSAlert alertWithMessageText:AILocalizedString(@"Are you sure you want to close this window?", nil)

											 defaultButton:AILocalizedString(@"Close", nil)

										   alternateButton:AILocalizedStringFromTable(@"Cancel", @"Buttons", nil)

											   otherButton:nil

								 informativeTextWithFormat:question];

			[alert setShowsSuppressionButton:YES];

			[[alert suppressionButton] setTitle:suppressionText];

			[alert beginSheetModalForWindow:self.window 

							  modalDelegate:self 

							 didEndSelector:@selector(closeAlertDidEnd:returnCode:contextInfo:) 

								contextInfo:nil];

			return NO;

		}

	}

	return YES;

}

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

{

	if ([alert suppressionButton].state == NSOnState) {

		[adium.preferenceController setPreference:nil

										   forKey:KEY_CONFIRM_MSG_CLOSE

											group:PREF_GROUP_CONFIRMATIONS];

	}

	if (result == NSAlertDefaultReturn) {

		// Dismiss the alert sheet.

		[self.window orderOut:nil];

		// Don't prompt again.

		windowIsClosing = YES;

		// Close the window.

		[self closeWindow:nil];

	}

}

/*!

 * @brief Called as the window closes

 */

- (void)windowWillClose:(id)sender

{

    NSEnumerator			*enumerator;

    AIMessageTabViewItem	*tabViewItem;

	if ([tabView_tabBar orientation] == PSMTabBarVerticalOrientation) {

		CGFloat widthToStore;

		if ([tabView_tabBar isTabBarHidden]) {

			widthToStore = lastTabBarWidth;

		} else {

			widthToStore = NSWidth([tabView_tabBar frame]);

		}

		[adium.preferenceController setPreference:[NSNumber numberWithDouble:widthToStore]

											 forKey:KEY_VERTICAL_TABS_WIDTH

											  group:PREF_GROUP_DUAL_WINDOW_INTERFACE];

	}

	windowIsClosing = YES;

	[super windowWillClose:sender];

	[adium.preferenceController unregisterPreferenceObserver:self];

    //Close all our tabs (The array will change as we remove tabs, so we must work with a copy)

	enumerator = [[tabView_messages tabViewItems] reverseObjectEnumerator];

    while ((tabViewItem = [enumerator nextObject])) {

		[adium.interfaceController closeChat:tabViewItem.chat];

	}

	//Chats have all closed, set active to nil, let the interface know we closed.  We should skip this step if our

	//window is no longer visible, since in that case another window will have already became active.

	if ([[self window] isVisible] && [[self window] isKeyWindow]) {

		[adium.interfaceController chatDidBecomeActive:nil];

	}

	[interface containerDidClose:self];

    return;

}

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

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

{

    if ([group isEqualToString:PREF_GROUP_DUAL_WINDOW_INTERFACE]) {

		NSWindow	*window = [self window];

		alwaysShowTabs = ![[prefDict objectForKey:KEY_AUTOHIDE_TABBAR] boolValue];

		[tabView_tabBar setHideForSingleTab:!alwaysShowTabs];

		NSNumber *useOverflow = [prefDict objectForKey:KEY_TABBAR_OVERFLOW];

		[tabView_tabBar setUseOverflowMenu:(useOverflow ? [useOverflow boolValue] : YES)];

		[[tabView_tabBar overflowPopUpButton] setAlternateImage:[AIStatusIcons statusIconForStatusName:@"content" statusType:AIAvailableStatusType iconType:AIStatusIconTab direction:AIIconNormal]];

		//NSImage *overflowImage = [[[NSImage alloc] initByReferencingFile:[[NSBundle mainBundle] pathForImageResource:@"overflow_overlay"]] autorelease];

		//[[tabView_tabBar overflowPopUpButton] setAlternateImage:overflowImage];

		//change the frame of the tab bar according to the orientation

		if (firstTime || [key isEqualToString:KEY_TABBAR_POSITION]) {

			PSMTabBarOrientation orientation;

			tabPosition = [[prefDict objectForKey:KEY_TABBAR_POSITION] integerValue];

			orientation = ((tabPosition == AdiumTabPositionBottom || tabPosition == AdiumTabPositionTop) ?

						   PSMTabBarHorizontalOrientation :

						   PSMTabBarVerticalOrientation);

			NSRect tabBarFrame = [tabView_tabBar frame], tabViewMessagesFrame = [tabView_messages frame];

			NSRect contentRect = [[[self window] contentView] frame];

			//remove the split view if the last orientation was vertical

			if ([tabView_tabBar orientation] == PSMTabBarVerticalOrientation) {

				[tabView_messages retain];

				[tabView_messages removeFromSuperview];

				[tabView_tabBar retain];

				[tabView_tabBar removeFromSuperview];

				[tabView_splitView removeFromSuperview];

				[[[self window] contentView] addSubview:tabView_messages];

				[[[self window] contentView] addSubview:tabView_tabBar];

				[tabView_messages release];

				[tabView_tabBar release];

			}

			[tabView_tabBar setOrientation:orientation];

			switch (orientation) {

				case PSMTabBarHorizontalOrientation:

				{

					tabBarFrame.size.height = [tabView_tabBar isTabBarHidden] ? 1 : kPSMTabBarControlHeight;

					tabBarFrame.size.width = contentRect.size.width + 1;

					//set the position of the tab bar (top/bottom)

					if (tabPosition == AdiumTabPositionBottom) {

						tabBarFrame.origin.y = NSMinY(contentRect);

						tabViewMessagesFrame.origin.y = NSHeight(tabBarFrame) + ([tabView_tabBar isTabBarHidden] ? 0 : (HORIZONTAL_TAB_BAR_TO_VIEW_SPACING - 1));

						tabViewMessagesFrame.size.height = (NSHeight(contentRect) - NSHeight(tabBarFrame) -

															([tabView_tabBar isTabBarHidden] ? 0 : (HORIZONTAL_TAB_BAR_TO_VIEW_SPACING - 2)));

						[tabView_tabBar setAutoresizingMask:(NSViewMaxYMargin | NSViewWidthSizable)];

					} else {

						// This arbitrary sizedown is so that top tabs look visually connected to their content below.

						tabBarFrame.size.height -= 3;

						tabBarFrame.origin.y = NSMaxY(contentRect) - NSHeight(tabBarFrame);

						tabViewMessagesFrame.origin.y = NSMinY(contentRect);

						tabViewMessagesFrame.size.height = NSHeight(contentRect) - NSHeight(tabBarFrame);

						[tabView_tabBar setAutoresizingMask:(NSViewMinYMargin | NSViewWidthSizable)];

					}

					/* If the cell is less than 60, icon + title + unread message count may overlap */

					[tabView_tabBar setCellMinWidth:60];

					[tabView_tabBar setCellMaxWidth:250];

					tabBarFrame.origin.x = 0;

					//Items within the tabview draw frames, so be sure to clip the left and right edges.

					tabViewMessagesFrame.origin.x = -1;

					tabViewMessagesFrame.size.width = NSWidth(contentRect) + 2;

					break;

				}

				case PSMTabBarVerticalOrientation:

				{

					CGFloat width = ([prefDict objectForKey:KEY_VERTICAL_TABS_WIDTH] ?

								   [[prefDict objectForKey:KEY_VERTICAL_TABS_WIDTH] doubleValue] :

								   100);

					lastTabBarWidth = width;

					tabBarFrame.size.height = [[[self window] contentView] frame].size.height;

					tabBarFrame.size.width = [tabView_tabBar isTabBarHidden] ? 1 : width;

					tabBarFrame.origin.y = NSMinY(contentRect);

					tabViewMessagesFrame.origin.y = NSMinY(contentRect);

					tabViewMessagesFrame.size.height = NSHeight(contentRect) + 1;

					tabViewMessagesFrame.size.width = NSWidth(contentRect) - NSWidth(tabBarFrame) - 5;

					//set the position of the tab bar (left/right)

					if (tabPosition == AdiumTabPositionLeft) {

						tabBarFrame.origin.x = NSMinX(contentRect);

						tabViewMessagesFrame.origin.x = NSMaxX(tabBarFrame);

						[tabView_tabBar setAutoresizingMask:NSViewHeightSizable];

					} else {

						tabViewMessagesFrame.origin.x = NSMinX(contentRect);

						tabBarFrame.origin.x = NSWidth(contentRect) - NSWidth(tabBarFrame) + 1;

						[tabView_tabBar setAutoresizingMask:NSViewHeightSizable | NSViewMinXMargin];

					}

					[tabView_tabBar setCellMinWidth:50];

					[tabView_tabBar setCellMaxWidth:200];

					//put the subviews into a split view

					NSRect splitViewRect = [[[self window] contentView] frame];

					splitViewRect.size.width++;

					splitViewRect.size.height++;

					tabView_splitView = [[[AIMessageTabSplitView alloc] initWithFrame:splitViewRect] autorelease];

					[tabView_splitView setDividerThickness:([tabView_tabBar isTabBarHidden] ? 0 : VERTICAL_DIVIDER_THICKNESS)];

					[tabView_splitView setVertical:YES];

					[tabView_splitView setDelegate:self];

					if (tabPosition == AdiumTabPositionLeft) {

						[tabView_splitView addSubview:tabView_tabBar];

						[tabView_splitView addSubview:tabView_messages];

						[tabView_splitView setLeftColor:[NSColor colorWithCalibratedWhite:0.92 alpha:1.0]

											 rightColor:[NSColor colorWithCalibratedWhite:0.91 alpha:1.0]];

					} else {

						[tabView_splitView addSubview:tabView_messages];

						[tabView_splitView addSubview:tabView_tabBar];

						[tabView_splitView setLeftColor:[NSColor colorWithCalibratedWhite:0.91 alpha:1.0]

											 rightColor:[NSColor colorWithCalibratedWhite:0.92 alpha:1.0]];

					}

					[tabView_splitView adjustSubviews];

					[tabView_splitView setAutoresizingMask:(NSViewWidthSizable | NSViewHeightSizable)];

					[[[self window] contentView] addSubview:tabView_splitView];

					break;

				}

			}

			[tabView_messages setFrame:tabViewMessagesFrame];

			[tabView_tabBar setFrame:tabBarFrame];

			//update the tab bar and tab view frame

			[[self window] display];

		}

		//set tab style drawing attributes

		[tabView_tabStyle setDrawsRight:(tabPosition == AdiumTabPositionRight)];

		[tabView_tabStyle setDrawsUnified:(tabPosition == AdiumTabPositionTop)];

		//[[[self window] toolbar] setShowsBaselineSeparator:(tabPosition != AdiumTabPositionTop)];

		[self _updateWindowTitleAndIcon];

		AIWindowLevel	windowLevel = [[prefDict objectForKey:KEY_WINDOW_LEVEL] integerValue];

		NSInteger				level = NSNormalWindowLevel;

		switch (windowLevel) {

			case AINormalWindowLevel: level = NSNormalWindowLevel; break;

			case AIFloatingWindowLevel: level = NSFloatingWindowLevel; break;

			case AIDesktopWindowLevel: level = kCGDesktopWindowLevel; break;

		}

		[window setLevel:level];

		[window setHidesOnDeactivate:[[prefDict objectForKey:KEY_WINDOW_HIDE] boolValue]];

    }

}

- (void)updateOverflowMenuUnviewedContentIcon

{

	BOOL someUnviewedContent = NO;

	NSInteger count = [[tabView_tabBar representedTabViewItems] count];

	for (NSInteger i = [tabView_tabBar numberOfVisibleTabs]; i < count; i++) {

		if ([[[[tabView_tabBar representedTabViewItems] objectAtIndex:i] chat] unviewedContentCount] > 0) {

			someUnviewedContent = YES;

			break;

		}

	}

	[[tabView_tabBar overflowPopUpButton] setAnimatingAlternateImage:someUnviewedContent];	

}

- (void)updateIconForTabViewItem:(AIMessageTabViewItem *)tabViewItem

{

	if (tabViewItem == [tabView_messages selectedTabViewItem]) {

		[self _updateWindowTitleAndIcon];

	}

	if ([[tabView_tabBar representedTabViewItems] indexOfObject:tabViewItem] >= [tabView_tabBar numberOfVisibleTabs]) {

		//The chat is in the overflow menu. If any chat has unviewed content, it should be animating to demonstrate that.

		[self updateOverflowMenuUnviewedContentIcon];

	}

}

- (AdiumTabPosition)tabPosition

{

	return tabPosition;

}

//Contained Chats ------------------------------------------------------------------------------------------------------

#pragma mark Contained Chats

//Add a tab view item container at the end of the tabs (without changing the current selection)

- (void)addTabViewItem:(AIMessageTabViewItem *)inTabViewItem

{    

    [self addTabViewItem:inTabViewItem atIndex:-1 silent:NO];

}

//Add a tab view item container (without changing the current selection)

//If silent is NO, the interface controller will be informed of the add

- (void)addTabViewItem:(AIMessageTabViewItem *)inTabViewItem atIndex:(NSInteger)index silent:(BOOL)silent

{

	/* XXX This mirrors the hack in -[AIMessageTabViewItem initWithMessageView]. It may have been undone

	 * in removeTabViewItem:silent: below if the tab was moving between windows.

	 */

	[inTabViewItem setIdentifier:inTabViewItem];

	if (index == -1) {

		[tabView_messages addTabViewItem:inTabViewItem];