/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
/*
 *  Copyright (C) 2004-2022  Ruby-GNOME Project Team
 *  Copyright (C) 2002,2003  Masahiro Sakai
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library 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
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 *  MA  02110-1301  USA
 */

/* This is for suppressing warnings for GValueArray.
 * We support GValueArray because GStreamer still uses it. */
#define GLIB_VERSION_MIN_REQUIRED GLIB_VERSION_2_30

#include "rbgprivate.h"

#define DEF_NUMERIC_PSPEC_METHODS_FUNC(pspec_type, typename, from_ruby, to_ruby, pspec_cast) \
static VALUE                                                            \
typename##_initialize(VALUE self, VALUE name, VALUE nick, VALUE blurb,  \
                      VALUE minimum, VALUE maximum, VALUE default_value, \
                      VALUE flags)                                      \
{                                                                       \
    GParamSpec* pspec;                                                  \
    pspec = g_param_spec_##typename(StringValuePtr(name),               \
                                    StringValuePtr(nick),               \
                                    StringValuePtr(blurb),              \
                                    from_ruby(minimum),                 \
                                    from_ruby(maximum),                 \
                                    from_ruby(default_value),           \
                                    NUM2UINT(flags));                   \
    rbgobj_param_spec_initialize(self, pspec);                          \
    return Qnil;                                                        \
}                                                                       \
                                                                        \
static VALUE                                                            \
typename##_minimum(VALUE self)                                          \
{                                                                       \
    return to_ruby(pspec_cast(RVAL2GOBJ(self))->minimum);               \
}                                                                       \
                                                                        \
static VALUE                                                            \
typename##_maximum(VALUE self)                                          \
{                                                                       \
    return to_ruby(pspec_cast(RVAL2GOBJ(self))->maximum);               \
}                                                                       \
                                                                        \
static VALUE                                                            \
typename##_range(VALUE self)                                            \
{                                                                       \
    pspec_type* pspec = pspec_cast(RVAL2GOBJ(self));                    \
    return rb_range_new(pspec->minimum, pspec->maximum, 0);             \
}

DEF_NUMERIC_PSPEC_METHODS_FUNC(GParamSpecChar, char, NUM2INT, INT2FIX, G_PARAM_SPEC_CHAR)
DEF_NUMERIC_PSPEC_METHODS_FUNC(GParamSpecUChar, uchar, NUM2UINT, INT2FIX, G_PARAM_SPEC_UCHAR)
DEF_NUMERIC_PSPEC_METHODS_FUNC(GParamSpecInt, int, NUM2INT, INT2NUM, G_PARAM_SPEC_INT)
DEF_NUMERIC_PSPEC_METHODS_FUNC(GParamSpecUInt, uint, NUM2UINT, UINT2NUM, G_PARAM_SPEC_UINT)
DEF_NUMERIC_PSPEC_METHODS_FUNC(GParamSpecLong, long, NUM2LONG, INT2NUM, G_PARAM_SPEC_LONG)
DEF_NUMERIC_PSPEC_METHODS_FUNC(GParamSpecULong, ulong, NUM2ULONG, UINT2NUM, G_PARAM_SPEC_ULONG)
DEF_NUMERIC_PSPEC_METHODS_FUNC(GParamSpecInt64, int64, rbglib_num_to_int64, rbglib_int64_to_num, G_PARAM_SPEC_INT64)
DEF_NUMERIC_PSPEC_METHODS_FUNC(GParamSpecUInt64, uint64, rbglib_num_to_uint64, rbglib_uint64_to_num, G_PARAM_SPEC_UINT64)
DEF_NUMERIC_PSPEC_METHODS_FUNC(GParamSpecFloat, float, NUM2DBL, rb_float_new, G_PARAM_SPEC_FLOAT)
DEF_NUMERIC_PSPEC_METHODS_FUNC(GParamSpecDouble, double, NUM2DBL, rb_float_new, G_PARAM_SPEC_DOUBLE)

static VALUE
float_epsilon(VALUE self)
{
    return rb_float_new(G_PARAM_SPEC_FLOAT(RVAL2GOBJ(self))->epsilon);
}

static VALUE
double_epsilon(VALUE self)
{
    return rb_float_new(G_PARAM_SPEC_DOUBLE(RVAL2GOBJ(self))->epsilon);
}


static VALUE
boolean_initialize(VALUE self, VALUE name, VALUE nick, VALUE blurb,
                   VALUE default_value, VALUE flags)
{
    GParamSpec* pspec;
    pspec = g_param_spec_boolean(StringValuePtr(name),
                                 StringValuePtr(nick),
                                 StringValuePtr(blurb),
                                 RVAL2CBOOL(default_value),
                                 NUM2UINT(flags));
    rbgobj_param_spec_initialize(self, pspec);
    return Qnil;
}

