//

//  AIStatusMenu.m

//  Adium

//

//  Created by Evan Schoenberg on 11/23/05.

//

#import <Adium/AIStatusMenu.h>

#import <Adium/AIStatus.h>

#import <Adium/AIStatusGroup.h>

#import <Adium/AIAccount.h>

#import <Adium/AIStatusControllerProtocol.h>

#import <Adium/AIEditStateWindowController.h>

#import <Adium/AIStatusIcons.h>

#import <Adium/AISocialNetworkingStatusMenu.h>

#import <Adium/AIAccountControllerProtocol.h>

#import <Adium/AIMenuControllerProtocol.h>

#import <AIUtilities/AIArrayAdditions.h>

#import <AIUtilities/AIEventAdditions.h>

#import <AIUtilities/AIMenuAdditions.h>

#import <AIUtilities/AIStringAdditions.h>

#define STATUS_TITLE_CUSTOM			[AILocalizedString(@"Custom", nil) stringByAppendingEllipsis]

#define STATE_TITLE_MENU_LENGTH		30

@interface AIStatusMenu ()

- (id)initWithDelegate:(id<AIStatusMenuDelegate>)inDelegate;

@end

@implementation AIStatusMenu

+ (id)statusMenuWithDelegate:(id<AIStatusMenuDelegate>)inDelegate

{

	return [[[self alloc] initWithDelegate:inDelegate] autorelease];

}

- (id)initWithDelegate:(id<AIStatusMenuDelegate>)inDelegate

{

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

		self.delegate = inDelegate;

		NSParameterAssert([delegate respondsToSelector:@selector(statusMenu:didRebuildStatusMenuItems:)]);

		menuItemArray = [[NSMutableArray alloc] init];

		stateMenuItemsAlreadyValidated = [[NSMutableSet alloc] init];

		[self rebuildMenu];

		[[NSNotificationCenter defaultCenter] addObserver:self

									   selector:@selector(stateArrayChanged:)

										   name:AIStatusStateArrayChangedNotification

										 object:nil];

		[[NSNotificationCenter defaultCenter] addObserver:self

									   selector:@selector(activeStatusStateChanged:)

										   name:AIStatusActiveStateChangedNotification

										 object:nil];

		//Update our state menus when the state array or status icon set changes

		[[NSNotificationCenter defaultCenter] addObserver:self

									   selector:@selector(statusIconSetChanged:)

										   name:AIStatusIconSetDidChangeNotification

										 object:nil];

	}

	return self;

}

- (void)dealloc

{

	[[NSNotificationCenter defaultCenter] removeObserver:self];

	[stateMenuItemsAlreadyValidated release];

	[menuItemArray release];

	self.delegate = nil;

	[super dealloc];

}

@synthesize delegate;

/*!

 * @brief The delegate is just too good for the menu items we've created; it will create all of the ones it wants on its own

 */

- (void)delegateWillReplaceAllMenuItems

{

	//Remove the menu items from needing update

	[stateMenuItemsAlreadyValidated removeAllObjects];

	//Clear the array itself

	[menuItemArray removeAllObjects];	

}

/*!

 * @brief The delegate created its own menu items it wants us to track and update

 */

- (void)delegateCreatedMenuItems:(NSArray *)addedMenuItems

{

	//Now add the items we were given

	[menuItemArray addObjectsFromArray:addedMenuItems];

}

- (void)stateArrayChanged:(NSNotification *)notification

{	

	[self rebuildMenu];

}

- (void)activeStatusStateChanged:(NSNotification *)notification

{

	[stateMenuItemsAlreadyValidated removeAllObjects];

}

- (void)statusIconSetChanged:(NSNotification *)notification

{

	[self rebuildMenu];	

}

/*!

 * @brief Generate the custom menu item for a status type

 */

- (NSMenuItem *)customMenuItemForStatusType:(AIStatusType)statusType

