// Authors: Robert Lopez

mod constants;
pub mod error;
#[cfg(test)]
mod tests;

use crate::error::WasmCssError;
use constants::VALID_CSS_KEYS;
use std::collections::{HashMap, VecDeque};
use web_sys::window;

/// Arguments: `$format:expr $(, $arg:expr)*` *(Formatter)*
///
/// ---
///
/// Builds a `crate::error::WasmCssError` via `format!`
macro_rules! format_error {
    ($format:expr $(, $arg:expr)*) => {
        $crate::error::WasmCssError(vec![format!($format $(, $arg)*)])
    };
}

/// Represents a CSS `Style`
#[derive(Debug, Clone)]
pub struct Style {
    pub css: String,
    pub class: String,
    pub global: bool,
    pub effects: HashMap<String, String>,
    pub components: HashMap<String, String>,
}

impl Style {
    /// Parse a effect into a ID and value
    ///
    /// Example:
    ///
    /// ```
    /// &:hover { font-size: 10rem; }
    ///
    /// ID = &:hover
    ///
    /// VALUE = { font-size: 10rem; }
    ///
    /// ```
    fn _parse_effect<E: Into<String>>(effect: E) -> (String, String) {
        let css = effect.into();
        let mut id_chars = vec![];
        let mut value_chars = vec![];

        let mut css_chars_queue = VecDeque::from_iter(css.trim().chars());

        // Parse ID
        let mut previous_char = None;
        while let Some(char) = css_chars_queue.pop_front() {
            if char == '\n' {
                continue;
            }

            if char == '{' {
                break;
            }

            if let Some(previous_char) = previous_char {
                if char == ' ' && previous_char == ' ' {
                    continue;
                }
            }

            id_chars.push(char.clone());
            previous_char = Some(char);
        }

        // Parse Value
        let mut previous_char = None;
        while let Some(char) = css_chars_queue.pop_front() {
            if char == '\n' {
                continue;
            }

            if let Some(previous_char) = previous_char {
                if char == ' ' && previous_char == ' ' {
                    continue;
                }
            }

            value_chars.push(char.clone());
            previous_char = Some(char);
        }
        value_chars.pop();

        let id = id_chars.into_iter().collect::<String>().trim().to_string();
        let value = value_chars
            .into_iter()
            .collect::<String>()
            .trim()
            .to_string();

        (id, value)
    }

    /// Parse raw `css` string into `Style`
    ///
    /// TODO: Validation beyond invalid keys or key: value format
    fn _build(css: String, class: String, global: bool) -> Self {
        let lines = css.split(";").collect::<Vec<&str>>();
        let mut filtered_css = format!("{}{} {{ ", if global { "" } else { "." }, class);

        let mut components = HashMap::new();

        for line in lines {
            let line = line.trim();
            let component_split = line.split(":").collect::<Vec<&str>>();

            if component_split.len() != 2 || !VALID_CSS_KEYS.contains(&component_split[0]) {
                continue;
            }

            components.insert(
                component_split[0].to_string(),
                component_split[1].trim().to_string(),
            );

            filtered_css += line;
            filtered_css += "; ";
        }

        filtered_css += "}";

        Self {
            css: filtered_css,
            class,
            global,
            effects: HashMap::new(),
            components,
        }
    }

    fn _build_css_from_components(&self) -> String {
        let mut css = format!("{}{} {{ ", if self.global { "" } else { "." }, self.class);

        for (key, value) in self.components.iter() {
            css += key;
            css += ": ";
            css += value;
            css += "; ";
        }

        for (key, value) in self.effects.iter() {
            css += key;
            css += " { ";
            css += value;
            css += " } ";
        }

        css += "}";
        css
    }

    fn _generate_class_uuid() -> Result<String, WasmCssError> {
        let window = window().ok_or(format_error!("Failed to obtain Window object"))?;
        let crypto = window
            .crypto()
            .map_err(|_| format_error!("Failed to obtain Crypto object"))?;

        let mut uuid = crypto.random_uuid();
        unsafe {
            uuid.as_bytes_mut()[0] = b'z';
        }

        Ok(uuid)
    }