static VALUE
unichar_initialize(VALUE self, VALUE name, VALUE nick, VALUE blurb,
                   VALUE default_value, VALUE flags)
{
    GParamSpec* pspec;
    pspec = g_param_spec_unichar(StringValuePtr(name),
                                 StringValuePtr(nick),
                                 StringValuePtr(blurb),
                                 NUM2UINT(default_value),
                                 NUM2UINT(flags));
    rbgobj_param_spec_initialize(self, pspec);
    return Qnil;
}

static VALUE
enum_initialize(VALUE self, VALUE name, VALUE nick, VALUE blurb,
                VALUE enum_type, VALUE default_value, VALUE flags)
{
    GParamSpec* pspec;
    GType gtype = rbgobj_gtype_from_ruby(enum_type);

    pspec = g_param_spec_enum(StringValuePtr(name),
                              StringValuePtr(nick),
                              StringValuePtr(blurb),
                              gtype,
                              RVAL2GENUM(default_value, gtype),
                              NUM2UINT(flags));
    rbgobj_param_spec_initialize(self, pspec);
    return Qnil;
}

static VALUE
flags_initialize(VALUE self, VALUE name, VALUE nick, VALUE blurb,
                 VALUE flags_type, VALUE default_value, VALUE flags)
{
    GParamSpec* pspec;
    GType gtype = rbgobj_gtype_from_ruby(flags_type);

    pspec = g_param_spec_flags(StringValuePtr(name),
                              StringValuePtr(nick),
                              StringValuePtr(blurb),
                              gtype,
                              RVAL2GFLAGS(default_value, gtype),
                              NUM2UINT(flags));
    rbgobj_param_spec_initialize(self, pspec);
    return Qnil;
}

static VALUE
string_initialize(VALUE self, VALUE name, VALUE nick, VALUE blurb,
                  VALUE default_value, VALUE flags)
{
    GParamSpec* pspec;
    pspec = g_param_spec_string(StringValuePtr(name),
                                StringValuePtr(nick),
                                StringValuePtr(blurb),
                                NIL_P(default_value) ? NULL : StringValuePtr(default_value),
                                NUM2UINT(flags));
    rbgobj_param_spec_initialize(self, pspec);
    return Qnil;
}

static VALUE
param_initialize(VALUE self, VALUE name, VALUE nick, VALUE blurb,
                 VALUE param_type, VALUE flags)
{
    GParamSpec* pspec;
    pspec = g_param_spec_param(StringValuePtr(name),
                               StringValuePtr(nick),
                               StringValuePtr(blurb),
                               rbgobj_gtype_from_ruby(param_type),
                               NUM2UINT(flags));
    rbgobj_param_spec_initialize(self, pspec);
    return Qnil;
}

static VALUE
boxed_initialize(VALUE self, VALUE name, VALUE nick, VALUE blurb,
                 VALUE boxed_type, VALUE flags)
{
    GParamSpec* pspec;
    pspec = g_param_spec_boxed(StringValuePtr(name),
                               StringValuePtr(nick),
                               StringValuePtr(blurb),
                               rbgobj_gtype_from_ruby(boxed_type),
                               NUM2UINT(flags));
    rbgobj_param_spec_initialize(self, pspec);
    return Qnil;
}

static VALUE
pointer_initialize(VALUE self, VALUE name, VALUE nick, VALUE blurb, VALUE flags)
{
    GParamSpec* pspec;
    pspec = g_param_spec_pointer(StringValuePtr(name),
                                 StringValuePtr(nick),
                                 StringValuePtr(blurb),
                                 NUM2UINT(flags));
    rbgobj_param_spec_initialize(self, pspec);
    return Qnil;
}

static VALUE
value_array_initialize(VALUE self, VALUE name, VALUE nick, VALUE blurb,
                       VALUE element_spec, VALUE flags)
{
    GParamSpec *pspec;
    pspec = g_param_spec_value_array(StringValuePtr(name),
                                     StringValuePtr(nick),
                                     StringValuePtr(blurb),
                                     RVAL2GOBJ(element_spec),
                                     NUM2UINT(flags));
    rbgobj_param_spec_initialize(self, pspec);
    return Qnil;
}

static VALUE
object_initialize(VALUE self, VALUE name, VALUE nick, VALUE blurb,
                  VALUE object_type, VALUE flags)
{
    GParamSpec* pspec;
    pspec = g_param_spec_object(StringValuePtr(name),
                                StringValuePtr(nick),
                                StringValuePtr(blurb),
                                rbgobj_gtype_from_ruby(object_type),
                                NUM2UINT(flags));
    rbgobj_param_spec_initialize(self, pspec);
    return Qnil;
}