{

	NSMenuItem *menuItem;

	menuItem = [[NSMenuItem alloc] initWithTitle:STATUS_TITLE_CUSTOM

										  target:self

										  action:@selector(selectCustomState:)

								   keyEquivalent:@""];

	[menuItem setImage:[AIStatusIcons statusIconForStatusName:nil

												   statusType:statusType

													 iconType:AIStatusIconMenu

													direction:AIIconNormal]];

	[menuItem setTag:statusType];

	return [menuItem autorelease];

}

/*!

 * @brief Rebuild the menu

 */

- (void)rebuildMenu

{

	NSEnumerator			*enumerator;

	NSMenuItem				*menuItem;

	AIStatus				*statusState;

	AIStatusType			currentStatusType = AIAvailableStatusType;

	AIStatusMutabilityType	currentStatusMutabilityType = AILockedStatusState;

	[adium.menuController delayMenuItemPostProcessing];

	if ([delegate respondsToSelector:@selector(statusMenu:willRemoveStatusMenuItems:)]) {

		[delegate statusMenu:self willRemoveStatusMenuItems:menuItemArray];

	}

	[menuItemArray removeAllObjects];

	[stateMenuItemsAlreadyValidated removeAllObjects];

	/* Create a menu item for each state.  States must first be sorted such that states of the same AIStatusType

		* are grouped together.

		*/

	enumerator = [[adium.statusController sortedFullStateArray] objectEnumerator];

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

		NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

		AIStatusType thisStatusType = statusState.statusType;

		AIStatusType thisStatusMutabilityType = [statusState mutabilityType];

		if ((currentStatusMutabilityType != AISecondaryLockedStatusState) &&

			(thisStatusMutabilityType == AISecondaryLockedStatusState)) {

			//Add the custom item, as we are ending this group

			[menuItemArray addObject:[self customMenuItemForStatusType:currentStatusType]];

			//Add a divider when we switch to a secondary locked group

			[menuItemArray addObject:[NSMenuItem separatorItem]];

		}

		//We treat Invisible statuses as being the same as Away for purposes of the menu

		if (thisStatusType == AIInvisibleStatusType) thisStatusType = AIAwayStatusType;

		/* Add the "Custom..." state option and a separatorItem before beginning to add items for a new statusType

			* Sorting the menu items before enumerating means that we know our statuses are sorted first by statusType

			*/

		if ((currentStatusType != thisStatusType) &&

			(currentStatusType != AIOfflineStatusType)) {

			//Don't include a Custom item after the secondary locked group, as it was already included

			if ((currentStatusMutabilityType != AISecondaryLockedStatusState)) {

				[menuItemArray addObject:[self customMenuItemForStatusType:currentStatusType]];

			}

			//Add a divider

			[menuItemArray addObject:[NSMenuItem separatorItem]];

			currentStatusType = thisStatusType;

		}

		menuItem = [[NSMenuItem alloc] initWithTitle:[AIStatusMenu titleForMenuDisplayOfState:statusState]

											  target:self

											  action:@selector(selectState:)

									   keyEquivalent:@""];

		if ([statusState isKindOfClass:[AIStatus class]]) {

			[menuItem setToolTip:[statusState statusMessageTooltipString]];

		} else {

			/* AIStatusGroup */

			[menuItem setSubmenu:[(AIStatusGroup *)statusState statusSubmenuNotifyingTarget:self

																					 action:@selector(selectState:)]];

		}

		[menuItem setRepresentedObject:[NSDictionary dictionaryWithObject:statusState

																   forKey:@"AIStatus"]];

		[menuItem setTag:currentStatusType];

		[menuItem setImage:[statusState menuIcon]];

		[menuItemArray addObject:menuItem];

		[menuItem release];

		currentStatusMutabilityType = thisStatusMutabilityType;

		[pool release];

	}

	if (currentStatusType != AIOfflineStatusType) {

		/* Add the last "Custom..." state option for the last statusType we handled,

		 * which didn't get a "Custom..." item yet.  At present, our last status type should always be

		 * our AIOfflineStatusType, so this will never be executed and just exists for completeness.

		 */

		[menuItemArray addObject:[self customMenuItemForStatusType:currentStatusType]];

	}

	//Now that we are done creating the menu items, tell the plugin about them

	[delegate statusMenu:self didRebuildStatusMenuItems:menuItemArray];

	[adium.menuController endDelayMenuItemPostProcessing];

}