    fn _update_class(&self) -> Result<(), WasmCssError> {
        let window = window().ok_or(format_error!("Failed to obtain Window object"))?;
        let document = window
            .document()
            .ok_or(format_error!("Failed to obtain Document object"))?;

        let head = document
            .head()
            .ok_or(format_error!("Failed to obtain HtmlHeadElement object"))?;

        if let Some(existing_style) = document.get_element_by_id(&self.class) {
            existing_style.set_id(&self.class);
            existing_style.set_class_name(&self.class);
            existing_style.set_inner_html(&self.css);
        }

        let style = document
            .create_element("style")
            .map_err(|_| format_error!("Failed to create new style Element"))?;

        style.set_id(&self.class);
        style.set_class_name(&self.class);
        style.set_inner_html(&self.css);

        head.append_child(&style)
            .map_err(|_| format_error!("Failed to add new style Element to HtmlHeadElement"))?;

        Ok(())
    }

    /// Construct a `Style` from a CSS string
    ///
    /// `global` simply removes the `.` from the class name, making
    /// it a global style, and requires you provide a `target` E.x. "html"
    ///
    /// - See `style!` and `global_style!` for built-in formatting
    ///
    /// - Generates random class name if one is not provided
    ///
    /// - Returns `WasmCssError` if unable to locate Crypto when generating uuid
    ///
    /// - Returns `WasmCssError` if unable to locate Document/Window/Head
    ///
    /// - Returns `WasmCssError` if `global` is true and `target` is `None`
    ///
    /// ---
    ///
    /// Example Usage:
    /// ```
    ///
    /// let style: Style = Style::new(
    ///     "
    ///         gap: 10rem;
    ///         display: flex;
    ///         flex-direction: column;
    ///     ",
    ///     None,
    /// )?;
    /// ```
    pub fn new(css: String, target: Option<String>, global: bool) -> Result<Self, WasmCssError> {
        if target.is_none() && global {
            return Err(format_error!("Global cannot be provided with no target"));
        }

        let class = target.unwrap_or(Self::_generate_class_uuid()?);
        let style = Self::_build(css, class, global);
        style._update_class()?;

        Ok(style)
    }

    /// Returns this `Style`s class name
    pub fn class(&self) -> &String {
        &self.class
    }

    /// Append another `Style` to this one, overwriting any fields on
    /// `self` matching with `source`, or adding them if they did not
    /// previously exist, updating the Style
    ///
    /// ---
    ///
    /// Example Usage:
    /// ```
    ///
    /// let mut style_one = style!("color: red; font-size: 10rem;")?;
    ///
    /// let style_two = style!("font-size: 30rem; background-color: red;")?;
    ///
    /// style_one.append(&style_two)?;
    ///
    /// // style_one.css: "color: red; font-size: 30rem; background-color: red;"
    /// ```
    pub fn append(&mut self, source: &Style) -> Result<(), WasmCssError> {
        self.components
            .extend(source.components.clone().into_iter());
        self.css = self._build_css_from_components();
        self._update_class()?;

        Ok(())
    }

    /// Insert a new CSS line into the `Style`
    ///
    /// - Skips invalid keys
    ///
    /// ---
    ///
    /// Example Usage:
    /// ```
    ///
    /// let mut style = style!("color: red; font-size: 10rem;")?;
    ///
    /// style.insert("font-weight", "bold");
    /// ```
    pub fn insert<V: Into<String>>(&mut self, key: &str, value: V) -> Result<(), WasmCssError> {
        if !VALID_CSS_KEYS.contains(&key) {
            return Ok(());
        }

        self.components.insert(key.into(), value.into());
        self.css = self._build_css_from_components();
        self._update_class()?;

        Ok(())
    }

    /// Remove a CSS line from `Style`
    ///
    /// ---
    ///
    /// Example Usage:
    /// ```
    ///
    /// let mut style = style!("color: red; font-size: 10rem;")?;
    ///
    /// style.remove("color", "red")?;
    /// ```
    pub fn remove(&mut self, key: &str) -> Result<(), WasmCssError> {
        self.components.remove(key);
        self.css = self._build_css_from_components();
        self._update_class()?;

        Ok(())
    }

