/* 

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

#import "AISoundController.h"

#import <AIUtilities/AIDictionaryAdditions.h>

#import <AIUtilities/AISleepNotification.h>

#import <CoreAudio/AudioHardware.h>

#import <CoreServices/CoreServices.h>

#import <sys/sysctl.h>

#define SOUND_DEFAULT_PREFS				@"SoundPrefs"

#define MAX_CACHED_SOUNDS				4			//Max cached sounds

@interface AdiumSound ()

- (void)_stopAndReleaseAllSounds;

- (void)_setVolumeOfAllSoundsTo:(CGFloat)inVolume;

- (void)cachedPlaySound:(NSString *)inPath;

- (void)_uncacheLeastRecentlyUsedSound;

- (NSString *)systemAudioDeviceID;

- (void)configureAudioContextForSound:(NSSound *)sound;

- (NSArray *)allSounds;

@end

@interface NSProcessInfo (AIProcessorInfoAdditions)

- (BOOL)processorFamilyIsG5;

@end

static OSStatus systemOutputDeviceDidChange(AudioHardwarePropertyID property, void *refcon);

@implementation AdiumSound

/*!

 * @brief Init

 */

- (id)init

{

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

		soundCacheDict = [[NSMutableDictionary alloc] init];

		soundCacheArray = [[NSMutableArray alloc] init];

		soundCacheCleanupTimer = nil;

		soundsAreMuted = NO;

		//Observe workspace activity changes so we can mute sounds as necessary

		NSNotificationCenter *workspaceCenter = [[NSWorkspace sharedWorkspace] notificationCenter];

		[workspaceCenter addObserver:self

							selector:@selector(workspaceSessionDidBecomeActive:)

								name:NSWorkspaceSessionDidBecomeActiveNotification

							  object:nil];

		[workspaceCenter addObserver:self

							selector:@selector(workspaceSessionDidResignActive:)

								name:NSWorkspaceSessionDidResignActiveNotification

							  object:nil];

		//Monitor system sleep so we can stop sounds before sleeping; otherwise, we may crash while waking

		[[NSNotificationCenter defaultCenter] addObserver:self

												 selector:@selector(systemWillSleep:)

													 name:AISystemWillSleep_Notification

												   object:nil];

		/* Sign up for notification when the user changes the system output device in the Sound pane of System Preferences.

		 *

		 * However, we avoid doing this on G5 machines. G5s spew a continuous stream of

		 * kAudioHardwarePropertyDefaultSystemOutputDevice notifications without the device actually changing;

		 * rather than stutter our audio and eat CPU continuously, we just won't try to update.

		 */

		if (![[NSProcessInfo processInfo] processorFamilyIsG5]) {

			OSStatus err = AudioHardwareAddPropertyListener(kAudioHardwarePropertyDefaultSystemOutputDevice, systemOutputDeviceDidChange, /*refcon*/ self);

			if (err != noErr)

				NSLog(@"%s: Couldn't sign up for system-output-device-changed notification, because AudioHardwareAddPropertyListener returned %i. Adium will not know when the default system audio device changes.", __PRETTY_FUNCTION__, err);			

		} else {

			//We won't be updating automatically, so reconfigure before a sound is played again

			reconfigureAudioContextBeforeEachPlay = YES;

		}

	}

	return self;

}

- (void)controllerDidLoad

{

	//Register our default preferences and observe changes

	[adium.preferenceController registerDefaults:[NSDictionary dictionaryNamed:SOUND_DEFAULT_PREFS forClass:[self class]]

										  forGroup:PREF_GROUP_SOUNDS];

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

}

- (void)dealloc

{

	[adium.preferenceController unregisterPreferenceObserver:self];

	[[[NSWorkspace sharedWorkspace] notificationCenter] removeObserver:self];

	[[NSNotificationCenter defaultCenter] removeObserver:self];

	[self _stopAndReleaseAllSounds];

	[soundCacheDict release]; soundCacheDict = nil;

	[soundCacheArray release]; soundCacheArray = nil;

	[soundCacheCleanupTimer invalidate]; [soundCacheCleanupTimer release]; soundCacheCleanupTimer = nil;

	[super dealloc];

}