/*!

* @brief Menu validation

 *

 * Our state menu items should always be active, so always return YES for validation.

 *

 * Here we lazily set the state of our menu items if our stateMenuItemsAlreadyValidated set indicates it is needed.

 *

 * Random note: stateMenuItemsAlreadyValidated will almost never have a count of 0 because separatorItems

 * get included but never get validated.

 */

- (BOOL)validateMenuItem:(NSMenuItem *)menuItem

{

	if (![stateMenuItemsAlreadyValidated containsObject:menuItem]) {

		NSDictionary	*dict = [menuItem representedObject];

		AIAccount		*account = [dict objectForKey:@"AIAccount"];

		AIStatus		*menuItemStatusState = [dict objectForKey:@"AIStatus"];

		if (account) {

			/* Account-specific menu items */

			AIStatus *appropriateActiveStatusState = account.statusState;

			/* Our "Custom..." menu choice has a nil represented object.  If the appropriate active search state is

				* in our array of states from which we made menu items, we'll be searching to match it.  If it isn't,

				* we have a custom state and will be searching for the custom item of the right type, switching all other

				* menu items to NSOffState.

				*/

			if ([adium.statusController.flatStatusSet containsObject:appropriateActiveStatusState]) {

				//If the search state is in the array so is a saved state, search for the match

				if ((menuItemStatusState == appropriateActiveStatusState) ||

					([menuItemStatusState isKindOfClass:[AIStatusGroup class]] &&

					 [(AIStatusGroup *)menuItemStatusState enclosesStatusState:appropriateActiveStatusState])) {

					if ([menuItem state] != NSOnState) [menuItem setState:NSOnState];

				} else {

					if ([menuItem state] != NSOffState) [menuItem setState:NSOffState];

				}

			} else {

				//If there is not a status state, we are in a Custom state. Search for the correct Custom item.

				if (menuItemStatusState) {

					//If the menu item has an associated state, it's always off.

					if ([menuItem state] != NSOffState) [menuItem setState:NSOffState];

				} else {

					//If it doesn't, check the tag to see if it should be on or off.

					if ([menuItem tag] == appropriateActiveStatusState.statusType) {

						if ([menuItem state] != NSOnState) [menuItem setState:NSOnState];

					} else {

						if ([menuItem state] != NSOffState) [menuItem setState:NSOffState];

					}

				}

			}

		} else {

			/* General menu items */

			NSSet	*allActiveStatusStates = [adium.statusController allActiveStatusStates];

			int		onState = (([allActiveStatusStates count] == 1) ? NSOnState : NSMixedState);

			if (menuItemStatusState) {

				//If this menu item has a status state, set it to the right on state if that state is active

				if ([allActiveStatusStates containsObject:menuItemStatusState] ||

					([menuItemStatusState isKindOfClass:[AIStatusGroup class]] &&

					 [(AIStatusGroup *)menuItemStatusState enclosesStatusStateInSet:allActiveStatusStates])) {

					if ([menuItem state] != onState) [menuItem setState:onState];

				} else {

					if ([menuItem state] != NSOffState) [menuItem setState:NSOffState];

				}

			} else {

				//If it doesn't, check the tag to see if it should be on or off by looking for a matching custom state

				NSEnumerator	*activeStatusStatesEnumerator = [allActiveStatusStates objectEnumerator];

				NSSet			*flatStatusSet = adium.statusController.flatStatusSet;

				AIStatus		*statusState;

				BOOL			foundCorrectStatusState = NO;

				while (!foundCorrectStatusState && (statusState = [activeStatusStatesEnumerator nextObject])) {

					/* We found a custom match if our array of menu item states doesn't contain this state and

					* its statusType matches the menuItem's tag.

					*/

					foundCorrectStatusState = (![flatStatusSet containsObject:statusState] &&

											   ([menuItem tag] == statusState.statusType));

				}

				if (foundCorrectStatusState) {

					if ([menuItem state] != NSOnState) [menuItem setState:onState];

				} else {

					if ([menuItem state] != NSOffState) [menuItem setState:NSOffState];

				}

			}

		}

		[stateMenuItemsAlreadyValidated addObject:menuItem];

	}

	return YES;

}