    /// Insert many CSS lines into the `Style`
    ///
    /// - Skips invalid keys
    ///
    /// ---
    ///
    /// Example Usage:
    /// ```
    ///
    /// let mut style = style!("color: red; font-size: 10rem;")?;
    ///
    /// style.insert_many(vec![
    ///     ("font-weight", "bold"),
    ///     ("background-color", "red")
    /// ])?;
    /// ```
    pub fn insert_many<V: Into<String>>(
        &mut self,
        components: Vec<(&str, V)>,
    ) -> Result<(), WasmCssError> {
        for (key, value) in components {
            if !VALID_CSS_KEYS.contains(&key) {
                continue;
            }

            self.components.insert(key.into(), value.into());
        }

        self.css = self._build_css_from_components();
        self._update_class()?;

        Ok(())
    }

    /// Remove CSS lines from `Style`
    ///
    /// ---
    ///
    /// Example Usage:
    /// ```
    ///
    /// let mut style = style!("color: red; font-size: 10rem;")?;
    ///
    /// style.remove("color", "red")?;
    /// ```
    pub fn remove_many(&mut self, keys: Vec<&str>) -> Result<(), WasmCssError> {
        for key in keys {
            self.components.remove(key);
        }

        self.css = self._build_css_from_components();
        self._update_class()?;

        Ok(())
    }

    /// Add a `effect` to the `Style`
    ///
    /// Effect meaning sub-components to a class like
    /// MediaQuery, Hover, Etc.
    ///
    /// The `ID` of the effect becomes its tag component.
    ///
    /// ---
    ///
    /// Example Usage:
    /// ```
    ///
    /// let mut style = style!("color: red;")?;
    ///
    /// // Effect ID = '&:hover'
    /// style.insert_effect("&:hover { font-size: 10rem; }")?;
    /// ```
    pub fn insert_effect<E: Into<String>>(&mut self, effect: E) -> Result<(), WasmCssError> {
        let (id, value) = Self::_parse_effect(effect);
        self.effects.insert(id, value);
        self.css = self._build_css_from_components();
        self._update_class()?;

        Ok(())
    }

    /// Remove a `effect` from the `Style`
    ///
    /// Effect meaning sub-components to a class like
    /// MediaQuery, Hover, Etc.
    ///
    /// The `ID` or name of the added effect is just its `tag`.
    ///
    /// ---
    ///
    /// Example Usage:
    /// ```
    ///
    /// let mut style = style!("color: red;")?;
    ///
    /// // Effect ID = '&:hover'
    /// style.insert_effect("&:hover { font-size: 10rem; };")?;
    ///
    /// style.remove_effect("&:hover")?;
    /// ```
    pub fn remove_effect(&mut self, id: &str) -> Result<(), WasmCssError> {
        self.effects.remove(id);
        self.css = self._build_css_from_components();
        self._update_class()?;

        Ok(())
    }

    /// Add many `effect`s to the `Style`
    ///
    /// Effect meaning sub-components to a class like
    /// MediaQuery, Hover, Etc.
    ///
    /// The `ID` of the effect becomes its tag component.
    ///
    /// ---
    ///
    /// Example Usage:
    /// ```
    ///
    /// let mut style = style!("color: red;")?;
    ///
    /// // Effect IDs = '&:hover' & '@media (max-width: 400px)'
    /// style.insert_effect_many(vec![
    ///     "&:hover { font-size: 10rem; }",
    ///     "@media (max-width: 400px) { color: blue; }"
    /// ])?;
    /// ```
    pub fn insert_effect_many<E: Into<String>>(
        &mut self,
        effects: Vec<E>,
    ) -> Result<(), WasmCssError> {
        for effect in effects {
            let (id, value) = Self::_parse_effect(effect);
            self.effects.insert(id, value);
        }

        self.css = self._build_css_from_components();
        self._update_class()?;

        Ok(())
    }

