/*

* Copyright (c) 2010-2011 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <boost/filesystem/fstream.hpp>

#include <SwifTools/Notifier/Notifier.h>

namespace Swift {

/**

* Preconditions for using growlnotifier:

* - Must be part a bundle.

* - The Carbon/Cocoa application loop must be running (e.g. through QApplication)

* such that notifications are coming through.

*/

class GrowlNotifier : public Notifier {

public:

GrowlNotifier(const std::string& name);

~GrowlNotifier();

virtual void showMessage(Type type, const std::string& subject, const std::string& description, const boost::filesystem::path& picture, boost::function<void()> callback);

virtual bool isExternallyConfigured() const;

// Called by the delegate. Don't call.

void handleNotificationClicked(void* data);

void handleNotificationTimedOut(void* data);

private:

class Private;

boost::shared_ptr<Private> p;

};

}

class GrowlNotifier::Private {

public:

std::set<Context*> pendingNotifications;

boost::intrusive_ptr<GrowlNotifierDelegate> delegate;

};

GrowlNotifier::GrowlNotifier(const std::string& name) {

p = boost::make_shared<Private>();

p->delegate = boost::intrusive_ptr<GrowlNotifierDelegate>([[GrowlNotifierDelegate alloc] init], false);

p->delegate.get().notifier = this;

p->delegate.get().name = STD2NSSTRING(name);

NSMutableArray* allNotifications = [[NSMutableArray alloc] init];

foreach(Type type, getAllTypes()) {

[allNotifications addObject: STD2NSSTRING(typeToString(type))];

}

NSMutableArray* defaultNotifications = [[NSMutableArray alloc] init];

foreach(Type type, getDefaultTypes()) {

[defaultNotifications addObject: STD2NSSTRING(typeToString(type))];

}

p->delegate.get().registrationDictionary = [[[NSDictionary alloc]

initWithObjects: [NSArray arrayWithObjects: allNotifications, defaultNotifications, nil]

forKeys: [NSArray arrayWithObjects: GROWL_NOTIFICATIONS_ALL, GROWL_NOTIFICATIONS_DEFAULT, nil]] autorelease];

[allNotifications release];

[defaultNotifications release];

[GrowlApplicationBridge setGrowlDelegate: p->delegate.get()];

}

GrowlNotifier::~GrowlNotifier() {

[GrowlApplicationBridge setGrowlDelegate: nil];

}

void GrowlNotifier::showMessage(Type type, const std::string& subject, const std::string& description, const boost::filesystem::path& picturePath, boost::function<void()> callback) {

ByteArray picture;

readByteArrayFromFile(picture, picturePath.string());

Context* context = new Context(callback);

// Growl sometimes sends timeout notifications twice for the same message. We therefore need

// to keep track of which ones have already been processed.

p->pendingNotifications.insert(context);

[GrowlApplicationBridge

notifyWithTitle: STD2NSSTRING(subject)

description: STD2NSSTRING(description)

notificationName: STD2NSSTRING(typeToString(type))

iconData: [NSData dataWithBytes: vecptr(picture) length: picture.size()]

priority: 0

isSticky: NO

clickContext: [NSData dataWithBytes: &context length: sizeof(context)]];

}

void GrowlNotifier::handleNotificationClicked(void* rawData) {

Context* context = *(Context**) [((NSData*) rawData) bytes];

if (p->pendingNotifications.erase(context) > 0) {

if (!context->callback->empty()) {

(*context->callback)();

}

delete context;

}

}

void GrowlNotifier::handleNotificationTimedOut(void* rawData) {

Context* context = *(Context**) [((NSData*) rawData) bytes];

if (p->pendingNotifications.erase(context) > 0) {

delete context;

}

}

bool GrowlNotifier::isExternallyConfigured() const {

return ![GrowlApplicationBridge isMistEnabled];

}

}