use super::*;

/// Represents contents of an .attheme file.
#[derive(Debug, PartialEq, Clone)]
pub struct Attheme {
  /// An `IndexMap` of variables of the theme.
  pub variables: Variables,
  /// The image wallpaper of the theme.
  ///
  /// Note that Telegram only recognizes `.jpg` images, but the crate doesn't
  /// check that the wallpaper is actually a valid `.jpg`. You should do it on
  /// your own.
  pub wallpaper: Option<Wallpaper>,
}

impl Attheme {
  /// Creates an empty theme.
  ///
  /// # Examples
  ///
  /// ```
  /// use attheme::Attheme;
  ///
  /// let theme = Attheme::new();
  ///
  /// assert!(theme.variables.is_empty());
  /// assert_eq!(theme.wallpaper, None);
  /// ```
  #[must_use]
  pub fn new() -> Attheme {
    Attheme {
      variables: IndexMap::new(),
      wallpaper: None,
    }
  }

  /// Creates an empty theme, with preallocation for `capacity` variables.
  #[must_use]
  pub fn with_capacity(capacity: usize) -> Attheme {
    Attheme {
      variables: IndexMap::with_capacity(capacity),
      wallpaper: None,
    }
  }

  /// Parses .attheme contents passed as bytes.
  ///
  /// # Examples
  ///
  /// ```
  /// use attheme::Attheme;
  ///
  /// let contents = b"
  /// checkbox=-1
  /// checkboxCheck=#123456
  /// divider=#40302010
  ///
  /// WPS
  /// Pretend it's Mona Lisa here
  /// WPE
  /// ";
  /// let theme = Attheme::from_bytes(contents);
  ///
  /// assert_eq!(theme.variables["checkbox"], [0xff; 4]);
  /// assert_eq!(theme.variables["checkboxCheck"], [0x12, 0x34, 0x56, 0xff]);
  /// assert_eq!(theme.variables["divider"], [0x30, 0x20, 0x10, 0x40]);
  /// assert_eq!(
  ///   theme.wallpaper,
  ///   Some(b"Pretend it's Mona Lisa here".to_vec()),
  /// );
  /// ```
  ///
  /// # Notes
  ///
  /// If Telegram can't parse something, it will simply ignore it. This crate
  /// resembles this behavior.
  ///
  /// Though Telegram only recognizes `.jpg` images, the crate does not check
  /// if the image is a valid `.jpg`. You should do it on your own.
  #[must_use]
  pub fn from_bytes(contents: &[u8]) -> Attheme {
    parser::from_bytes(contents)
  }

  /// Serializes the theme.
  ///
  /// # Examples
  /// ```
  /// use attheme::*;
  ///
  /// let mut theme = Attheme::new();
  ///
  /// theme.variables.insert("divider".to_string(), [1, 2, 3, 4]);
  /// theme.variables.insert("checkbox".to_string(), [0xff; 4]);
  ///
  /// let expected_contents = b"divider=67174915
  /// checkbox=-1
  /// ".to_vec();
  ///
  /// assert_eq!(theme.to_bytes(ColorSignature::Int), expected_contents);
  ///
  /// theme.wallpaper = Some(b"Pretend it's Mona Lisa here".to_vec());
  ///
  /// let expected_contents = b"divider=#04010203
  /// checkbox=#ffffffff
  ///
  /// WPS
  /// Pretend it's Mona Lisa here
  /// WPE
  /// ".to_vec();
  ///
  /// assert_eq!(theme.to_bytes(ColorSignature::Hex), expected_contents);
  /// ```
  #[must_use]
  pub fn to_bytes(&self, color_signature: ColorSignature) -> Vec<u8> {
    serializer::theme_to_bytes(
      &self.variables,
      &self.wallpaper,
      color_signature,
    )
  }
}