- (void)playSoundAtPath:(NSString *)inPath

{

	if (inPath && customVolume != 0.0 && !soundsAreMuted) {

		[self cachedPlaySound:inPath];

	}

}

- (void)stopPlayingSoundAtPath:(NSString *)inPath

{

	NSSound *sound = [soundCacheDict objectForKey:inPath];

	if (sound) {

		[sound stop];

	}

}

/*!

 * @brief Preferences changed, adjust to the new values

 */

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

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

{

	CGFloat newVolume = [[prefDict objectForKey:KEY_SOUND_CUSTOM_VOLUME_LEVEL] doubleValue];

	//If sound volume has changed, we must update all existing sounds to the new volume

	if (customVolume != newVolume) {

		[self _setVolumeOfAllSoundsTo:newVolume];

	}

	//Load the new preferences

	customVolume = newVolume;

}

/*!

 * @brief Stop and release all cached sounds

 */

- (void)_stopAndReleaseAllSounds

{

	[[soundCacheDict allValues] makeObjectsPerformSelector:@selector(stop)];

	[soundCacheDict removeAllObjects];

	[soundCacheArray removeAllObjects];

}

/*!

 * @brief Update the volume of all cached sounds

 */

- (void)_setVolumeOfAllSoundsTo:(CGFloat)inVolume

{

	for (NSSound *sound in [soundCacheDict objectEnumerator]) {

		[sound setVolume:inVolume];

	}

}

/*!

 * @brief Play an NSSound, possibly cached

 * 

 * @param inPath path to the sound file

 */

- (void)cachedPlaySound:(NSString *)inPath

{

	NSSound *sound = [soundCacheDict objectForKey:inPath];

	//Load the sound if necessary

	if (!sound) {

		//If the cache is full, remove the least recently used cached sound

		if ([soundCacheDict count] >= MAX_CACHED_SOUNDS) {

			[self _uncacheLeastRecentlyUsedSound];

		}

		//Load and cache the sound

		NSError *error = nil;

		sound = [[NSSound alloc] initWithContentsOfFile:inPath byReference:NO];

		if (sound) {

			//Insert the player at the front of our cache

			[soundCacheArray insertObject:inPath atIndex:0];

			[soundCacheDict setObject:sound forKey:inPath];

			[sound release];

			//Set the volume (otherwise #2283 happens)

			[sound setVolume:customVolume];

			[self configureAudioContextForSound:sound];

		} else {

			AILogWithSignature(@"Error loading %@: %@", inPath, error);

		}

	} else {

		//Move this sound to the front of the cache (This will naturally move lesser used sounds to the back for removal)

		[soundCacheArray removeObject:inPath];

		[soundCacheArray insertObject:inPath atIndex:0];

		if (reconfigureAudioContextBeforeEachPlay) {

			[sound stop];

			[self configureAudioContextForSound:sound];

		}

	}

	//Engage!

	if (sound) {

		[sound setCurrentTime:0.0];

		//This only has an effect if the sound is not already playing. It won't stop it, and it won't start it over (the latter is what setCurrentTime: is for).

		[sound play];

	}

}

/*!

 * @brief Remove the least recently used sound from the cache

 */

- (void)_uncacheLeastRecentlyUsedSound

{

	NSString			*lastCachedPath = [soundCacheArray lastObject];

	NSSound *sound = [soundCacheDict objectForKey:lastCachedPath];

	//Remove it from the cache only if it is not playing.

	if (![sound isPlaying]) {

		[soundCacheDict removeObjectForKey:lastCachedPath];

		[soundCacheArray removeLastObject];

	}

}

- (NSString *)systemAudioDeviceID

