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

use crate::Script;
use glib::translate::*;
use glib::GString;

/// The [`Language`][crate::Language] structure is used to
/// represent a language.
///
/// [`Language`][crate::Language] pointers can be efficiently
/// copied and compared with each other.
#[doc(alias = "PangoLanguage")]
pub struct Language(*mut ffi::PangoLanguage);

unsafe impl Send for Language {}
unsafe impl Sync for Language {}

#[doc(hidden)]
impl<'a> ToGlibPtr<'a, *mut ffi::PangoLanguage> for &'a Language {
    type Storage = &'a Language;

    fn to_glib_none(&self) -> Stash<'a, *mut ffi::PangoLanguage, Self> {
        Stash(self.0, *self)
    }
}

#[doc(hidden)]
impl<'a> ToGlibPtrMut<'a, *mut ffi::PangoLanguage> for Language {
    type Storage = &'a mut Self;

    #[inline]
    fn to_glib_none_mut(&'a mut self) -> StashMut<'a, *mut ffi::PangoLanguage, Self> {
        StashMut(self.0, self)
    }
}

#[doc(hidden)]
impl FromGlibPtrNone<*mut ffi::PangoLanguage> for Language {
    unsafe fn from_glib_none(ptr: *mut ffi::PangoLanguage) -> Self {
        assert!(!ptr.is_null());
        Self(ptr)
    }
}

#[doc(hidden)]
impl FromGlibPtrFull<*mut ffi::PangoLanguage> for Language {
    unsafe fn from_glib_full(ptr: *mut ffi::PangoLanguage) -> Self {
        assert!(!ptr.is_null());
        Self(ptr)
    }
}

#[doc(hidden)]
impl FromGlibPtrNone<*const ffi::PangoLanguage> for Language {
    unsafe fn from_glib_none(ptr: *const ffi::PangoLanguage) -> Self {
        assert!(!ptr.is_null());
        Self(ptr as *mut _)
    }
}

#[doc(hidden)]
impl FromGlibPtrFull<*const ffi::PangoLanguage> for Language {
    unsafe fn from_glib_full(ptr: *const ffi::PangoLanguage) -> Self {
        assert!(!ptr.is_null());
        Self(ptr as *mut _)
    }
}

impl Default for Language {
    #[doc(alias = "pango_language_get_default")]
    fn default() -> Self {
        unsafe { from_glib_full(ffi::pango_language_get_default()) }
    }
}

impl Language {
    /// Convert a language tag to a [`Language`][crate::Language].
    ///
    /// The language tag must be in a RFC-3066 format. [`Language`][crate::Language] pointers
    /// can be efficiently copied (copy the pointer) and compared with other
    /// language tags (compare the pointer.)
    ///
    /// This function first canonicalizes the string by converting it to
    /// lowercase, mapping '_' to '-', and stripping all characters other
    /// than letters and '-'.
    ///
    /// Use [`default()`][Self::default()] if you want to get the
    /// [`Language`][crate::Language] for the current locale of the process.
    /// ## `language`
    /// a string representing a language tag
    ///
    /// # Returns
    ///
    /// a [`Language`][crate::Language]
    #[doc(alias = "pango_language_from_string")]
    pub fn from_string(language: &str) -> Self {
        unsafe { from_glib_full(ffi::pango_language_from_string(language.to_glib_none().0)) }
    }

    #[doc(alias = "pango_language_to_string")]
    pub fn to_string(&self) -> GString {
        unsafe { from_glib_none(ffi::pango_language_to_string(self.to_glib_none().0)) }
    }

    /// Checks if a language tag matches one of the elements in a list of
    /// language ranges.
    ///
    /// A language tag is considered to match a range in the list if the
    /// range is '*', the range is exactly the tag, or the range is a prefix
    /// of the tag, and the character after it in the tag is '-'.
    /// ## `range_list`
    /// a list of language ranges, separated by ';', ':',
    ///   ',', or space characters.
    ///   Each element must either be '*', or a RFC 3066 language range
    ///   canonicalized as by [`from_string()`][Self::from_string()]
    ///
    /// # Returns
    ///
    /// [`true`] if a match was found
    #[doc(alias = "pango_language_matches")]
    pub fn matches(&self, range_list: &str) -> bool {
        unsafe {
            from_glib(ffi::pango_language_matches(
                self.to_glib_none().0,
                range_list.to_glib_none().0,
            ))
        }
    }