/// Adds all variables from `other` to `self`.
///
/// # Example
///
/// ```
/// use attheme::Attheme;
///
/// let mut first_theme = Attheme::new();
/// let mut second_theme = Attheme::new();
/// let wallpaper = b"Just pretending".to_vec();
///
/// first_theme.variables.insert("checkbox".to_string(), [0xff; 4]);
/// first_theme.wallpaper = Some(wallpaper.clone());
/// second_theme.variables.insert("checkbox".to_string(), [0x80; 4]);
/// second_theme.variables.insert("divider".to_string(), [0x40; 4]);
///
/// let third_theme = first_theme + second_theme;
///
/// assert_eq!(third_theme.variables["checkbox"], [0x80; 4]);
/// assert_eq!(third_theme.variables["divider"], [0x40; 4]);
/// assert_eq!(third_theme.wallpaper, Some(wallpaper));
/// ```
///
/// # Notes
///
/// If `other.wallpaper` is `None`, it will fallback to `self.wallpaper`.
impl std::ops::Add for Attheme {
  type Output = Attheme;

  fn add(self, other: Attheme) -> Attheme {
    let mut merged_theme = Attheme::new();

    for (variable, color) in other.variables {
      merged_theme.variables.insert(variable, color);
    }

    for (variable, color) in self.variables {
      merged_theme.variables.entry(variable).or_insert(color);
    }

    if let Some(wallpaper) = other.wallpaper {
      merged_theme.wallpaper = Some(wallpaper);
    } else if let Some(wallpaper) = self.wallpaper {
      merged_theme.wallpaper = Some(wallpaper);
    }

    merged_theme
  }
}

/// Adds all variables from `other` to `self`.
///
/// # Notes
///
/// If `other.wallpaper` is `None`, it will fallback to `self.wallpaper`.
impl<'a> std::ops::Add for &'a Attheme {
  type Output = Attheme;

  fn add(self, other: &Attheme) -> Attheme {
    let mut merged_theme = Attheme::with_capacity(other.variables.len());

    for (variable, color) in &other.variables {
      merged_theme.variables.insert(variable.clone(), color.clone());
    }

    for (variable, color) in &self.variables {
      merged_theme.variables.entry(variable.clone()).or_insert(color.clone());
    }

    if let Some(wallpaper) = &other.wallpaper {
      merged_theme.wallpaper = Some(wallpaper.clone());
    } else if let Some(wallpaper) = &self.wallpaper {
      merged_theme.wallpaper = Some(wallpaper.clone());
    }

    merged_theme
  }
}

/// Adds all variables from the `other` theme to `self`.
///
/// # Example
///
/// ```
/// use attheme::Attheme;
///
/// let mut first_theme = Attheme::new();
/// let mut second_theme = Attheme::new();
/// let wallpaper = b"Just pretending".to_vec();
///
/// first_theme.variables.insert("checkbox".to_string(), [0xff; 4]);
/// first_theme.wallpaper = Some(wallpaper.clone());
/// second_theme.variables.insert("checkbox".to_string(), [0x80; 4]);
/// second_theme.variables.insert("divider".to_string(), [0x40; 4]);
///
/// first_theme += second_theme;
///
/// assert_eq!(first_theme.variables["checkbox"], [0x80; 4]);
/// assert_eq!(first_theme.variables["divider"], [0x40; 4]);
/// assert_eq!(first_theme.wallpaper, Some(wallpaper));
/// ```
///
/// # Notes
///
/// If `other.wallpaper` is `None`, the wallpaper won't be removed.
impl std::ops::AddAssign for Attheme {
  fn add_assign(&mut self, other: Attheme) {
    for (variable, color) in other.variables {
      self.variables.insert(variable, color);
    }

    if let Some(wallpaper) = other.wallpaper {
      self.wallpaper = Some(wallpaper);
    }
  }
}