/*!

 * @brief Select a state menu item

 *

 * Invoked by a state menu item, sets the state corresponding to the menu item as the active state.

 *

 * If the representedObject NSDictionary has an @"AIAccount" object, set the state just for the appropriate AIAccount.

 * Otherwise, set the state globally.

 */

- (void)selectState:(id)sender

{

	NSDictionary	*dict = [sender representedObject];

	AIStatusItem	*statusItem = [dict objectForKey:@"AIStatus"];

	AIAccount		*account = [dict objectForKey:@"AIAccount"];

	if ([statusItem isKindOfClass:[AIStatusGroup class]]) {

		statusItem = [(AIStatusGroup *)statusItem anyContainedStatus];

	}

	/* Random undocumented feature of the moment... hold option and select a state to bring up the custom status window

	 * for modifying and then setting it. Alternately, select an active status (one in the on state) to do the same.

	 * Selecting a mixed state item should still select it to switch to full-on (all accounts).

	 */	

	NSEventType eventType = [[NSApp currentEvent] type];

	BOOL		keyEvent = (eventType == NSKeyDown || eventType == NSKeyUp);

	BOOL		isOptionClick = [NSEvent optionKey] && !keyEvent;

	if (isOptionClick ||

		(([sender state] == NSOnState) && (statusItem.statusType != AIOfflineStatusType))) {

		[AIEditStateWindowController editCustomState:(AIStatus *)statusItem

											 forType:statusItem.statusType

										  andAccount:account

									  withSaveOption:YES

											onWindow:nil

									 notifyingTarget:adium.statusController];

	} else {

		if (account) {

			BOOL shouldRebuild;

			shouldRebuild = [adium.statusController removeIfNecessaryTemporaryStatusState:account.statusState];

			[account setStatusState:(AIStatus *)statusItem];

			//Enable the account if it isn't currently enabled

			if (!account.enabled && statusItem.statusType != AIOfflineStatusType) {

				[account setEnabled:YES];

			}

			if (shouldRebuild) {

				//Rebuild our menus if there was a change

				[[NSNotificationCenter defaultCenter] postNotificationName:AIStatusStateArrayChangedNotification object:nil];

			}

		} else {

			[adium.statusController setActiveStatusState:(AIStatus *)statusItem];

		}

	}

}

/*!

 * @brief Select the custom state menu item

 *

 * Invoked by the custom state menu item, opens a custom state window.

 * If the representedObject NSDictionary has an @"AIAccount" object, configure just for the appropriate AIAccount.

 * Otherwise, configure globally.

 */

- (IBAction)selectCustomState:(id)sender

{

	NSDictionary	*dict = [sender representedObject];

	AIAccount		*account = [dict objectForKey:@"AIAccount"];

	AIStatusType	statusType = [sender tag];

	AIStatus		*baseStatusState;

	if (account) {

		baseStatusState = account.statusState;

	} else {

		baseStatusState = adium.statusController.activeStatusState;

	}

	/* If we are going to a custom state of a different type, we don't want to prefill with baseStatusState as it stands.

	 * Instead, we load the last used status of that type.

	 */

	if ((baseStatusState.statusType != statusType)) {

		NSDictionary *lastStatusStates = [adium.preferenceController preferenceForKey:@"LastStatusStates"

																				  group:PREF_GROUP_STATUS_PREFERENCES];

		NSData		*lastStatusStateData = [lastStatusStates objectForKey:[[NSNumber numberWithInt:statusType] stringValue]];

		AIStatus	*lastStatusStateOfThisType = (lastStatusStateData ?

												  [NSKeyedUnarchiver unarchiveObjectWithData:lastStatusStateData] :

												  nil);

		if (lastStatusStateOfThisType) {

			// Restore the current status message into this last-saved variety, since users tend want to keep them.

			// If it doesn't exist, use the last-saved status message.

			if (baseStatusState.statusMessage.length) {

				lastStatusStateOfThisType.statusMessage = baseStatusState.statusMessage;

			}

			baseStatusState = [[lastStatusStateOfThisType retain] autorelease];

		}

	}

	[AIEditStateWindowController editCustomState:baseStatusState

										 forType:statusType

									  andAccount:account

								  withSaveOption:YES

										onWindow:nil

								 notifyingTarget:adium.statusController];

}

