/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */

/*

 * soup-proxy-resolver-wrapper.c: SoupProxyURIResolver -> GProxyResolver wrapper

 *

 * Copyright 2013 Red Hat, Inc.

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include "soup-proxy-resolver-wrapper.h"

#include "soup.h"

static void soup_proxy_resolver_wrapper_interface_init (GProxyResolverInterface *proxy_resolver_interface);

G_DEFINE_TYPE_WITH_CODE (SoupProxyResolverWrapper, soup_proxy_resolver_wrapper, G_TYPE_OBJECT,

			 G_IMPLEMENT_INTERFACE (G_TYPE_PROXY_RESOLVER, soup_proxy_resolver_wrapper_interface_init);

			 )

static void

soup_proxy_resolver_wrapper_init (SoupProxyResolverWrapper *resolver_wrapper)

{

}

static void

soup_proxy_resolver_wrapper_finalize (GObject *object)

{

	SoupProxyResolverWrapper *wrapper =

		SOUP_PROXY_RESOLVER_WRAPPER (object);

	g_clear_object (&wrapper->soup_resolver);

	G_OBJECT_CLASS (soup_proxy_resolver_wrapper_parent_class)->finalize (object);

}

static char **

convert_response (SoupURI *source_uri, guint status,

		  SoupURI *proxy_uri, GError **error)

{

	char **proxies = NULL;

	if (status == SOUP_STATUS_CANT_RESOLVE_PROXY) {

		g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_NOT_FOUND,

			     "%s (%s)", soup_status_get_phrase (status),

			     source_uri->host);

	} else if (status == SOUP_STATUS_CANT_CONNECT_PROXY) {

		g_set_error (error, G_IO_ERROR, G_IO_ERROR_CONNECTION_REFUSED,

			     "%s (%s)", soup_status_get_phrase (status),

			     source_uri->host);

	} else {

		g_return_val_if_fail (status == SOUP_STATUS_OK, NULL);

		proxies = g_new (char *, 2);

		proxies[0] = soup_uri_to_string (proxy_uri, FALSE);

		proxies[1] = NULL;

		soup_uri_free (proxy_uri);

	}

	return proxies;

}

static void

wrapper_lookup_async_complete (SoupProxyURIResolver *resolver,

			       guint status, SoupURI *proxy_uri,

			       gpointer user_data)

{

	GTask *task = user_data;

	SoupURI *source_uri = g_task_get_task_data (task);

	char **proxies;

	GError *error = NULL;

	proxies = convert_response (source_uri, status, proxy_uri, &error);

	if (error)

		g_task_return_error (task, error);

	else

		g_task_return_pointer (task, proxies, (GDestroyNotify) g_strfreev);

	g_object_unref (task);

}

static void

soup_proxy_resolver_wrapper_lookup_async (GProxyResolver       *resolver,

					  const gchar          *uri,

					  GCancellable         *cancellable,

					  GAsyncReadyCallback   callback,

					  gpointer              user_data)

{

	SoupProxyResolverWrapper *wrapper =

		SOUP_PROXY_RESOLVER_WRAPPER (resolver);

	GTask *task;

	SoupURI *source_uri;

	task = g_task_new (resolver, cancellable, callback, user_data);

	source_uri = soup_uri_new (uri);

	g_task_set_task_data (task, source_uri, (GDestroyNotify) soup_uri_free);

	G_GNUC_BEGIN_IGNORE_DEPRECATIONS;

	soup_proxy_uri_resolver_get_proxy_uri_async (wrapper->soup_resolver,

						     source_uri,

						     g_main_context_get_thread_default (),

						     cancellable,

						     wrapper_lookup_async_complete,

						     task);

	G_GNUC_END_IGNORE_DEPRECATIONS;

}

static char **

soup_proxy_resolver_wrapper_lookup_finish (GProxyResolver       *resolver,

					   GAsyncResult         *result,

					   GError              **error)

{

	return g_task_propagate_pointer (G_TASK (result), error);

}

static gchar **

soup_proxy_resolver_wrapper_lookup (GProxyResolver  *resolver,

				    const gchar     *uri,

				    GCancellable    *cancellable,

				    GError         **error)

{

	SoupProxyResolverWrapper *wrapper =

		SOUP_PROXY_RESOLVER_WRAPPER (resolver);

	SoupURI *source_uri, *proxy_uri;

	guint status;

	gchar **proxies;

	source_uri = soup_uri_new (uri);

	G_GNUC_BEGIN_IGNORE_DEPRECATIONS;

	status = soup_proxy_uri_resolver_get_proxy_uri_sync (wrapper->soup_resolver,

							     source_uri,

							     cancellable,

							     &proxy_uri);

	G_GNUC_END_IGNORE_DEPRECATIONS;

	proxies = convert_response (source_uri, status, proxy_uri, error);

	soup_uri_free (source_uri);

	return proxies;

}

static void

soup_proxy_resolver_wrapper_class_init (SoupProxyResolverWrapperClass *static_class)

{

	GObjectClass *object_class = G_OBJECT_CLASS (static_class);

	object_class->finalize = soup_proxy_resolver_wrapper_finalize;

}

static void

soup_proxy_resolver_wrapper_interface_init (GProxyResolverInterface *proxy_resolver_interface)

{

	proxy_resolver_interface->lookup =

		soup_proxy_resolver_wrapper_lookup;

	proxy_resolver_interface->lookup_async =

		soup_proxy_resolver_wrapper_lookup_async;

	proxy_resolver_interface->lookup_finish =

		soup_proxy_resolver_wrapper_lookup_finish;

}

GProxyResolver *

soup_proxy_resolver_wrapper_new (SoupProxyURIResolver *soup_resolver)

{

	SoupProxyResolverWrapper *wrapper;

	wrapper = g_object_new (SOUP_TYPE_PROXY_RESOLVER_WRAPPER, NULL);

	wrapper->soup_resolver = g_object_ref (soup_resolver);

	return (GProxyResolver *)wrapper;

}