#include "rblm.h"
#include "rblm-private.h"

VALUE lm_cSSL;

LmSSL *
rb_lm_ssl_from_ruby_object (VALUE obj)
{
	LmSSL *ssl;

	if (!rb_lm__is_kind_of (obj, lm_cSSL)) {
		rb_raise (rb_eTypeError, "not a LmSSL");
	}

	Data_Get_Struct (obj, LmSSL, ssl);

	return ssl;
}

void
ssl_free (LmSSL *ssl)
{
	lm_ssl_unref (ssl);
}

VALUE
rb_lm_ssl_to_ruby_object (LmSSL *ssl)
{
	if (ssl) {
		lm_ssl_ref (ssl);
		return Data_Wrap_Struct (lm_cSSL, NULL, 
					 ssl_free, ssl);
	} else {
		return Qnil;
	}
}

VALUE
ssl_allocate (VALUE klass)
{
	return Data_Wrap_Struct (klass, NULL, ssl_free, NULL);
}

static VALUE
ssl_is_supported (VALUE self)
{
	return GBOOL2RVAL (lm_ssl_is_supported ());
}

static LmSSLResponse
ssl_func_callback (LmSSL       *ssl,
		   LmSSLStatus  status,
		   gpointer     user_data)
{
	VALUE response;

	if (!user_data) {
		return LM_SSL_RESPONSE_CONTINUE;
	}

	response = rb_funcall ((VALUE)user_data, rb_intern ("call"), 1,
			       INT2FIX (status));

	return rb_lm_ssl_response_from_ruby_object (response);
}

static VALUE
ssl_initialize (int argc, VALUE *argv, VALUE self)
{
	LmSSL    *ssl;
	VALUE     fingerprint;
	VALUE     func;
	char     *fingerprint_str = NULL;
	gpointer  func_ptr = NULL;

	rb_scan_args (argc, argv, "01&", &fingerprint, &func);

	if (!NIL_P (func)) {
		func_ptr = (gpointer) func;
	}

	if (!NIL_P (fingerprint)) {
		VALUE str_val;

		if (!rb_respond_to (fingerprint, rb_intern ("to_s"))) {
			rb_raise (rb_eArgError, 
				  "fingerprint should respond to to_s");
		}

		str_val = rb_funcall (fingerprint, rb_intern ("to_s"), 0);
		fingerprint_str = StringValuePtr (str_val);
	}

	ssl = lm_ssl_new (fingerprint_str, ssl_func_callback,
			  func_ptr, NULL);

	DATA_PTR (self) = ssl;

	return self;
}

static VALUE
ssl_get_fingerprint (VALUE self)
{
	LmSSL *ssl = rb_lm_ssl_from_ruby_object (self);

	if (lm_ssl_get_fingerprint (ssl)) {
		return rb_str_new2 (lm_ssl_get_fingerprint (ssl));
	}

	return Qnil;
}

static VALUE
ssl_get_use_starttls (VALUE self)
{
	LmSSL *ssl = rb_lm_ssl_from_ruby_object (self);

	return GBOOL2RVAL (lm_ssl_get_use_starttls (ssl));
}

static VALUE
ssl_set_use_starttls (VALUE self, VALUE use)
{
	LmSSL *ssl = rb_lm_ssl_from_ruby_object (self);

	lm_ssl_use_starttls (ssl,
			     RVAL2GBOOL (use),
			     lm_ssl_get_require_starttls (ssl));

	return Qnil;
}

static VALUE
ssl_get_require_starttls (VALUE self)
{
	LmSSL *ssl = rb_lm_ssl_from_ruby_object (self);

	return GBOOL2RVAL (lm_ssl_get_require_starttls (ssl));
}

static VALUE
ssl_set_require_starttls (VALUE self, VALUE require)
{
	LmSSL *ssl = rb_lm_ssl_from_ruby_object (self);

	lm_ssl_use_starttls (ssl,
			     lm_ssl_get_use_starttls (ssl),
			     RVAL2GBOOL (require));

	return Qnil;
}

extern void
Init_lm_ssl (VALUE lm_mLM)
{
	lm_cSSL = rb_define_class_under (lm_mLM, "SSL", rb_cObject);

	rb_define_alloc_func (lm_cSSL, ssl_allocate);

	rb_define_singleton_method (lm_cSSL, "supported?", 
				    ssl_is_supported, 0);

	rb_define_method (lm_cSSL, "initialize", ssl_initialize, -1);
	rb_define_method (lm_cSSL, "fingerprint", ssl_get_fingerprint, 0);
	rb_define_method (lm_cSSL, "use_starttls", ssl_get_use_starttls, 0);
	rb_define_method (lm_cSSL, "use_starttls=", ssl_set_use_starttls, 1);
	rb_define_method (lm_cSSL, "require_starttls", ssl_get_require_starttls, 0);
	rb_define_method (lm_cSSL, "require_starttls=", ssl_set_require_starttls, 1);
}