void
Init_gobject_gparamspecs(void)
{
    VALUE cParamSpec = GTYPE2CLASS(G_TYPE_PARAM);
    VALUE c;

#define DEF_NUMERIC_PSPEC_METHODS(c, typename) \
  G_STMT_START {\
    rbg_define_method(c, "initialize", typename##_initialize, 7); \
    rbg_define_method(c, "minimum", typename##_minimum, 0); \
    rbg_define_method(c, "maximum", typename##_maximum, 0); \
    rbg_define_method(c, "range", typename##_range, 0); \
  } G_STMT_END

#if 0
    rbg_define_method(c, "default_value", typename##_default_value, 0); \
    rb_define_alias(c, "default", "default_value"); \

#endif

    c = G_DEF_CLASS(G_TYPE_PARAM_CHAR, "Char", cParamSpec);
    DEF_NUMERIC_PSPEC_METHODS(c, char);

    c = G_DEF_CLASS(G_TYPE_PARAM_UCHAR, "UChar", cParamSpec);
    DEF_NUMERIC_PSPEC_METHODS(c, uchar);

    c = G_DEF_CLASS(G_TYPE_PARAM_INT, "Int", cParamSpec);
    DEF_NUMERIC_PSPEC_METHODS(c, int);

    c = G_DEF_CLASS(G_TYPE_PARAM_UINT, "UInt", cParamSpec);
    DEF_NUMERIC_PSPEC_METHODS(c, uint);

    c = G_DEF_CLASS(G_TYPE_PARAM_LONG, "Long", cParamSpec);
    DEF_NUMERIC_PSPEC_METHODS(c, long);

    c = G_DEF_CLASS(G_TYPE_PARAM_ULONG, "ULong", cParamSpec);
    DEF_NUMERIC_PSPEC_METHODS(c, ulong);

    c = G_DEF_CLASS(G_TYPE_PARAM_INT64, "Int64", cParamSpec);
    DEF_NUMERIC_PSPEC_METHODS(c, int64);

    c = G_DEF_CLASS(G_TYPE_PARAM_UINT64, "UInt64", cParamSpec);
    DEF_NUMERIC_PSPEC_METHODS(c, uint64);

    c = G_DEF_CLASS(G_TYPE_PARAM_FLOAT, "Float", cParamSpec);
    DEF_NUMERIC_PSPEC_METHODS(c, float);
    rbg_define_method(c, "epsilon", float_epsilon, 0);

    c = G_DEF_CLASS(G_TYPE_PARAM_DOUBLE, "Double", cParamSpec);
    DEF_NUMERIC_PSPEC_METHODS(c, double);
    rbg_define_method(c, "epsilon", double_epsilon, 0);

    c = G_DEF_CLASS(G_TYPE_PARAM_BOOLEAN, "Boolean", cParamSpec);
    rbg_define_method(c, "initialize", boolean_initialize, 5);

    c = G_DEF_CLASS(G_TYPE_PARAM_UNICHAR, "UniChar", cParamSpec);
    rbg_define_method(c, "initialize", unichar_initialize, 5);

    c = G_DEF_CLASS(G_TYPE_PARAM_ENUM, "Enum", cParamSpec);
    rbg_define_method(c, "initialize", enum_initialize, 6);

    c = G_DEF_CLASS(G_TYPE_PARAM_FLAGS, "Flags", cParamSpec);
    rbg_define_method(c, "initialize", flags_initialize, 6);

    c = G_DEF_CLASS(G_TYPE_PARAM_STRING, "String", cParamSpec);
    rbg_define_method(c, "initialize", string_initialize, 5);

    c = G_DEF_CLASS(G_TYPE_PARAM_PARAM, "Param", cParamSpec);
    rbg_define_method(c, "initialize", param_initialize, 5);

    c = G_DEF_CLASS(G_TYPE_PARAM_BOXED, "Boxed", cParamSpec);
    rbg_define_method(c, "initialize", boxed_initialize, 5);

    c = G_DEF_CLASS(G_TYPE_PARAM_POINTER, "Pointer", cParamSpec);
    rbg_define_method(c, "initialize", pointer_initialize, 4);

    c = G_DEF_CLASS(G_TYPE_PARAM_VALUE_ARRAY, "ValueArray", cParamSpec);
    rbg_define_method(c, "initialize", value_array_initialize, 5);

    c = G_DEF_CLASS(G_TYPE_PARAM_OBJECT, "Object", cParamSpec);
    rbg_define_method(c, "initialize", object_initialize, 5);
}
