#import <Cocoa/Cocoa.h>
#import <ScriptingBridge/ScriptingBridge.h>
#import "syphon-framework/Syphon.h"
#include <obs-module.h>

#define LOG(level, message, ...) \
	blog(level, "%s: " message, obs_source_get_name(s->source),  ##__VA_ARGS__)

struct syphon {
	SYPHON_CLIENT_UNIQUE_CLASS_NAME *client;
	IOSurfaceRef ref;

	gs_samplerstate_t *sampler;
	gs_effect_t       *effect;
	gs_vertbuffer_t   *vertbuffer;
	gs_texture_t      *tex;
	uint32_t          width, height;
	bool              crop;
	CGRect            crop_rect;
	bool              allow_transparency;

	obs_source_t *source;

	bool active;
	bool uuid_changed;
	id   new_server_listener;
	id   retire_listener;

	NSString *app_name;
	NSString *name;
	NSString *uuid;

	obs_data_t *inject_info;
	bool       inject_active;
	id         launch_listener;
};
typedef struct syphon *syphon_t;

static inline void objc_release(NSObject **obj)
{
	[*obj release];
	*obj = nil;
}

static inline void update_properties(syphon_t s)
{
	obs_source_update_properties(s->source);
}

static inline void find_and_inject_target(syphon_t s, NSArray *arr);

@interface OBSSyphonKVObserver : NSObject
- (void)observeValueForKeyPath:(NSString *)keyPath
                      ofObject:(id)object
                        change:(NSDictionary *)change
                       context:(void *)context;
@end

static inline void handle_application_launch(syphon_t s, NSArray *new)
{
	if (!s->inject_active)
		return;

	if (!new)
		return;

	find_and_inject_target(s, new);
}

@implementation OBSSyphonKVObserver
- (void)observeValueForKeyPath:(NSString *)keyPath
                      ofObject:(id)object
                        change:(NSDictionary *)change
                       context:(void *)context
{
	UNUSED_PARAMETER(keyPath);
	UNUSED_PARAMETER(object);

	syphon_t s = context;
	if (!s)
		return;

	handle_application_launch(s, change[NSKeyValueChangeNewKey]);
	update_properties(s);
}
@end

static const char *syphon_get_name()
{
	return "Syphon";
}

static void stop_client(syphon_t s)
{
	obs_enter_graphics();

	if (s->client) {
		@autoreleasepool {
			[s->client stop];
			objc_release(&s->client);
		}
	}

	if (s->tex) {
		gs_texture_destroy(s->tex);
		s->tex = NULL;
	}

	if (s->ref) {
		IOSurfaceDecrementUseCount(s->ref);
		CFRelease(s->ref);
		s->ref = NULL;
	}

	s->width  = 0;
	s->height = 0;

	obs_leave_graphics();
}

static inline NSDictionary *find_by_uuid(NSArray *arr, NSString *uuid)
{
	for (NSDictionary *dict in arr) {
		if ([dict[SyphonServerDescriptionUUIDKey] isEqual:uuid])
			return dict;
	}

	return nil;
}

static inline void check_version(syphon_t s, NSDictionary *desc)
{
	extern const NSString *SyphonServerDescriptionDictionaryVersionKey;

	NSNumber *version = desc[SyphonServerDescriptionDictionaryVersionKey];
	if (!version)
		return LOG(LOG_WARNING, "Server description does not contain "
					"VersionKey");

	if (version.unsignedIntValue > 0)
		LOG(LOG_WARNING, "Got server description version %d, "
				 "expected 0", version.unsignedIntValue);
}

static inline void check_description(syphon_t s, NSDictionary *desc)
{
	extern const NSString *SyphonSurfaceType;
	extern const NSString *SyphonSurfaceTypeIOSurface;
	extern const NSString *SyphonServerDescriptionSurfacesKey;

	NSArray *surfaces = desc[SyphonServerDescriptionSurfacesKey];
	if (!surfaces)
		return LOG(LOG_WARNING, "Server description does not contain "
					"SyphonServerDescriptionSurfacesKey");

	if (!surfaces.count)
		return LOG(LOG_WARNING, "Server description contains empty "
					"SyphonServerDescriptionSurfacesKey");

	for (NSDictionary *surface in surfaces) {
		NSString *type = surface[SyphonSurfaceType];
		if (type && [type isEqual:SyphonSurfaceTypeIOSurface])
			return;
	}

	NSString *surfaces_string = [NSString stringWithFormat:@"%@", surfaces];
	LOG(LOG_WARNING, "SyphonSurfaces does not contain"
			 "'SyphonSurfaceTypeIOSurface': %s",
			 surfaces_string.UTF8String);
}

static inline bool update_string(NSString **str, NSString *new)
{
	if (!new)
		return false;

	[*str release];
	*str = [new retain];
	return true;
}

static inline void handle_new_frame(syphon_t s,
		SYPHON_CLIENT_UNIQUE_CLASS_NAME *client)
{
	IOSurfaceRef ref = [client IOSurface];

	if (!ref)
		return;

	if (ref == s->ref) {
		CFRelease(ref);
		return;
	}

	IOSurfaceIncrementUseCount(ref);

	obs_enter_graphics();
	if (s->ref) {
		gs_texture_destroy(s->tex);
		IOSurfaceDecrementUseCount(s->ref);
		CFRelease(s->ref);
	}

	s->ref    = ref;
	s->tex    = gs_texture_create_from_iosurface(s->ref);
	s->width  = gs_texture_get_width(s->tex);
	s->height = gs_texture_get_height(s->tex);
	obs_leave_graphics();
}

static void create_client(syphon_t s)
{
	stop_client(s);

	if (!s->app_name.length && !s->name.length && !s->uuid.length)
		return;

	SyphonServerDirectory *ssd = [SyphonServerDirectory sharedDirectory];
	NSArray *servers = [ssd serversMatchingName:s->name
					    appName:s->app_name];
	if (!servers.count)
		return;

	NSDictionary *desc = find_by_uuid(servers, s->uuid);
	if (!desc) {
		desc = servers[0];
		if (update_string(&s->uuid,
					desc[SyphonServerDescriptionUUIDKey]))
			s->uuid_changed = true;
	}

	check_version(s, desc);
	check_description(s, desc);

	@autoreleasepool {
		s->client = [[SYPHON_CLIENT_UNIQUE_CLASS_NAME alloc]
			initWithServerDescription:desc
					  options:nil
				  newFrameHandler:^
				  (SYPHON_CLIENT_UNIQUE_CLASS_NAME *client)
		{
			handle_new_frame(s, client);
		}];
	}

	s->active = true;
}

static inline void release_settings(syphon_t s)
{
	[s->app_name release];
	[s->name     release];
	[s->uuid     release];
}

static inline bool load_syphon_settings(syphon_t s, obs_data_t *settings)
{
	NSString *app_name = @(obs_data_get_string(settings, "app_name"));
	NSString *name     = @(obs_data_get_string(settings, "name"));
	bool equal_names   = [app_name isEqual:s->app_name] &&
				 [name isEqual:s->name];
	if (s->uuid_changed && equal_names)
		return false;

	NSString *uuid     = @(obs_data_get_string(settings, "uuid"));
	if ([uuid isEqual:s->uuid] && equal_names)
		return false;

	release_settings(s);
	s->app_name     = [app_name retain];
	s->name         = [name     retain];
	s->uuid         = [uuid     retain];
	s->uuid_changed = false;
	return true;
}

static inline void update_from_announce(syphon_t s, NSDictionary *info)
{
	if (s->active)
		return;

	if (!info)
		return;

	NSString *app_name = info[SyphonServerDescriptionAppNameKey];
	NSString *name     = info[SyphonServerDescriptionNameKey];
	NSString *uuid     = info[SyphonServerDescriptionUUIDKey];

	if (![uuid isEqual:s->uuid] &&
		!([app_name isEqual:s->app_name] && [name isEqual:s->name]))
		return;

	update_string(&s->app_name, app_name);
	update_string(&s->name,     name);
	if (update_string(&s->uuid, uuid))
		s->uuid_changed = true;

	create_client(s);
}

static inline void handle_announce(syphon_t s, NSNotification *note)
{
	if (!note)
		return;

	update_from_announce(s, note.object);
	update_properties(s);
}

static inline void update_from_retire(syphon_t s, NSDictionary *info)
{
	if (!info)
		return;

	NSString *uuid = info[SyphonServerDescriptionUUIDKey];
	if (!uuid)
		return;

	if (![uuid isEqual:s->uuid])
		return;

	s->active = false;
}

static inline void handle_retire(syphon_t s, NSNotification *note)
{
	if (!note)
		return;

	update_from_retire(s, note.object);
	update_properties(s);
}

static inline gs_vertbuffer_t *create_vertbuffer()
{
	struct gs_vb_data *vb_data = gs_vbdata_create();
	vb_data->num = 4;
	vb_data->points = bzalloc(sizeof(struct vec3) * 4);
	if (!vb_data->points)
		return NULL;

	vb_data->num_tex = 1;
	vb_data->tvarray = bzalloc(sizeof(struct gs_tvertarray));
	if (!vb_data->tvarray)
		goto fail_tvarray;

	vb_data->tvarray[0].width = 2;
	vb_data->tvarray[0].array = bzalloc(sizeof(struct vec2) * 4);
	if (!vb_data->tvarray[0].array)
		goto fail_array;

	gs_vertbuffer_t *vbuff = gs_vertexbuffer_create(vb_data, GS_DYNAMIC);
	if (vbuff)
		return vbuff;

	bfree(vb_data->tvarray[0].array);
fail_array:
	bfree(vb_data->tvarray);
fail_tvarray:
	bfree(vb_data->points);

	return NULL;
}

static inline bool init_obs_graphics_objects(syphon_t s)
{
	struct gs_sampler_info info = {
		.filter         = GS_FILTER_LINEAR,
		.address_u      = GS_ADDRESS_CLAMP,
		.address_v      = GS_ADDRESS_CLAMP,
		.address_w      = GS_ADDRESS_CLAMP,
		.max_anisotropy = 1,
	};

	obs_enter_graphics();
	s->sampler    = gs_samplerstate_create(&info);
	s->vertbuffer = create_vertbuffer();
	obs_leave_graphics();

	s->effect     = obs_get_default_rect_effect();

	return s->sampler != NULL && s->vertbuffer != NULL && s->effect != NULL;
}

static inline bool create_syphon_listeners(syphon_t s)
{
	NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
	s->new_server_listener   = [nc
		addObserverForName:SyphonServerAnnounceNotification
			    object:nil
			     queue:[NSOperationQueue mainQueue]
			usingBlock:^(NSNotification *note)
		{
			handle_announce(s, note);
		}
	];

	s->retire_listener       = [nc
		addObserverForName:SyphonServerRetireNotification
			    object:nil
			     queue:[NSOperationQueue mainQueue]
			usingBlock:^(NSNotification *note)
		{
			handle_retire(s, note);
		}
	];

	return s->new_server_listener != nil && s->retire_listener != nil;
}

static inline bool create_applications_observer(syphon_t s, NSWorkspace *ws)
{
	s->launch_listener = [[OBSSyphonKVObserver alloc] init];
	if (!s->launch_listener)
		return false;

	[ws addObserver:s->launch_listener
	     forKeyPath:NSStringFromSelector(@selector(runningApplications))
		options:NSKeyValueObservingOptionNew
		context:s];

	return true;
}

static inline void load_crop(syphon_t s, obs_data_t *settings)
{
	s->crop = obs_data_get_bool(settings, "crop");

#define LOAD_CROP(x) \
	s->crop_rect.x = obs_data_get_double(settings, "crop." #x)
	LOAD_CROP(origin.x);
	LOAD_CROP(origin.y);
	LOAD_CROP(size.width);
	LOAD_CROP(size.height);
#undef LOAD_CROP
}

static inline void syphon_destroy_internal(syphon_t s);

static void *syphon_create_internal(obs_data_t *settings, obs_source_t *source)
{
	UNUSED_PARAMETER(source);

	syphon_t s = bzalloc(sizeof(struct syphon));
	if (!s)
		return s;

	s->source  = source;

	if (!init_obs_graphics_objects(s))
		goto fail;

	if (!load_syphon_settings(s, settings))
		goto fail;

	const char *inject_info = obs_data_get_string(settings, "application");
	s->inject_info          = obs_data_create_from_json(inject_info);
	s->inject_active        = obs_data_get_bool(settings, "inject");

	if (!create_syphon_listeners(s))
		goto fail;

	NSWorkspace *ws = [NSWorkspace sharedWorkspace];
	if (!create_applications_observer(s, ws))
		goto fail;

	if (s->inject_active)
		find_and_inject_target(s, ws.runningApplications);

	create_client(s);

	load_crop(s, settings);

	s->allow_transparency = obs_data_get_bool(settings,
			"allow_transparency");

	return s;

fail:
	syphon_destroy_internal(s);
	return NULL;
}

static void *syphon_create(obs_data_t *settings, obs_source_t *source)
{
	@autoreleasepool {
		return syphon_create_internal(settings, source);
	}
}

static inline void stop_listener(id listener)
{
	if (!listener)
		return;

	NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
	[nc removeObserver:listener];
}

static inline void syphon_destroy_internal(syphon_t s)
{
	stop_listener(s->new_server_listener);
	stop_listener(s->retire_listener);

	NSWorkspace *ws = [NSWorkspace sharedWorkspace];
	[ws removeObserver:s->launch_listener
		forKeyPath:NSStringFromSelector(@selector(runningApplications))];
	objc_release(&s->launch_listener);

	obs_data_release(s->inject_info);

	release_settings(s);

	obs_enter_graphics();
	stop_client(s);
	
	if (s->sampler)
		gs_samplerstate_destroy(s->sampler);
	if (s->vertbuffer)
		gs_vertexbuffer_destroy(s->vertbuffer);
	obs_leave_graphics();

	bfree(s);
}

static void syphon_destroy(void *data)
{
	@autoreleasepool {
		syphon_destroy_internal(data);
	}
}

static inline NSString *get_string(obs_data_t *settings, const char *name)
{
	if (!settings)
		return nil;

	return @(obs_data_get_string(settings, name));
}

static inline void update_strings_from_context(syphon_t s, obs_data_t *settings,
		NSString **app, NSString **name, NSString **uuid)
{
	if (!s || !s->uuid_changed)
		return;

	s->uuid_changed = false;
	*app  = s->app_name;
	*name = s->name;
	*uuid = s->uuid;

	obs_data_set_string(settings, "app_name", s->app_name.UTF8String);
	obs_data_set_string(settings, "name",     s->name.UTF8String);
	obs_data_set_string(settings, "uuid",     s->uuid.UTF8String);
}

static inline void add_servers(syphon_t s, obs_property_t *list,
		obs_data_t *settings)
{
	bool found_current = settings == NULL;

	NSString *set_app  = get_string(settings, "app_name");
	NSString *set_name = get_string(settings, "name");
	NSString *set_uuid = get_string(settings, "uuid");

	update_strings_from_context(s, settings,
			&set_app, &set_name, &set_uuid);

	obs_property_list_add_string(list, "", "");
	NSArray *arr = [[SyphonServerDirectory sharedDirectory] servers];
	for (NSDictionary *server in arr) {
		NSString *app  = server[SyphonServerDescriptionAppNameKey];
		NSString *name = server[SyphonServerDescriptionNameKey];
		NSString *uuid = server[SyphonServerDescriptionUUIDKey];
		NSString *serv = [NSString stringWithFormat:@"[%@] %@",
		      app, name];

		obs_property_list_add_string(list,
				serv.UTF8String, uuid.UTF8String);

		if (!found_current)
			found_current = [uuid isEqual:set_uuid];
	}

	if (found_current || !set_uuid.length || !set_app.length)
		return;

	NSString *serv = [NSString stringWithFormat:@"[%@] %@",
		 set_app, set_name];
	size_t idx     = obs_property_list_add_string(list,
			serv.UTF8String, set_uuid.UTF8String);
	obs_property_list_item_disable(list, idx, true);
}

static bool servers_changed(obs_properties_t *props, obs_property_t *list,
		obs_data_t *settings)
{
	@autoreleasepool {
		obs_property_list_clear(list);
		add_servers(obs_properties_get_param(props), list, settings);
		return true;
	}
}

static inline NSString *get_inject_application_path()
{
	static NSString *ident = @"zakk.lol.SyphonInject";
	NSWorkspace *ws = [NSWorkspace sharedWorkspace];
	return [ws absolutePathForAppBundleWithIdentifier:ident];
}

static inline bool is_inject_available_in_lib_dir(NSFileManager *fm, NSURL *url)
{
	if (!url.isFileURL)
		return false;

	for (NSString *path in [fm
			contentsOfDirectoryAtPath:url.path
					    error:nil]) {
		NSURL *bundle_url = [url URLByAppendingPathComponent:path];
		NSBundle  *bundle = [NSBundle bundleWithURL:bundle_url];
		if (!bundle)
			continue;

		if ([bundle.bundleIdentifier
				isEqual:@"zakk.lol.SASyphonInjector"])
			return true;
	}

	return false;
}

static inline bool is_inject_available()
{
	if (get_inject_application_path())
		return true;

	NSFileManager *fm = [NSFileManager defaultManager];
	for (NSURL *url in [fm URLsForDirectory:NSLibraryDirectory
				      inDomains:NSAllDomainsMask]) {
		NSURL *scripting = [url
			URLByAppendingPathComponent:@"ScriptingAdditions"
					isDirectory:true];
		if (is_inject_available_in_lib_dir(fm, scripting))
			return true;
	}

	return false;
}

static inline void launch_syphon_inject_internal()
{
	NSString *path = get_inject_application_path();
	NSWorkspace *ws = [NSWorkspace sharedWorkspace];
	if (path)
		[ws launchApplication:path];
}

static bool launch_syphon_inject(obs_properties_t *props, obs_property_t *prop,
		void *data)
{
	UNUSED_PARAMETER(props);
	UNUSED_PARAMETER(prop);
	UNUSED_PARAMETER(data);

	@autoreleasepool {
		launch_syphon_inject_internal();
		return false;
	}
}

static int describes_app(obs_data_t *info, NSRunningApplication *app)
{
	int score = 0;
	if ([app.localizedName    isEqual:get_string(info, "name")])
		score += 1;

	if ([app.bundleIdentifier isEqual:get_string(info, "bundle")])
		score += 1;

	if ([app.executableURL    isEqual:get_string(info, "executable")])
		score += 1;

	if (score && app.processIdentifier == obs_data_get_int(info, "pid"))
		score += 1;

	return score;
}

static inline void app_to_data(NSRunningApplication *app, obs_data_t *app_data)
{
	obs_data_set_string(app_data, "name", app.localizedName.UTF8String);
	obs_data_set_string(app_data, "bundle",
			app.bundleIdentifier.UTF8String);
	obs_data_set_string(app_data, "executable",
			app.executableURL.fileSystemRepresentation);
	obs_data_set_int(app_data, "pid", app.processIdentifier);
}

static void update_inject_list_internal(obs_properties_t *props,
		obs_property_t *prop, obs_data_t *settings)
{
	UNUSED_PARAMETER(props);

	const char *current_str = obs_data_get_string(settings, "application");
	obs_data_t *current     = obs_data_create_from_json(current_str);

	bool current_found = !obs_data_has_user_value(current, "name");

	obs_property_list_clear(prop);
	obs_property_list_add_string(prop, "", "");

	NSMapTable *candidates = [NSMapTable weakToStrongObjectsMapTable];

	obs_data_t *app_data = obs_data_create();
	NSWorkspace *ws = [NSWorkspace sharedWorkspace];
	for (NSRunningApplication *app in ws.runningApplications) {
		app_to_data(app, app_data);

		obs_property_list_add_string(prop, app.localizedName.UTF8String,
				obs_data_get_json(app_data));

		int score = describes_app(current, app);
		if (score) {
			[candidates setObject:@(score) forKey:app];
			current_found = true;
		}
	}
	obs_data_release(app_data);

	if (!current_found) {
		size_t idx = obs_property_list_add_string(prop,
				obs_data_get_string(current, "name"),
				current_str);
		obs_property_list_item_disable(prop, idx, true);

	} else if (candidates.count > 0) {
		NSRunningApplication *best_match = nil;
		NSNumber *best_match_score = @(0);

		for (NSRunningApplication *app in candidates.keyEnumerator) {
			NSNumber *score = [candidates objectForKey:app];
			if ([score compare:best_match_score] ==
					NSOrderedDescending) {
				best_match = app;
				best_match_score = score;
			}
		}

		app_to_data(best_match, current);
		obs_data_set_string(settings, "application",
				obs_data_get_json(current));
	}

	obs_data_release(current);
}

static void toggle_inject_internal(obs_properties_t *props,
		obs_property_t *prop, obs_data_t *settings)
{
	bool enabled = obs_data_get_bool(settings, "inject");
	obs_property_t *inject_list = obs_properties_get(props, "application");

	bool inject_enabled = obs_property_enabled(prop);
	obs_property_set_enabled(inject_list, enabled && inject_enabled);
}

static bool toggle_inject(obs_properties_t *props, obs_property_t *prop,
		obs_data_t *settings)
{
	@autoreleasepool {
		toggle_inject_internal(props, prop, settings);
		return true;
	}
}

static bool update_inject_list(obs_properties_t *props, obs_property_t *prop,
		obs_data_t *settings)
{
	@autoreleasepool {
		update_inject_list_internal(props, prop, settings);
		return true;
	}
}

static bool update_crop(obs_properties_t *props, obs_property_t *prop,
		obs_data_t *settings)
{
	bool enabled = obs_data_get_bool(settings, "crop");

#define LOAD_CROP(x) \
	prop = obs_properties_get(props, "crop." #x); \
	obs_property_set_enabled(prop, enabled);
	LOAD_CROP(origin.x);
	LOAD_CROP(origin.y);
	LOAD_CROP(size.width);
	LOAD_CROP(size.height);
#undef LOAD_CROP

	return true;
}

static void show_syphon_license_internal(void)
{
	char *path = obs_module_file("syphon_license.txt");
	if (!path)
		return;

	NSWorkspace *ws = [NSWorkspace sharedWorkspace];
	[ws openFile:@(path)];
	bfree(path);
}

static bool show_syphon_license(obs_properties_t *props, obs_property_t *prop,
		void *data)
{
	UNUSED_PARAMETER(props);
	UNUSED_PARAMETER(prop);
	UNUSED_PARAMETER(data);

	@autoreleasepool {
		show_syphon_license_internal();
		return false;
	}
}

static void syphon_release(void *param)
{
	if (!param)
		return;

	obs_source_release(((syphon_t)param)->source);
}

static inline obs_properties_t *syphon_properties_internal(syphon_t s)
{
	if (s)
		obs_source_addref(s->source);

	obs_properties_t *props = obs_properties_create_param(s,
			syphon_release);

	obs_property_t *list = obs_properties_add_list(props,
			"uuid", obs_module_text("Source"),
			OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
	obs_property_set_modified_callback(list, servers_changed);

	obs_properties_add_bool(props, "allow_transparency",
			obs_module_text("AllowTransparency"));

	obs_property_t *launch = obs_properties_add_button(props,
			"launch inject", obs_module_text("LaunchSyphonInject"),
			launch_syphon_inject);

	obs_property_t *inject = obs_properties_add_bool(props,
			"inject", obs_module_text("Inject"));
	obs_property_set_modified_callback(inject, toggle_inject);

	obs_property_t *inject_list = obs_properties_add_list(props,
			"application", obs_module_text("Application"),
			OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
	obs_property_set_modified_callback(inject_list, update_inject_list);

	if (!get_inject_application_path())
		obs_property_set_enabled(launch, false);

	if (!is_inject_available()) {
		obs_property_set_enabled(inject, false);
		obs_property_set_enabled(inject_list, false);
	}

	obs_property_t *crop = obs_properties_add_bool(props, "crop",
			obs_module_text("Crop"));
	obs_property_set_modified_callback(crop, update_crop);

#define LOAD_CROP(x) \
	obs_properties_add_float(props, "crop." #x, \
		obs_module_text("Crop." #x), 0., 4096.f, .5f);
	LOAD_CROP(origin.x);
	LOAD_CROP(origin.y);
	LOAD_CROP(size.width);
	LOAD_CROP(size.height);
#undef LOAD_CROP

	obs_properties_add_button(props, "syphon license",
			obs_module_text("SyphonLicense"),
			show_syphon_license);

	return props;
}

static obs_properties_t *syphon_properties(void *data)
{
	@autoreleasepool {
		return syphon_properties_internal(data);
	}
}

static inline void syphon_save_internal(syphon_t s, obs_data_t *settings)
{
	if (!s->uuid_changed)
		return;

	obs_data_set_string(settings, "app_name", s->app_name.UTF8String);
	obs_data_set_string(settings, "name",     s->name.UTF8String);
	obs_data_set_string(settings, "uuid",     s->uuid.UTF8String);
}

static void syphon_save(void *data, obs_data_t *settings)
{
	@autoreleasepool {
		syphon_save_internal(data, settings);
	}
}

static inline void build_sprite(struct gs_vb_data *data, float fcx, float fcy,
		float start_u, float end_u, float start_v, float end_v)
{
	struct vec2 *tvarray = data->tvarray[0].array;

	vec3_set(data->points+1,  fcx, 0.0f, 0.0f);
	vec3_set(data->points+2, 0.0f,  fcy, 0.0f);
	vec3_set(data->points+3,  fcx,  fcy, 0.0f);
	vec2_set(tvarray,   start_u, start_v);
	vec2_set(tvarray+1, end_u,   start_v);
	vec2_set(tvarray+2, start_u, end_v);
	vec2_set(tvarray+3, end_u,   end_v);
}

static inline void build_sprite_rect(struct gs_vb_data *data,
		float origin_x, float origin_y, float end_x, float end_y)
{
	build_sprite(data, fabs(end_x - origin_x), fabs(end_y - origin_y),
			origin_x, end_x,
			origin_y, end_y);
}

static void syphon_video_tick(void *data, float seconds)
{
	UNUSED_PARAMETER(seconds);

	syphon_t s = data;
	if (!s->tex)
		return;

	static const CGRect null_crop = { { 0.f } };
	const CGRect *crop = &null_crop;
	if (s->crop)
		crop = &s->crop_rect;

	obs_enter_graphics();
	build_sprite_rect(gs_vertexbuffer_get_data(s->vertbuffer),
			crop->origin.x,
			s->height - crop->origin.y,
			s->width  - crop->size.width,
			crop->size.height);
	obs_leave_graphics();
}

static void syphon_video_render(void *data, gs_effect_t *effect)
{
	UNUSED_PARAMETER(effect);

	syphon_t s = data;

	if (!s->tex)
		return;

	bool disable_blending = !s->allow_transparency;
	if (disable_blending) {
		gs_enable_blending(false);
		gs_enable_color(true, true, true, false);
	}

	gs_vertexbuffer_flush(s->vertbuffer);
	gs_load_vertexbuffer(s->vertbuffer);
	gs_load_indexbuffer(NULL);
	gs_load_samplerstate(s->sampler, 0);
	gs_technique_t *tech = gs_effect_get_technique(s->effect, "Draw");
	gs_effect_set_texture(gs_effect_get_param_by_name(s->effect, "image"),
			s->tex);
	gs_technique_begin(tech);
	gs_technique_begin_pass(tech, 0);

	gs_draw(GS_TRISTRIP, 0, 4);

	gs_technique_end_pass(tech);
	gs_technique_end(tech);

	if (disable_blending) {
		gs_enable_color(true, true, true, true);
		gs_enable_blending(true);
	}
}

static uint32_t syphon_get_width(void *data)
{
	syphon_t s = (syphon_t)data;
	if (!s->crop)
		return s->width;
	int32_t width = s->width
		- s->crop_rect.origin.x
		- s->crop_rect.size.width;
	return MAX(0, width);
}

static uint32_t syphon_get_height(void *data)
{
	syphon_t s = (syphon_t)data;
	if (!s->crop)
		return s->height;
	int32_t height = s->height
		- s->crop_rect.origin.y
		- s->crop_rect.size.height;
	return MAX(0, height);
}

static inline void inject_app(syphon_t s, NSRunningApplication *app)
{
	SBApplication *sbapp = nil;
	if (app.processIdentifier != -1)
		sbapp = [SBApplication
			applicationWithProcessIdentifier:app.processIdentifier];
	else if (app.bundleIdentifier)
		sbapp = [SBApplication
			applicationWithBundleIdentifier:app.bundleIdentifier];

	if (!sbapp)
		return LOG(LOG_ERROR, "Could not inject %s",
				app.localizedName.UTF8String);

	sbapp.timeout = 10*60;
	sbapp.sendMode = kAEWaitReply;
	[sbapp sendEvent:'ascr' id:'gdut' parameters:0];
	sbapp.sendMode = kAENoReply;
	[sbapp sendEvent:'SASI' id:'injc' parameters:0];

	LOG(LOG_INFO, "Injected '%s' (%d, '%s')",
			app.localizedName.UTF8String,
			app.processIdentifier, app.bundleIdentifier.UTF8String);
}

static inline void find_and_inject_target(syphon_t s, NSArray *arr)
{
	for (NSRunningApplication *app in arr) {
		if (describes_app(s->inject_info, app))
			inject_app(s, app);
	}
}

static inline bool inject_info_equal(obs_data_t *prev, obs_data_t *new)
{
	if (![get_string(prev, "name")
			isEqual:get_string(new, "name")])
		return false;

	if (![get_string(prev, "bundle")
			isEqual:get_string(new, "bundle")])
		return false;

	if (![get_string(prev, "executable")
			isEqual:get_string(new, "executable")])
		return false;

	if (![get_string(prev, "pid")
			isEqual:get_string(new, "pid")])
		return false;

	return true;
}

static inline void update_inject(syphon_t s, obs_data_t *settings)
{
	bool try_injecting     = s->inject_active;
	s->inject_active       = obs_data_get_bool(settings, "inject");
	const char *inject_str = obs_data_get_string(settings, "application");

	try_injecting = !try_injecting && s->inject_active;

	obs_data_t *prev = s->inject_info;
	s->inject_info = obs_data_create_from_json(inject_str);
	if (!try_injecting)
		try_injecting = s->inject_active &&
			!inject_info_equal(prev, s->inject_info);
	obs_data_release(prev);

	if (!try_injecting)
		return;

	NSWorkspace *ws = [NSWorkspace sharedWorkspace];
	find_and_inject_target(s, ws.runningApplications);
}

static inline bool update_syphon(syphon_t s, obs_data_t *settings)
{
	NSArray *arr = [[SyphonServerDirectory sharedDirectory] servers];

	if (!load_syphon_settings(s, settings))
		return false;

	NSDictionary *dict = find_by_uuid(arr, s->uuid);
	if (dict) {
		NSString *app  = dict[SyphonServerDescriptionAppNameKey];
		NSString *name = dict[SyphonServerDescriptionNameKey];
		obs_data_set_string(settings, "app_name", app.UTF8String);
		obs_data_set_string(settings, "name",     name.UTF8String);
		load_syphon_settings(s, settings);

	} else if (!dict && !s->uuid.length) {
		obs_data_set_string(settings, "app_name", "");
		obs_data_set_string(settings, "name",     "");
		load_syphon_settings(s, settings);
	}

	return true;
}

static void syphon_update_internal(syphon_t s, obs_data_t *settings)
{
	s->allow_transparency = obs_data_get_bool(settings,
			"allow_transparency");

	load_crop(s, settings);
	update_inject(s, settings);
	if (update_syphon(s, settings))
		create_client(s);
}

static void syphon_update(void *data, obs_data_t *settings)
{
	@autoreleasepool {
		syphon_update_internal(data, settings);
	}
}

struct obs_source_info syphon_info = {
	.id             = "syphon-input",
	.type           = OBS_SOURCE_TYPE_INPUT,
	.output_flags   = OBS_SOURCE_VIDEO | OBS_SOURCE_CUSTOM_DRAW,
	.get_name       = syphon_get_name,
	.create         = syphon_create,
	.destroy        = syphon_destroy,
	.video_render   = syphon_video_render,
	.video_tick     = syphon_video_tick,
	.get_properties = syphon_properties,
	.get_width      = syphon_get_width,
	.get_height     = syphon_get_height,
	.update         = syphon_update,
	.save           = syphon_save,
};