///|
/// GLib Variant — immutable, ref-counted typed value container.
/// Used by GSettings, D-Bus, GAction, and other GLib APIs.
/// Automatically unreffed when garbage collected.

///|
pub type Variant

///|
pub(open) trait IVariant {
  fn as_variant(Self) -> Variant
}

///|
pub impl IVariant for Variant with fn as_variant(self) {
  self
}

// =============================================================================
// FFI Declarations
// =============================================================================

///|
extern "c" fn moonbit_glib_variant_new_bool(value : Bool) -> Variant = "moonbit_glib_variant_new_bool"

///|
extern "c" fn moonbit_glib_variant_new_int32(value : Int) -> Variant = "moonbit_glib_variant_new_int32"

///|
extern "c" fn moonbit_glib_variant_new_uint32(value : UInt) -> Variant = "moonbit_glib_variant_new_uint32"

///|
extern "c" fn moonbit_glib_variant_new_int64(value : Int64) -> Variant = "moonbit_glib_variant_new_int64"

///|
extern "c" fn moonbit_glib_variant_new_uint64(value : UInt64) -> Variant = "moonbit_glib_variant_new_uint64"

///|
extern "c" fn moonbit_glib_variant_new_double(value : Double) -> Variant = "moonbit_glib_variant_new_double"

///|
#borrow(value)
extern "c" fn moonbit_glib_variant_new_string(value : Bytes) -> Variant = "moonbit_glib_variant_new_string"

///|
#borrow(variant)
extern "c" fn moonbit_glib_variant_get_bool(variant : Variant) -> Bool = "moonbit_glib_variant_get_bool"

///|
#borrow(variant)
extern "c" fn moonbit_glib_variant_get_int32(variant : Variant) -> Int = "moonbit_glib_variant_get_int32"

///|
#borrow(variant)
extern "c" fn moonbit_glib_variant_get_uint32(variant : Variant) -> UInt = "moonbit_glib_variant_get_uint32"

///|
#borrow(variant)
extern "c" fn moonbit_glib_variant_get_int64(variant : Variant) -> Int64 = "moonbit_glib_variant_get_int64"

///|
#borrow(variant)
extern "c" fn moonbit_glib_variant_get_uint64(variant : Variant) -> UInt64 = "moonbit_glib_variant_get_uint64"

///|
#borrow(variant)
extern "c" fn moonbit_glib_variant_get_double(variant : Variant) -> Double = "moonbit_glib_variant_get_double"

///|
#borrow(variant)
extern "c" fn moonbit_glib_variant_get_string(variant : Variant) -> Bytes = "moonbit_glib_variant_get_string"

///|
#borrow(variant)
extern "c" fn moonbit_glib_variant_get_type_string(variant : Variant) -> Bytes = "moonbit_glib_variant_get_type_string"

///|
#borrow(variant, type_string)
extern "c" fn moonbit_glib_variant_is_of_type(
  variant : Variant,
  type_string : Bytes,
) -> Bool = "moonbit_glib_variant_is_of_type"

// =============================================================================
// Public Methods
// =============================================================================

///|
/// Create a Variant holding a boolean value.
///
/// ```mbt check
/// test {
///   let v = @glib.Variant::from_bool(true)
///   @debug.assert_eq(v.type_string(), "b")
///   @debug.assert_eq(v.as_bool(), Some(true))
/// }
/// ```
pub fn Variant::from_bool(value : Bool) -> Variant {
  moonbit_glib_variant_new_bool(value)
}

///|
/// Create a Variant holding a 32-bit signed integer.
///
/// ```mbt check
/// test {
///   let v = @glib.Variant::from_int32(42)
///   @debug.assert_eq(v.type_string(), "i")
///   @debug.assert_eq(v.as_int32(), Some(42))
/// }
/// ```
pub fn Variant::from_int32(value : Int) -> Variant {
  moonbit_glib_variant_new_int32(value)
}

///|
/// Create a Variant holding a 32-bit unsigned integer.
pub fn Variant::from_uint32(value : UInt) -> Variant {
  moonbit_glib_variant_new_uint32(value)
}

///|
/// Create a Variant holding a 64-bit signed integer.
pub fn Variant::from_int64(value : Int64) -> Variant {
  moonbit_glib_variant_new_int64(value)
}

///|
/// Create a Variant holding a 64-bit unsigned integer.
pub fn Variant::from_uint64(value : UInt64) -> Variant {
  moonbit_glib_variant_new_uint64(value)
}

///|
/// Create a Variant holding a double-precision float.
pub fn Variant::from_double(value : Double) -> Variant {
  moonbit_glib_variant_new_double(value)
}

///|
/// Create a Variant holding a string.
///
/// ```mbt check
/// test {
///   let v = @glib.Variant::from_string("hello")
///   @debug.assert_eq(v.type_string(), "s")
///   @debug.assert_eq(v.as_string(), Some("hello"))
/// }
/// ```
pub fn Variant::from_string(value : String) -> Variant {
  moonbit_glib_variant_new_string(@encoding/utf8.encode(value))
}

///|
/// Get the boolean value, or None if the variant is not of type "b".
pub fn Variant::as_bool(self : Variant) -> Bool? {
  if moonbit_glib_variant_is_of_type(self, b"b") {
    Some(moonbit_glib_variant_get_bool(self))
  } else {
    None
  }
}

///|
/// Get the 32-bit signed integer value, or None if not of type "i".
pub fn Variant::as_int32(self : Variant) -> Int? {
  if moonbit_glib_variant_is_of_type(self, b"i") {
    Some(moonbit_glib_variant_get_int32(self))
  } else {
    None
  }
}

///|
/// Get the 32-bit unsigned integer value, or None if not of type "u".
pub fn Variant::as_uint32(self : Variant) -> UInt? {
  if moonbit_glib_variant_is_of_type(self, b"u") {
    Some(moonbit_glib_variant_get_uint32(self))
  } else {
    None
  }
}

///|
/// Get the 64-bit signed integer value, or None if not of type "x".
pub fn Variant::as_int64(self : Variant) -> Int64? {
  if moonbit_glib_variant_is_of_type(self, b"x") {
    Some(moonbit_glib_variant_get_int64(self))
  } else {
    None
  }
}

///|
/// Get the 64-bit unsigned integer value, or None if not of type "t".
pub fn Variant::as_uint64(self : Variant) -> UInt64? {
  if moonbit_glib_variant_is_of_type(self, b"t") {
    Some(moonbit_glib_variant_get_uint64(self))
  } else {
    None
  }
}

///|
/// Get the double value, or None if not of type "d".
pub fn Variant::as_double(self : Variant) -> Double? {
  if moonbit_glib_variant_is_of_type(self, b"d") {
    Some(moonbit_glib_variant_get_double(self))
  } else {
    None
  }
}

///|
/// Get the string value, or None if not of type "s".
pub fn Variant::as_string(self : Variant) -> String? {
  if moonbit_glib_variant_is_of_type(self, b"s") {
    Some(@encoding/utf8.decode_lossy(moonbit_glib_variant_get_string(self)))
  } else {
    None
  }
}

///|
/// Get the Variant type string (e.g. "s", "i", "b", "(si)").
pub fn Variant::type_string(self : Variant) -> String {
  @encoding/utf8.decode_lossy(moonbit_glib_variant_get_type_string(self))
}

///|
/// Check if this variant is of the given type.
pub fn Variant::is_of_type(self : Variant, type_string : String) -> Bool {
  moonbit_glib_variant_is_of_type(self, @encoding/utf8.encode(type_string))
}