/// Adds all variables from the `&other` theme to `self`.
///
/// # Example
///
/// ```
/// use attheme::Attheme;
///
/// let mut first_theme = Attheme::new();
/// let mut second_theme = Attheme::new();
/// let wallpaper = b"Just pretending".to_vec();
///
/// first_theme.variables.insert("checkbox".to_string(), [0xff; 4]);
/// first_theme.wallpaper = Some(wallpaper.clone());
/// second_theme.variables.insert("checkbox".to_string(), [0x80; 4]);
/// second_theme.variables.insert("divider".to_string(), [0x40; 4]);
///
/// first_theme += &second_theme;
///
/// assert_eq!(
///   first_theme.variables["checkbox"],
///   second_theme.variables["checkbox"],
/// );
/// assert_eq!(
///   first_theme.variables["divider"],
///   second_theme.variables["divider"],
/// );
/// assert_eq!(first_theme.wallpaper, Some(wallpaper));
/// ```
///
/// # Notes
///
/// If `other.wallpaper` is `None`, the wallpaper won't be removed.
impl<'a> std::ops::AddAssign<&'a Attheme> for Attheme {
  fn add_assign(&mut self, other: &Attheme) {
    for (variable, color) in &other.variables {
      self.variables.insert(variable.clone(), color.clone());
    }

    if let Some(wallpaper) = &other.wallpaper {
      self.wallpaper = Some(wallpaper.clone());
    }
  }
}

/// Adds variables from `other` if absent in `self`.
///
/// Note that in this case, this works exactly as `other + self`.
impl std::ops::BitOr for Attheme {
  type Output = Attheme;

  fn bitor(self, other: Attheme) -> Attheme {
    other + self
  }
}

/// Adds variables from `&other` if absent in `&self`.
///
/// Note that in this case, this works exactly as `&other + &self`.
impl<'a> std::ops::BitOr for &'a Attheme {
  type Output = Attheme;

  fn bitor(self, other: &Attheme) -> Attheme {
    other + self
  }
}

/// Adds variables from `other` that are absent in `self`.
///
/// # Example
///
/// ```
/// use attheme::Attheme;
///
/// let mut first_theme = Attheme::new();
/// let mut second_theme = Attheme::new();
/// let wallpaper = b"Just pretending".to_vec();
///
/// first_theme.variables.insert("checkbox".to_string(), [0xff; 4]);
/// first_theme.wallpaper = Some(wallpaper.clone());
/// second_theme.variables.insert("checkbox".to_string(), [0x80; 4]);
/// second_theme.variables.insert("divider".to_string(), [0x40; 4]);
///
/// first_theme |= second_theme;
///
/// assert_eq!(first_theme.variables["checkbox"], [0xff; 4]);
/// assert_eq!(first_theme.variables["divider"], [0x40; 4]);
/// assert_eq!(first_theme.wallpaper, Some(wallpaper));
/// ```
impl std::ops::BitOrAssign for Attheme {
  fn bitor_assign(&mut self, other: Attheme) {
    for (variable, color) in other.variables {
      self.variables.entry(variable).or_insert(color);
    }

    if let None = self.wallpaper {
      self.wallpaper = other.wallpaper;
    }
  }
}

/// Similar to `theme |= other`, but clones only when neccesary.
///
/// # Example
///
/// ```
/// use attheme::Attheme;
///
/// let mut first_theme = Attheme::new();
/// let mut second_theme = Attheme::new();
/// let wallpaper = b"Just pretending".to_vec();
///
/// first_theme.variables.insert("checkbox".to_string(), [0xff; 4]);
/// first_theme.wallpaper = Some(wallpaper.clone());
/// second_theme.variables.insert("checkbox".to_string(), [0x80; 4]);
/// second_theme.variables.insert("divider".to_string(), [0x40; 4]);
///
/// first_theme |= &second_theme;
///
/// assert_eq!(first_theme.variables["checkbox"], [0xff; 4]);
/// assert_eq!(
///   first_theme.variables["divider"],
///   second_theme.variables["divider"],
/// );
/// assert_eq!(first_theme.wallpaper, Some(wallpaper));
/// ```
impl<'a> std::ops::BitOrAssign<&'a Attheme> for Attheme {
  fn bitor_assign(&mut self, other: &'a Attheme) {
    for (variable, color) in &other.variables {
      if !self.variables.contains_key(variable) {
        self.variables.insert(variable.clone(), color.clone());
      }
    }

    if let None = self.wallpaper {
      self.wallpaper = other.wallpaper.clone();
    }
  }
}