use deunicode::deunicode_char;

pub struct StrSlug {
    pub use_hash: bool,

    /// if its set to false the hash will be prepended
    pub append_hash: bool,

    /// use full hash if `hash_len` = 0
    pub hash_len: usize,

    /// separator to use to separate slug and hash
    pub hash_separator: char,

    pub separator: char,
    pub remove_duplicate_separators: bool,

    /// Trim leading and trailing separators after slugifying the given string.
    pub trim_separator: bool,
    pub trim_separator_start: bool,
    pub trim_separator_end: bool,
}

impl StrSlug {
    pub fn new() -> Self {
        Self {
            use_hash: false,
            append_hash: true,
            hash_len: 6,
            hash_separator: '_',

            separator: '-',
            remove_duplicate_separators: true,

            trim_separator: true,
            trim_separator_start: false,
            trim_separator_end: false,
        }
    }

    #[inline]
    fn _slug_ascii_char(&self, c: char) -> char {
        match c {
            'a'..='z' | '0'..='9' => c,
            'A'..='Z' => c.to_ascii_lowercase(),
            _ => self.separator,
        }
    }

    #[inline]
    fn _push(&self, slug: &mut String, c: char, is_separator: bool) -> bool {
        if c == self.separator {
            if !self.remove_duplicate_separators {
                slug.push(self.separator);
            } else if self.remove_duplicate_separators && !is_separator {
                slug.push(self.separator);
            }

            return true
        } else  {
            slug.push(c);
        }

        false
    }

    /// Generate a slug for the given value by applying user options.
    ///
    /// # Examples
    ///
    /// **Normal usage**
    ///
    /// ```rust
    /// use str_slug::StrSlug;
    ///
    /// let str_slug = StrSlug::new();
    /// let slug = str_slug::slug("Hello, World!");
    /// assert_eq!(slug, "hello-world");
    /// ```
    ///
    /// **Hashed slug**
    ///
    /// ```rust
    /// use str_slug::StrSlug;
    ///
    /// let mut str_slug = StrSlug::new();
    /// str_slug.use_hash = true;
    ///
    /// let slug = str_slug.slug("Hello, World!");
    /// assert_eq!(slug, "hello-world_288a86");
    /// ```
    pub fn slug<T: AsRef<str>>(&self, value: T) -> String {
        let value = value.as_ref();
        let mut slug = String::new();
        let mut is_separator = false;

        for c in value.chars() {
            if c.is_ascii() {
                let c = self._slug_ascii_char(c);
                is_separator = self._push(&mut slug, c, is_separator);
            } else {
                if let Some(output) = deunicode_char(c) {
                    for c in output.chars() {
                        let c = self._slug_ascii_char(c);
                        is_separator = self._push(&mut slug, c, is_separator);
                    }
                } else {
                    is_separator = self._push(&mut slug, self.separator, is_separator);
                }
            }
        }

        if self.trim_separator {
            slug = slug.trim_end_matches(|c| c == self.separator)
                .trim_start_matches(|c| c == self.separator)
                .to_string();
        } else {
            if self.trim_separator_start {
                slug = slug.trim_start_matches(|c| c == self.separator).to_string();
            }

            if self.trim_separator_end {
                slug = slug.trim_end_matches(|c| c == self.separator).to_string();
            }
        }

        #[cfg(feature = "hash")]
        {
            if self.use_hash && cfg!(feature = "hash") {
                let hash = blake3::hash(value.as_bytes()).to_hex();
                let hash_len = if self.hash_len == 0 || self.hash_len > hash.len() {
                    hash.len()
                } else {
                    self.hash_len
                };

                if self.append_hash {
                    slug.push_str(&format!("{}{}", self.hash_separator, &hash[..hash_len]));
                } else {
                    slug = format!("{}{}{}", &hash[..hash_len], self.hash_separator, slug);
                }
            }
        }

        slug
    }
}

/// Generate URL friendly slug of the given string.
///
/// # Examples
///
/// ```
/// use str_slug::slug;
///
/// let slug = slug("Hello, World ;-)");
/// assert_eq!("hello-world", slug);
/// ```
pub fn slug<T: AsRef<str>>(value: T) -> String {
    let str_slug = StrSlug::new();
    str_slug.slug(value)
}

/// Generate URL friendly slug of the given string, and append a hash to it.
///
/// # Features
/// - hash
///
/// # Examples
///
/// ```
/// use str_slug::slug_hash;
///
/// let slug = slug_hash("don’t let your life clubbed into dank submission. be on the watch, there are ways out.");
/// assert_eq!(slug, "don-t-let-your-life-clubbed-into-dank-submission-be-on-the-watch-there-are-ways-out_a2f4f4");
///
/// ```
pub fn slug_hash<T: AsRef<str>>(value: T) -> String {
    let mut str_slug = StrSlug::new();
    str_slug.use_hash = true;
    str_slug.slug(value)
}

/// Slugify the given string and append the hash of the given value (trimed)
///
/// # Examples
///
/// ```
/// use str_slug::slug_hash_len;
///
/// let slug = slug_hash_len("Hello, world ;-)", 6);
/// assert_eq!("hello-world_ea1ac5", slug);
/// ```
pub fn slug_hash_len<T: AsRef<str>>(value: T, hash_len: usize) -> String {
    let mut str_slug = StrSlug::new();
    str_slug.use_hash = true;
    str_slug.hash_len = hash_len;
    str_slug.slug(value)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn trim_whitespaces() {
        let slug = slug("   Hello, world!");
        assert_eq!("hello-world", slug);
    }

    #[test]
    fn trim_whitespace_start() {
        let mut slug = StrSlug::new();
        slug.remove_duplicate_separators = false;
        slug.trim_separator = false;
        slug.trim_separator_end = false;
        slug.trim_separator_start = true;
        let slug = slug.slug("   Hello, world!  ");
        assert_eq!("hello--world---", slug);
    }

    #[test]
    fn hello_hash() {
        let slug = slug_hash("oussama");
        assert_eq!("oussama_407ad6", slug);
    }

    #[test]
    fn hello_ascii() {
        let slug = super::slug("Hello, ascii");
        assert_eq!(slug, "hello-ascii");
    }

    #[test]
    fn hello_unicode() {
        let slug = super::slug("Æ, ☣");
        assert_eq!(slug, "ae-biohazard");
    }

    #[test]
    fn hello_ascii_unicode() {
        let slug = super::slug("Hello, Æ, ☣");
        assert_eq!(slug, "hello-ae-biohazard");
    }

    #[test]
    fn hello_empty_unicode() {
        let slug = super::slug("Hello, ❤ ;-)");
        assert_eq!(slug, "hello");
    }

    #[test]
    fn hello_empty_unicode_allow_duplicates_no_trimming() {
        let mut slug = StrSlug::new();
        slug.remove_duplicate_separators = false;
        slug.trim_separator = false;
        let slug = slug.slug("Hello, ❤ ;-)");
        assert_eq!("hello------", slug);
    }

    #[test]
    fn unicode_allow_duplicates_trim() {
        let mut slug = StrSlug::new();
        slug.remove_duplicate_separators = false;
        slug.trim_separator = true;
        let slug = slug.slug("Hello ‟Oussama‟ Æ, «☣» with ❤");
        assert_eq!("hello--oussama--ae----biohazard----with", slug);
    }
}