    /// Remove many `effect`s from the `Style`
    ///
    /// Effect meaning sub-components to a class like
    /// MediaQuery, Hover, Etc.
    ///
    /// The `ID` of the effect becomes its tag component.
    ///
    /// ---
    ///
    /// Example Usage:
    /// ```
    ///
    /// let mut style = style!("color: red;")?;
    ///
    /// // Effect IDs = '&:hover' & '@media (max-width: 400px)'
    /// style.insert_effect_many(vec![
    ///     "&:hover { font-size: 10rem; }",
    ///     "@media (max-width: 400px) { color: blue; }"
    /// ])?;
    ///
    /// style.remove_effect_many(vec!["&:hover", "@media (max-width: 400px)"])?;
    /// ```
    pub fn remove_effect_many(&mut self, effect_ids: Vec<&str>) -> Result<(), WasmCssError> {
        for effect_id in effect_ids {
            self.effects.remove(effect_id);
        }

        self.css = self._build_css_from_components();
        self._update_class()?;

        Ok(())
    }
}

/// Construct a `Style` from a CSS string with formatting
///
/// - Returns `WasmCssError` if unable to locate Crypto when generating uuid
///
/// - Returns `WasmCssError` if unable to locate Document/Window/Head
///
/// ---
///
/// ```
///
/// style!(css: &str) -> Result<Style, WasmCssError>
/// ```
///
/// ---
///
/// Example Usage:
/// ```
///
/// style!(
///     "
///         gap: {}rem;
///         display: flex;
///         flex-direction: column;
///     ",
///     gap_size
/// )?;
/// ```
#[macro_export]
macro_rules! style {
    ($css:expr $(, $arg:expr)*) => {{
        let formatted_css = format!($css $(, $arg)*);

        $crate::Style::new(formatted_css, None, false)
    }};
}

/// Construct a `Style` from a CSS string with formatting
///
/// - Returns `WasmCssError` if unable to locate Crypto when generating uuid
///
/// - Returns `WasmCssError` if unable to locate Document/Window/Head
///
/// ---
///
/// ```
///
/// named_style!(class_name: Into<String>, css: &str) -> Result<Style, WasmCssError>
/// ```
///
/// ---
///
/// Example Usage:
///
/// ```
///
/// named_style!(
///     "my_class",
///     "
///         gap: {}rem;
///         display: flex;
///         flex-direction: column;
///     ",
///     gap_size
/// )?;
/// ```
#[macro_export]
macro_rules! named_style {
    ($name:expr, $css:expr $(, $arg:expr)*) => {{
        let formatted_css = format!($css $(, $arg)*);

        $crate::Style::new(formatted_css, Some($name.into()), false)
    }};
}

/// Construct a global `Style` from a CSS string with formatting
///
/// - Returns `WasmCssError` if unable to locate Crypto when generating uuid
///
/// - Returns `WasmCssError` if unable to locate Document/Window/Head
///
/// ---
///
/// ```
///
/// global_style!(target: Into<String>, css: &str) -> Result<Style, WasmCssError>
/// ```
///
/// ---
///
/// Example Usage:
/// ```
///
/// global_style!(
///     "html",
///     "
///         gap: {}rem;
///         display: flex;
///         flex-direction: column;
///     ",
///     gap_size
/// )?;
/// ```
#[macro_export]
macro_rules! global_style {
    ($target:expr, $css:expr $(, $arg:expr)*) => {{
        let formatted_css = format!($css $(, $arg)*);

        $crate::Style::new(formatted_css, Some($target.into()), true)
    }};
}

/// Add a `effect`(s) to the `Style` with formatting
///
/// Effect meaning sub-components to a class like
/// MediaQuery, Hover, Etc.
///
/// The `ID` of the effect becomes its tag component.
///
/// ---
///
/// ```
///
/// add_effects!(style: &mut Style, effect formats) -> Result<(), WasmCssError>
/// ```
///
/// ---
///
/// Example Usage:
/// ```
///
/// let mut style = style!("color: red;")?;
///
/// add_effects!(
///     &mut style,
///     (" // Effect ID = &:hover
///         &:hover {{
///             color: black;
///         }}
///     "),
///     (" // Effect ID = @media (max-width: 400px)
///         @media (max-width: {}px) {{
///             font-size: 10rem;
///         }}
///     ",
///         400
///     )
/// )?;
/// ```
#[macro_export]
macro_rules! add_effects {
    ($style:expr,  $(($fmt:expr $(, $($arg:expr)*)?)),*) => {{
        let mut formatted_effects = Vec::new();
        $(
            formatted_effects.push(format!($fmt $(, $($arg)*)?));
        )*

        $style.insert_effect_many(formatted_effects)
    }}
}