#pragma mark -

#pragma mark Class methods

+ (NSMenu *)staticStatusStatesMenuNotifyingTarget:(id)target selector:(SEL)selector

{

	NSMenu			*statusStatesMenu = [[NSMenu allocWithZone:[NSMenu menuZone]] init];

	NSEnumerator	*enumerator;

	AIStatus		*statusState;

	AIStatusType	currentStatusType = AIAvailableStatusType;

	NSMenuItem		*menuItem;

	[statusStatesMenu setMenuChangedMessagesEnabled:NO];

	[statusStatesMenu setAutoenablesItems:NO];

	if (!target && !selector) {

		//Need to set a target and action for items with submenus (AIStatusGroups) to be selectable... so if we're not given one, set one.

		target = self;

		selector = @selector(dummyAction:);

	}

	/* Create a menu item for each state.  States must first be sorted such that states of the same AIStatusType

		* are grouped together.

		*/

	enumerator = [[adium.statusController sortedFullStateArray] objectEnumerator];

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

		AIStatusType thisStatusType = statusState.statusType;

		//We treat Invisible statuses as being the same as Away for purposes of the menu

		if (thisStatusType == AIInvisibleStatusType) thisStatusType = AIAwayStatusType;

		if (currentStatusType != thisStatusType) {

			//Add a divider between each type of status

			[statusStatesMenu addItem:[NSMenuItem separatorItem]];

			currentStatusType = thisStatusType;

		}

		menuItem = [[NSMenuItem alloc] initWithTitle:[AIStatusMenu titleForMenuDisplayOfState:statusState]

											  target:target

											  action:selector

									   keyEquivalent:@""];

		[menuItem setImage:[statusState menuIcon]];

		[menuItem setTag:statusState.statusType];

		[menuItem setRepresentedObject:[NSDictionary dictionaryWithObject:statusState

																   forKey:@"AIStatus"]];

		if ([statusState isKindOfClass:[AIStatus class]]) {

			[menuItem setToolTip:[statusState statusMessageTooltipString]];

		} else {

			/* AIStatusGroup */

			[menuItem setSubmenu:[(AIStatusGroup *)statusState statusSubmenuNotifyingTarget:target

																					 action:selector]];

		}

		[statusStatesMenu addItem:menuItem];

		[menuItem release];

	}

	[statusStatesMenu setMenuChangedMessagesEnabled:YES];

	return [statusStatesMenu autorelease];

}

/*!

* @brief Determine a string to use as a menu title

 *

 * This method truncates a state title string for display as a menu item.

 * Wide menus aren't pretty and may cause crashing in certain versions of OS X, so all state

 * titles should be run through this method before being used as menu item titles.

 *

 * @param statusState The state for which we want a title

 *

 * @result An appropriate NSString title

 */

+ (NSString *)titleForMenuDisplayOfState:(AIStatusItem *)statusState

{

	NSString	*title = [statusState title];

	/* Why plus 3? Say STATE_TITLE_MENU_LENGTH was 7, and the title is @"ABCDEFGHIJ".

	* The shortened title will be @"ABCDEFG..." which looks to be just as long - even

	* if the ellipsis is an ellipsis character and therefore technically two characters

	* shorter. Better to just use the full string, which appears as being the same length.

	*/

	if ([title length] > (STATE_TITLE_MENU_LENGTH + 3)) {

		title = [title stringWithEllipsisByTruncatingToLength:STATE_TITLE_MENU_LENGTH];

	}

	return title;

}

+ (void)dummyAction:(id)sender {};

@end