    /// Determines if @script is one of the scripts used to
    /// write @self.
    ///
    /// The returned value is conservative; if nothing is known about
    /// the language tag @self, [`true`] will be returned, since, as
    /// far as Pango knows, @script might be used to write @self.
    ///
    /// This routine is used in Pango's itemization process when
    /// determining if a supplied language tag is relevant to
    /// a particular section of text. It probably is not useful
    /// for applications in most circumstances.
    ///
    /// This function uses [`scripts()`][Self::scripts()] internally.
    /// ## `script`
    /// a [`Script`][crate::Script]
    ///
    /// # Returns
    ///
    /// [`true`] if @script is one of the scripts used
    ///   to write @self or if nothing is known about @self
    ///   (including the case that @self is [`None`]), [`false`] otherwise.
    #[doc(alias = "pango_language_includes_script")]
    pub fn includes_script(&self, script: Script) -> bool {
        unsafe {
            from_glib(ffi::pango_language_includes_script(
                self.to_glib_none().0,
                script.into_glib(),
            ))
        }
    }

    /// Determines the scripts used to to write @self.
    ///
    /// If nothing is known about the language tag @self,
    /// or if @self is [`None`], then [`None`] is returned.
    /// The list of scripts returned starts with the script that the
    /// language uses most and continues to the one it uses least.
    ///
    /// The value @num_script points at will be set to the number
    /// of scripts in the returned array (or zero if [`None`] is returned).
    ///
    /// Most languages use only one script for writing, but there are
    /// some that use two (Latin and Cyrillic for example), and a few
    /// use three (Japanese for example). Applications should not make
    /// any assumptions on the maximum number of scripts returned
    /// though, except that it is positive if the return value is not
    /// [`None`], and it is a small number.
    ///
    /// The [`includes_script()`][Self::includes_script()] function uses this
    /// function internally.
    ///
    /// Note: while the return value is declared as [`Script`][crate::Script], the
    /// returned values are from the `GUnicodeScript` enumeration, which
    /// may have more values. Callers need to handle unknown values.
    ///
    /// # Returns
    ///
    ///
    ///   An array of [`Script`][crate::Script] values, with the number of entries in
    ///   the array stored in @num_scripts, or [`None`] if Pango does not have
    ///   any information about this particular language tag (also the case
    ///   if @self is [`None`]).
    #[doc(alias = "get_scripts")]
    #[doc(alias = "pango_language_get_scripts")]
    pub fn scripts(&self) -> Vec<Script> {
        let mut num_scripts = 0;
        let mut ret = Vec::new();

        unsafe {
            let scripts: *const ffi::PangoScript =
                ffi::pango_language_get_scripts(self.to_glib_none().0, &mut num_scripts);
            if num_scripts > 0 {
                for x in 0..num_scripts {
                    ret.push(from_glib(
                        *(scripts.offset(x as isize) as *const ffi::PangoScript),
                    ));
                }
            }
            ret
        }
    }

    /// Get a string that is representative of the characters needed to
    /// render a particular language.
    ///
    /// The sample text may be a pangram, but is not necessarily. It is chosen
    /// to be demonstrative of normal text in the language, as well as exposing
    /// font feature requirements unique to the language. It is suitable for use
    /// as sample text in a font selection dialog.
    ///
    /// If @self is [`None`], the default language as found by
    /// [`default()`][Self::default()] is used.
    ///
    /// If Pango does not have a sample string for @self, the classic
    /// "The quick brown fox..." is returned.  This can be detected by
    /// comparing the returned pointer value to that returned for (non-existent)
    /// language code "xx".  That is, compare to:
    ///
    /// ```text
    /// pango_language_get_sample_string (pango_language_from_string ("xx"))
    /// ```
    ///
    /// # Returns
    ///
    /// the sample string
    #[doc(alias = "get_sample_string")]
    #[doc(alias = "pango_language_get_sample_string")]
    pub fn sample_string(&self) -> GString {
        unsafe { from_glib_none(ffi::pango_language_get_sample_string(self.to_glib_none().0)) }
    }

    /// Returns the list of languages that the user prefers.
    ///
    /// The list is specified by the `PANGO_LANGUAGE` or `LANGUAGE`
    /// environment variables, in order of preference. Note that this
    /// list does not necessarily include the language returned by
    /// [`default()`][Self::default()].
    ///
    /// When choosing language-specific resources, such as the sample
    /// text returned by [`sample_string()`][Self::sample_string()],
    /// you should first try the default language, followed by the
    /// languages returned by this function.
    ///
    /// # Returns
    ///
    /// a [`None`]-terminated array
    ///   of [`Language`][crate::Language]*
    #[cfg(any(feature = "v1_48", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_48")))]
    #[doc(alias = "get_preferred")]
    #[doc(alias = "pango_language_get_preferred")]
    pub fn preferred(&self) -> Vec<Language> {
        unsafe {
            let langs = ffi::pango_language_get_preferred();
            let mut ptr = langs;

            let mut ret = vec![];

            while !(*ptr).is_null() {
                ret.push(Language(*ptr));
                ptr = ptr.add(1);
            }

            ret
        }
    }
}