{

	OSStatus err;

	UInt32 dataSize;

	//First, obtain the device itself.

	AudioDeviceID systemOutputDevice = 0;

	dataSize = sizeof(systemOutputDevice);

	err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultSystemOutputDevice, &dataSize, &systemOutputDevice);

	if (err != noErr) {

		NSLog(@"%s: Could not get the system output device: AudioHardwareGetProperty returned error %i", __PRETTY_FUNCTION__, err);

		return NULL;

	}

	//Now get its UID. We'll need to release this.

	CFStringRef deviceUID = NULL;

	dataSize = sizeof(deviceUID);

	err = AudioDeviceGetProperty(systemOutputDevice, /*channel*/ 0, /*isInput*/ false, kAudioDevicePropertyDeviceUID, &dataSize, &deviceUID);

	if (err != noErr) {

		NSLog(@"%s: Could not get the device UID for device %p: AudioDeviceGetProperty returned error %i", __PRETTY_FUNCTION__, systemOutputDevice, err);

		return NULL;

	}

	[(NSString *)deviceUID autorelease];

	return (NSString *)deviceUID;

}

- (void)configureAudioContextForSound:(NSSound *)sound

{

	[sound pause];

	//Exchange the audio context for a new one with the new device.

	NSString *deviceUID = [self systemAudioDeviceID];

	[sound setPlaybackDeviceIdentifier:deviceUID];

	//Resume playback, now on the new device.

	[sound resume];

}

- (NSArray *)allSounds

{

	return [soundCacheDict allValues];

}

/*!

 * @brief Workspace activated (Computer switched to our user)

 */

- (void)workspaceSessionDidBecomeActive:(NSNotification *)notification

{

	[self setSoundsAreMuted:NO];

}

/*!

 * @brief Workspace resigned (Computer switched to another user)

 */

- (void)workspaceSessionDidResignActive:(NSNotification *)notification

{

	[self setSoundsAreMuted:YES];

}

- (void)systemWillSleep:(NSNotification *)notification

{

	[self _stopAndReleaseAllSounds];

}

- (void)setSoundsAreMuted:(BOOL)mute

{

	AILog(@"setSoundsAreMuted: %i",mute);

	if (soundsAreMuted > 0 && !mute)

		soundsAreMuted--;

	else if (mute)

		soundsAreMuted++;

	if (soundsAreMuted == 1)

		[self _stopAndReleaseAllSounds];

}

- (void)systemOutputDeviceDidChange

{

	for (NSSound *sound in [self allSounds]) {

		[self configureAudioContextForSound:sound];

	}

}

@end

static OSStatus systemOutputDeviceDidChange(AudioHardwarePropertyID property, void *refcon)

{

#pragma unused(property)

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

	AdiumSound *self = (id)refcon;

	NSCAssert1(self, @"AudioHardware property listener function %s called with nil refcon, which we expected to be the AdiumSound instance", __PRETTY_FUNCTION__);

	[self performSelectorOnMainThread:@selector(systemOutputDeviceDidChange)

						   withObject:nil

						waitUntilDone:NO];

	[pool release];

	return noErr;

}

@implementation NSProcessInfo (AIProcessorInfoAdditions)

- (BOOL)processorFamilyIsG5

{

	/* Credit to http://www.cocoadev.com/index.pl?MacintoshModels */

	BOOL	isG5 = NO;

	char	buffer[128];

	size_t	length = sizeof(buffer);

	if (sysctlbyname("hw.model", &buffer, &length, NULL, 0) == 0) {

		NSString	*hardwareModel = [NSString stringWithUTF8String:buffer];

		NSArray		*knownG5Macs = [NSArray arrayWithObjects:@"PowerMac11,2" /* G5 PCIe */, @"PowerMac12,1" /* iMac G5 (iSight) */, 

									@"PowerMac7,2" /* PowerMac G5 */, @"PowerMac7,3" /* PowerMac G5 */, @"PowerMac8,1" /* iMac G5 */,

									@"PowerMac8,2" /* iMac G5 Ambient Light Sensor */, @"PowerMac9,1" /* Power Mac G5 (Late 2004) */,

									@"RackMac3,1" /* Xserve G5 */, nil];

		if ([knownG5Macs containsObject:hardwareModel]) {

			AILogWithSignature(@"On a G5 Mac.");

			isG5 = YES;

		}

	}

	return isG5;

}

@end