// Take a look at the license at the top of the repository in the LICENSE file.

use crate::{prelude::*, CssParserWarning, Ordering};
use glib::{error::ErrorDomain, translate::*, Quark};
use std::cmp;

impl From<cmp::Ordering> for Ordering {
    #[inline]
    fn from(o: cmp::Ordering) -> Self {
        skip_assert_initialized!();
        match o {
            cmp::Ordering::Equal => Self::Equal,
            cmp::Ordering::Greater => Self::Larger,
            cmp::Ordering::Less => Self::Smaller,
        }
    }
}

impl From<Ordering> for cmp::Ordering {
    #[inline]
    fn from(o: Ordering) -> Self {
        skip_assert_initialized!();
        match o {
            Ordering::Equal => Self::Equal,
            Ordering::Larger => Self::Greater,
            Ordering::Smaller => Self::Less,
            Ordering::__Unknown(_) => unreachable!(),
        }
    }
}

impl ErrorDomain for CssParserWarning {
    #[inline]
    fn domain() -> Quark {
        skip_assert_initialized!();
        unsafe { from_glib(ffi::gtk_css_parser_warning_quark()) }
    }

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match code {
            ffi::GTK_CSS_PARSER_WARNING_DEPRECATED => Some(Self::Deprecated),
            ffi::GTK_CSS_PARSER_WARNING_SYNTAX => Some(Self::Syntax),
            ffi::GTK_CSS_PARSER_WARNING_UNIMPLEMENTED => Some(Self::Unimplemented),
            value => Some(Self::__Unknown(value)),
        }
    }
}

/// Controls how a widget deals with extra space in a single dimension.
///
/// Alignment only matters if the widget receives a “too large” allocation,
/// for example if you packed the widget with the [`hexpand`][struct@crate::Widget#hexpand]
/// property inside a [`Box`][crate::Box], then the widget might get extra space.
/// If you have for example a 16x16 icon inside a 32x32 space, the icon
/// could be scaled and stretched, it could be centered, or it could be
/// positioned to one side of the space.
///
/// Note that in horizontal context `GTK_ALIGN_START` and `GTK_ALIGN_END`
/// are interpreted relative to text direction.
///
/// Baseline support is optional for containers and widgets, and is only available
/// for vertical alignment. `GTK_ALIGN_BASELINE_CENTER and `GTK_ALIGN_BASELINE_FILL`
/// are treated similar to `GTK_ALIGN_CENTER` and `GTK_ALIGN_FILL`, except that it
/// positions the widget to line up the baselines, where that is supported.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkAlign")]
pub enum Align {
    /// stretch to fill all space if possible, center if
    ///   no meaningful way to stretch
    #[doc(alias = "GTK_ALIGN_FILL")]
    Fill,
    /// snap to left or top side, leaving space on right or bottom
    #[doc(alias = "GTK_ALIGN_START")]
    Start,
    /// snap to right or bottom side, leaving space on left or top
    #[doc(alias = "GTK_ALIGN_END")]
    End,
    /// center natural width of widget inside the allocation
    #[doc(alias = "GTK_ALIGN_CENTER")]
    Center,
    /// align the widget according to the baseline.
    ///   See [`Widget`][crate::Widget]. Deprecated: 4.12: Use `GTK_ALIGN_BASELINE_FILL` instead
    #[doc(alias = "GTK_ALIGN_BASELINE")]
    Baseline,
    /// a different name for `GTK_ALIGN_BASELINE`. Since 4.12
    #[cfg(feature = "v4_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
    #[doc(alias = "GTK_ALIGN_BASELINE_FILL")]
    BaselineFill,
    /// stretch to fill all space, but align the baseline. Since 4.12
    #[cfg(feature = "v4_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
    #[doc(alias = "GTK_ALIGN_BASELINE_CENTER")]
    BaselineCenter,
    #[doc(hidden)]
    __Unknown(i32),
}

impl std::fmt::Display for Align {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(
            f,
            "Align::{}",
            match *self {
                Self::Fill => "Fill",
                Self::Start => "Start",
                Self::End => "End",
                Self::Center => "Center",
                Self::Baseline => "Baseline",
                #[cfg(feature = "v4_12")]
                Self::BaselineFill => "BaselineFill",
                #[cfg(feature = "v4_12")]
                Self::BaselineCenter => "BaselineCenter",
                _ => "Unknown",
            }
        )
    }
}

#[doc(hidden)]
impl IntoGlib for Align {
    type GlibType = ffi::GtkAlign;

    #[inline]
    fn into_glib(self) -> ffi::GtkAlign {
        match self {
            Self::Fill => ffi::GTK_ALIGN_FILL,
            Self::Start => ffi::GTK_ALIGN_START,
            Self::End => ffi::GTK_ALIGN_END,
            Self::Center => ffi::GTK_ALIGN_CENTER,
            #[cfg(not(feature = "v4_12"))]
            Self::Baseline => ffi::GTK_ALIGN_BASELINE,
            #[cfg(feature = "v4_12")]
            Self::BaselineFill | Self::Baseline => ffi::GTK_ALIGN_BASELINE_FILL,
            #[cfg(feature = "v4_12")]
            Self::BaselineCenter => ffi::GTK_ALIGN_BASELINE_CENTER,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkAlign> for Align {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkAlign) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_ALIGN_FILL => Self::Fill,
            ffi::GTK_ALIGN_START => Self::Start,
            ffi::GTK_ALIGN_END => Self::End,
            ffi::GTK_ALIGN_CENTER => Self::Center,
            #[cfg(not(feature = "v4_12"))]
            ffi::GTK_ALIGN_BASELINE => Self::Baseline,
            #[cfg(feature = "v4_12")]
            ffi::GTK_ALIGN_BASELINE_FILL => Self::BaselineFill,
            #[cfg(feature = "v4_12")]
            ffi::GTK_ALIGN_BASELINE_CENTER => Self::BaselineCenter,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for Align {
    #[inline]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_align_get_type()) }
    }
}

impl glib::HasParamSpec for Align {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        |name, default_value| Self::ParamSpec::builder_with_default(name, default_value)
    }
}

impl glib::value::ValueType for Align {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for Align {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
    }
}

impl glib::value::ToValue for Align {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<Align> for glib::Value {
    #[inline]
    fn from(v: Align) -> Self {
        skip_assert_initialized!();
        glib::value::ToValue::to_value(&v)
    }
}