/*
 * Copyright 2016 Mattis Marjak
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
use std::ffi::{CStr, CString};
use std::{fmt, ptr, slice};

use libc::c_void;
#[cfg(target_os = "freebsd")]
use libc::size_t;

use bindings;
use conversions::*;
use result::MagickError;
#[cfg(not(target_os = "freebsd"))]
use size_t;

use crate::result::Result;
use super::{MagickTrue, MagickFalse};

use super::{DrawingWand, PixelWand};
use crate::{
    AlphaChannelOption,
    AutoThresholdMethod,
    ChannelType,
    ColorspaceType,
    CompositeOperator,
    CompressionType,
    DisposeType,
    DitherMethod,
    EndianType,
    FilterType,
    GravityType,
    Image,
    ImageType,
    InterlaceType,
    KernelInfo,
    LayerMethod,
    MagickEvaluateOperator,
    MagickFunction,
    MetricType,
    MorphologyMethod,
    OrientationType,
    PixelInterpolateMethod,
    PixelMask,
    RenderingIntent,
    ResolutionType,
    ResourceType,
    StatisticType,
};

wand_common!(
    MagickWand,
    NewMagickWand,
    ClearMagickWand,
    IsMagickWand,
    CloneMagickWand,
    DestroyMagickWand,
    MagickClearException,
    MagickGetExceptionType,
    MagickGetException
);

/// MagickWand is a Rustic wrapper to the Rust bindings to ImageMagick.
///
/// Instantiating a `MagickWand` will construct an ImageMagick "wand"
/// on which operations can be performed via the `MagickWand` functions.
/// When the `MagickWand` is dropped, the ImageMagick wand will be
/// destroyed as well.
impl MagickWand {
    /// Creates new wand by cloning the image.
    ///
    /// * `img`: the image.
    pub fn new_from_image(img: &Image<'_>) -> Result<MagickWand> {
        let result = unsafe {
            bindings::NewMagickWandFromImage(img.get_ptr())
        };

        return if result.is_null() {
            Err(MagickError("failed to create magick wand from image".to_string()))
        } else {
            Ok(MagickWand { wand: result })
        }
    }

    pub fn new_image(&self, columns: usize, rows: usize, background: &PixelWand) -> Result<()> {
        match unsafe { bindings::MagickNewImage(self.wand, columns.into(), rows.into(), background.wand) } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    // opt-in platforms that have resource limits support
    #[cfg(any(target_os = "linux", target_os = "macos"))]
    pub fn set_resource_limit(resource: ResourceType, limit: u64) -> Result<()> {
        let result = unsafe {
            bindings::SetMagickResourceLimit(
                resource.into(),
                limit as bindings::MagickSizeType,
            )
        };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError("failed to set resource limit".to_string())),
        }
    }

    pub fn set_option(&mut self, key: &str, value: &str) -> Result<()> {
        let c_key = CString::new(key).map_err(|_| "key string contains null byte")?;
        let c_value = CString::new(value).map_err(|_| "value string contains null byte")?;
        let result =
            unsafe { bindings::MagickSetOption(self.wand, c_key.as_ptr(), c_value.as_ptr()) };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    pub fn annotate_image(
        &mut self,
        drawing_wand: &DrawingWand,
        x: f64,
        y: f64,
        angle: f64,
        text: &str,
    ) -> Result<()> {
        let c_string = CString::new(text).map_err(|_| "could not convert to cstring")?;
        match unsafe {
            bindings::MagickAnnotateImage(
                self.wand,
                drawing_wand.wand,
                x,
                y,
                angle,
                c_string.as_ptr() as *const _,
            )
        } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Add all images from another wand to this wand at the current index.
    pub fn add_image(&mut self, other_wand: &MagickWand) -> Result<()> {
        match unsafe { bindings::MagickAddImage(self.wand, other_wand.wand) } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    pub fn append_all(&mut self, stack: bool) -> Result<MagickWand> {
        unsafe { bindings::MagickResetIterator(self.wand) };
        let result = unsafe { bindings::MagickAppendImages(self.wand, stack.to_magick()) };

        if result.is_null() {
            return Err(MagickError("failed to append image".to_string()));
        }
        return Ok(MagickWand { wand: result });
    }

    pub fn label_image(&self, label: &str) -> Result<()> {
        let c_label = CString::new(label).map_err(|_| "label string contains null byte")?;
        let result = unsafe { bindings::MagickLabelImage(self.wand, c_label.as_ptr()) };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    pub fn write_images(&self, path: &str, adjoin: bool) -> Result<()> {
        let c_name = CString::new(path).map_err(|_| "path string contains null byte")?;
        let result =
            unsafe { bindings::MagickWriteImages(self.wand, c_name.as_ptr(), adjoin.to_magick()) };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Read the image data from the named file.
    pub fn read_image(&self, path: &str) -> Result<()> {
        let c_name = CString::new(path).map_err(|_| "path string contains null byte")?;
        let result = unsafe { bindings::MagickReadImage(self.wand, c_name.as_ptr()) };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Read the image data from the vector of bytes.
    pub fn read_image_blob<T: AsRef<[u8]>>(&self, data: T) -> Result<()> {
        let int_slice = data.as_ref();
        let size = int_slice.len();
        let result = unsafe {
            bindings::MagickReadImageBlob(
                self.wand,
                int_slice.as_ptr() as *const c_void,
                size.into(),
            )
        };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Same as read_image, but reads only the width, height, size and format of an image,
    /// without reading data.
    pub fn ping_image(&self, path: &str) -> Result<()> {
        let c_name = CString::new(path).map_err(|_| "path string contains null byte")?;
        let result = unsafe { bindings::MagickPingImage(self.wand, c_name.as_ptr()) };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Same as read_image, but reads only the width, height, size and format of an image,
    /// without reading data.
    pub fn ping_image_blob<T: AsRef<[u8]>>(&self, data: T) -> Result<()> {
        let int_slice = data.as_ref();
        let size = int_slice.len();
        let result = unsafe {
            bindings::MagickPingImageBlob(
                self.wand,
                int_slice.as_ptr() as *const c_void,
                size.into(),
            )
        };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Composes all the image layers from the current given image onward to produce a single image
    /// of the merged layers.
    ///
    /// The inital canvas's size depends on the given LayerMethod, and is initialized using the
    /// first images background color. The images are then composited onto that image in sequence
    /// using the given composition that has been assigned to each individual image.
    ///
    /// * `method`: the method of selecting the size of the initial canvas.
    ///     MergeLayer: Merge all layers onto a canvas just large enough to hold all the actual
    ///     images. The virtual canvas of the first image is preserved but otherwise ignored.
    ///
    ///     FlattenLayer: Use the virtual canvas size of first image. Images which fall outside
    ///     this canvas is clipped. This can be used to 'fill out' a given virtual canvas.
    ///
    ///     MosaicLayer: Start with the virtual canvas of the first image, enlarging left and right
    ///     edges to contain all images. Images with negative offsets will be clipped.
    pub fn merge_image_layers(&self, method: LayerMethod) -> Result<MagickWand> {
        let result = unsafe {
            bindings::MagickMergeImageLayers(self.wand, method.into())
        };
        if result.is_null() {
            return Err(MagickError("failed to merge image layers".to_string()));
        }
        return Ok(MagickWand { wand: result });
    }

    /// Returns the number of images associated with a magick wand.
    pub fn get_number_images(&self) -> usize {
        return unsafe { bindings::MagickGetNumberImages(self.wand).into() };
    }

    /// Compare two images and return tuple `(distortion, diffImage)`
    /// `diffImage` is `None` if `distortion == 0`
    pub fn compare_images(
        &self,
        reference: &MagickWand,
        metric: MetricType,
    ) -> (f64, Option<MagickWand>) {
        let mut distortion: f64 = 0.0;
        let result = unsafe {
            bindings::MagickCompareImages(self.wand, reference.wand, metric.into(), &mut distortion)
        };
        let wand = if result.is_null() {
            None
        } else {
            Some(MagickWand { wand: result })
        };
        (distortion, wand)
    }

    /// Compose another image onto self at (x, y) using composition_operator
    pub fn compose_images(
        &self,
        reference: &MagickWand,
        composition_operator: CompositeOperator,
        clip_to_self: bool,
        x: isize,
        y: isize,
    ) -> Result<()> {
        let native_clip_to_self = if clip_to_self {
            MagickTrue
        } else {
            MagickFalse
        };
        let result = unsafe {
            bindings::MagickCompositeImage(
                self.wand,
                reference.wand,
                composition_operator.into(),
                native_clip_to_self,
                x,
                y,
            )
        };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Compose another image onto self with gravity using composition_operator
    pub fn compose_images_gravity(
        &self,
        reference: &MagickWand,
        composition_operator: CompositeOperator,
        gravity_type: GravityType,
    ) -> Result<()> {
        let result = unsafe {
            bindings::MagickCompositeImageGravity(
                self.wand,
                reference.wand,
                composition_operator.into(),
                gravity_type.into(),
            )
        };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Rebuilds image sequence with each frame size the same as first frame, and composites each frame atop of previous.
    /// Only affects GIF, and other formats with multiple pages/layers.
    pub fn coalesce(&mut self) -> Result<MagickWand> {
        let result = unsafe { bindings::MagickCoalesceImages(self.wand) };
        if result.is_null() {
            Err(MagickError("failed to coalesce images".to_string()))
        } else {
            Ok(MagickWand { wand: result })
        }
    }

    // Replaces colors in the image from a color lookup table.
    pub fn clut_image(
        &self,
        clut_wand: &MagickWand,
        method: PixelInterpolateMethod,
    ) -> Result<()> {
        let result = unsafe { bindings::MagickClutImage(self.wand, clut_wand.wand, method.into()) };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    pub fn hald_clut_image(&self, clut_wand: &MagickWand) -> Result<()> {
        let result = unsafe { bindings::MagickHaldClutImage(self.wand, clut_wand.wand) };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    pub fn fx(&mut self, expression: &str) -> Result<MagickWand> {
        let c_expression = CString::new(expression).map_err(|_| "expression string contains null byte")?;
        let wand = unsafe { bindings::MagickFxImage(self.wand, c_expression.as_ptr()) };
        if wand.is_null() {
            Err(MagickError("failed to fx the image".to_string()))
        } else {
            Ok(MagickWand { wand })
        }
    }

    pub fn set_size(&self, columns: usize, rows: usize) -> Result<()> {
        let result = unsafe { bindings::MagickSetSize(self.wand, columns.into(), rows.into()) };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    // Define two 'quantum_range' functions because the bindings::QuantumRange symbol
    // is not available if hdri is disabled in the compiled ImageMagick libs
    #[cfg(not(feature = "disable-hdri"))]
    fn quantum_range(&self) -> Result<f64> {
        Ok(bindings::QuantumRange)
    }

    // with disable-hdri enabled we define our own quantum_range
    // values lifted directly from magick-type.h
    #[cfg(feature = "disable-hdri")]
    fn quantum_range(&self) -> Result<f64> {
        match bindings::MAGICKCORE_QUANTUM_DEPTH {
            8 => Ok(255.0f64),
            16 => Ok(65535.0f64),
            32 => Ok(4294967295.0f64),
            64 => Ok(18446744073709551615.0f64),
            _ => Err(MagickError("Quantum depth must be one of 8, 16, 32 or 64".to_string())),
        }
    }

    // Level an image. Black and white points are multiplied with QuantumRange to
    // decrease dependencies on the end user.
    pub fn level_image(&self, black_point: f64, gamma: f64, white_point: f64) -> Result<()> {
        let quantum_range = self.quantum_range()?;

        let result = unsafe {
            bindings::MagickLevelImage(
                self.wand,
                black_point * quantum_range,
                gamma,
                white_point * quantum_range,
            )
        };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Applies the reversed [level_image](Self::level_image). It compresses the full range of color values, so
    /// that they lie between the given black and white points. Gamma is applied before the values
    /// are mapped. It can be used to de-contrast a greyscale image to the exact levels specified.
    pub fn levelize_image(&self, black_point: f64, gamma: f64, white_point: f64) -> Result<()> {
        let quantum_range = self.quantum_range()?;

        let result = unsafe {
            bindings::MagickLevelizeImage(
                self.wand,
                black_point * quantum_range,
                gamma,
                white_point * quantum_range,
            )
        };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    //MagickNormalizeImage enhances the contrast of a color image by adjusting the pixels color
    //to span the entire range of colors available
    pub fn normalize_image(
        &self,
    ) -> Result<()> {
        let result = unsafe {
            bindings::MagickNormalizeImage(
                self.wand,
            )
        };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    //MagickOrderedDitherImage performs an ordered dither based on a number of pre-defined
    //dithering threshold maps, but over multiple intensity levels, which can be different for
    //different channels, according to the input arguments.
    pub fn ordered_dither_image(
        &self,
        threshold_map: &str,
    ) -> Result<()> {
        let c_threshold_map = CString::new(threshold_map).map_err(|_| "threshold_map string contains null byte")?;

        let result = unsafe {
            bindings::MagickOrderedDitherImage(
                self.wand,
                c_threshold_map.as_ptr(),
            )
        };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Apply sigmoidal contrast to the image
    ///
    /// Adjusts the contrast of an image with a non-linear sigmoidal contrast algorithm. Increase
    /// the contrast of the image using a sigmoidal transfer function without saturating highlights
    /// or shadows. Contrast indicates how much to increase the contrast (0 is none; 3 is typical;
    /// 20 is pushing it); mid-point indicates where midtones fall in the resultant image (0.0 is
    /// white; 0.5 is middle-gray; 1.0 is black). Set sharpen to `true` to increase the image
    /// contrast otherwise the contrast is reduced.
    ///
    /// * `sharpen`: increase or decrease image contrast
    /// * `strength`: strength of the contrast, the larger the number the more 'threshold-like' it becomes.
    /// * `midpoint`: midpoint of the function as a number in range [0, 1]
    pub fn sigmoidal_contrast_image(
        &self,
        sharpen: bool,
        strength: f64,
        midpoint: f64,
    ) -> Result<()> {
        let quantum_range = self.quantum_range()?;

        let result = unsafe {
            bindings::MagickSigmoidalContrastImage(
                self.wand,
                sharpen.to_magick(),
                strength,
                midpoint * quantum_range,
            )
        };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Extend the image as defined by the geometry, gravity, and wand background color. Set the
    /// (x,y) offset of the geometry to move the original wand relative to the extended wand.
    pub fn extend_image(&self, width: usize, height: usize, x: isize, y: isize) -> Result<()> {
        let result = unsafe { bindings::MagickExtentImage(self.wand, width, height, x, y) };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    pub fn profile_image<'a, T: Into<Option<&'a [u8]>>>(
        &self,
        name: &str,
        profile: T,
    ) -> Result<()> {
        let c_name = CString::new(name).map_err(|_| "name string contains null byte")?;
        let result = unsafe {
            let profile = profile.into();
            let profile_ptr = match profile {
                Some(data) => data.as_ptr(),
                None => ptr::null(),
            } as *const c_void;
            let profile_len = match profile {
                Some(data) => data.len(),
                None => 0,
            };
            bindings::MagickProfileImage(self.wand, c_name.as_ptr(), profile_ptr, profile_len)
        };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    pub fn strip_image(&self) -> Result<()> {
        let result = unsafe { bindings::MagickStripImage(self.wand) };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    pub fn flip_image(&self) -> Result<()> {
        let result = unsafe { bindings::MagickFlipImage(self.wand) };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    pub fn negate_image(&self) -> Result<()> {
        let result = unsafe {
            bindings::MagickNegateImage(self.wand, MagickTrue)
        };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    pub fn flop_image(&self) -> Result<()> {
        let result = unsafe { bindings::MagickFlopImage(self.wand) };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    pub fn blur_image(&self, radius: f64, sigma: f64) -> Result<()> {
        let result = unsafe { bindings::MagickBlurImage(self.wand, radius, sigma) };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    pub fn gaussian_blur_image(&self, radius: f64, sigma: f64) -> Result<()> {
        let result = unsafe { bindings::MagickGaussianBlurImage(self.wand, radius, sigma) };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Replace each pixel with corresponding statistic from the neighborhood of the specified width and height.
    ///
    /// * `statistic_type`: the statistic type (e.g. `StatisticType::Median`, `StatisticType::Mode`, etc.).
    /// * `width`: the width of the pixel neighborhood.
    /// * `height`: the height of the pixel neighborhood.
    pub fn statistic_image(
        &self,
        statistic_type: StatisticType,
        width: usize,
        height: usize,
    ) -> Result<()> {
        match unsafe {
            bindings::MagickStatisticImage(
                self.wand,
                statistic_type.into(),
                width.into(),
                height.into()
            )
        } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Calculate median for each pixel's neighborhood.
    ///
    /// See [statistic_image](Self::statistic_image)
    pub fn median_blur_image(&self, width: usize, height: usize) -> Result<()> {
        return self.statistic_image(StatisticType::Median, width, height);
    }

    /// Adaptively resize the currently selected image.
    pub fn adaptive_resize_image(&self, width: usize, height: usize) -> Result<()> {
        match unsafe { bindings::MagickAdaptiveResizeImage(self.wand, width, height) } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Rotate the currently selected image by the given number of degrees,
    /// filling any empty space with the background color of a given PixelWand
    pub fn rotate_image(&self, background: &PixelWand, degrees: f64) -> Result<()> {
        match unsafe { bindings::MagickRotateImage(self.wand, background.wand, degrees) } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Trim the image removing the backround color from the edges.
    pub fn trim_image(&self, fuzz: f64) -> Result<()> {
        let result = unsafe { bindings::MagickTrimImage(self.wand, fuzz) };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Retrieve the width of the image.
    pub fn get_image_width(&self) -> usize {
        unsafe { bindings::MagickGetImageWidth(self.wand) }
    }

    /// Retrieve the height of the image.
    pub fn get_image_height(&self) -> usize {
        unsafe { bindings::MagickGetImageHeight(self.wand) }
    }

    /// Retrieve the page geometry (width, height, x offset, y offset) of the image.
    pub fn get_image_page(&self) -> (usize, usize, isize, isize) {
        let (mut width, mut height, mut x, mut y) = (0usize, 0usize, 0isize, 0isize);
        unsafe {
            bindings::MagickGetImagePage(self.wand, &mut width, &mut height, &mut x, &mut y);
        }
        (width, height, x, y)
    }

    /// Reset the Wand page canvas and position.
    pub fn reset_image_page(&self, page_geometry: &str) -> Result<()> {
        let c_page_geometry = CString::new(page_geometry).map_err(|_| "page_geometry contains null byte")?;
        match unsafe {
            bindings::MagickResetImagePage(self.wand, c_page_geometry.as_ptr())
        } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0))
        }
    }

    /// Returns a value associated with the specified artifact.
    ///
    /// * `artifact`: the artifact.
    pub fn get_image_artifact(&self, artifact: &str) -> Result<String> {
        let c_artifact = CString::new(artifact).map_err(|_| "artifact string contains null byte")?;

        let c_value = unsafe {
            bindings::MagickGetImageArtifact(
                self.wand,
                c_artifact.as_ptr()
            )
        };

        if c_value.is_null() {
            return Err(MagickError(format!("missing artifact: {}", artifact)));
        }
        // convert (and copy) the C string to a Rust string
        let value = unsafe { CStr::from_ptr(c_value) }.to_string_lossy().into_owned();

        unsafe {
            bindings::MagickRelinquishMemory(c_value as *mut c_void);
        }

        Ok(value)
    }

    pub fn get_image_artifacts(&self, pattern: &str) -> Result<Vec<String>> {
        let c_pattern = CString::new(pattern).map_err(|_| MagickError("artifact string contains null byte".to_string()))?;
        let mut num_of_artifacts: size_t = 0;

        let c_values = unsafe {
            bindings::MagickGetImageArtifacts(
                self.wand,
                c_pattern.as_ptr(),
                &mut num_of_artifacts
            )
        };

        if c_values.is_null() {
            return Err(MagickError("image has no artifacts".to_string()));
        }

        let mut values: Vec<String> = Vec::with_capacity(num_of_artifacts);
        for i in 0..num_of_artifacts {
            // convert (and copy) the C string to a Rust string
            let cstr = unsafe { CStr::from_ptr(*c_values.add(i)) };
            values.push(cstr.to_string_lossy().into_owned());
        }

        unsafe {
            bindings::MagickRelinquishMemory(c_values as *mut c_void);
        }

        Ok(values)
    }

    /// Sets a key-value pair in the image artifact namespace. Artifacts differ from properties.
    /// Properties are public and are generally exported to an external image format if the format
    /// supports it. Artifacts are private and are utilized by the internal ImageMagick API to
    /// modify the behavior of certain algorithms.
    ///
    /// * `artifact`: the artifact.
    /// * `value`: the value.
    ///
    /// # Example
    ///
    /// This example shows how you can blend an image with its blurred copy with 50% opacity by
    /// setting "compose:args" to "50". This is equivalent to having `-define compose:args=50` when
    /// using imagemagick cli.
    ///
    /// ```
    /// use magick_rust::{MagickWand, PixelWand, CompositeOperator};
    ///
    /// fn main() -> Result<(), magick_rust::MagickError> {
    ///     let mut wand1 = MagickWand::new();
    ///     wand1.new_image(4, 4, &PixelWand::new())?; // Replace with `read_image` to open your image file
    ///     let wand2 = wand1.clone();
    ///
    ///     wand1.median_blur_image(10, 10)?;
    ///
    ///     wand1.set_image_artifact("compose:args", "50")?;
    ///     wand1.compose_images(&wand2, CompositeOperator::Blend, false, 0, 0)?;
    ///
    ///     Ok(())
    /// }
    /// ```
    pub fn set_image_artifact(
        &mut self,
        artifact: &str,
        value: &str
    ) -> Result<()> {
        let c_artifact = CString::new(artifact).map_err(|_| "artifact string contains null byte")?;
        let c_value = CString::new(value).map_err(|_| "value string contains null byte")?;

        let result = unsafe {
            bindings::MagickSetImageArtifact(
                self.wand,
                c_artifact.as_ptr(),
                c_value.as_ptr()
            )
        };

        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Deletes a wand artifact.
    ///
    /// * `artifact`: the artifact.
    pub fn delete_image_artifact(&mut self, artifact: &str) -> Result<()> {
        let c_artifact = CString::new(artifact).map_err(|_| "artifact string contains null byte")?;

        match unsafe {
            bindings::MagickDeleteImageArtifact(
                self.wand,
                c_artifact.as_ptr()
            )
        } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(format!("missing artifact: {}", artifact))),
        }
    }

    /// Retrieve the named image property value.
    pub fn get_image_property(&self, name: &str) -> Result<String> {
        let c_name = CString::new(name).map_err(|_| "name string contains null byte")?;
        let c_value = unsafe { bindings::MagickGetImageProperty(self.wand, c_name.as_ptr()) };

        if c_value.is_null() {
            return Err(MagickError(format!("missing property: {}", name)));
        }

        // convert (and copy) the C string to a Rust string
        let value = unsafe { CStr::from_ptr(c_value) }.to_string_lossy().into_owned();

        unsafe {
            bindings::MagickRelinquishMemory(c_value as *mut c_void);
        }

        Ok(value)
    }

    pub fn get_image_properties(&self, pattern: &str) -> Result<Vec<String>> {
        let c_pattern = CString::new(pattern).map_err(|_| MagickError("artifact string contains null byte".to_string()))?;
        let mut num_of_artifacts: size_t = 0;

        let c_values = unsafe {
            bindings::MagickGetImageProperties(
                self.wand,
                c_pattern.as_ptr(),
                &mut num_of_artifacts
            )
        };

        if c_values.is_null() {
            return Err(MagickError(self.get_exception()?.0));
        }

        let mut values: Vec<String> = Vec::with_capacity(num_of_artifacts);
        for i in 0..num_of_artifacts {
            // convert (and copy) the C string to a Rust string
            let cstr = unsafe { CStr::from_ptr(*c_values.add(i)) };
            values.push(cstr.to_string_lossy().into_owned());
        }

        unsafe {
            bindings::MagickRelinquishMemory(c_values as *mut c_void);
        }

        Ok(values)
    }

    /// Set the named image property.
    pub fn set_image_property(&self, name: &str, value: &str) -> Result<()> {
        let c_name = CString::new(name).map_err(|_| "name string contains null byte")?;
        let c_value = CString::new(value).map_err(|_| "value string contains null byte")?;
        match unsafe {
            bindings::MagickSetImageProperty(self.wand, c_name.as_ptr(), c_value.as_ptr())
        } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Returns a `PixelWand` instance for the pixel specified by x and y offests.
    pub fn get_image_pixel_color(&self, x: isize, y: isize) -> Option<PixelWand> {
        let pw = PixelWand::new();

        match unsafe {
            bindings::MagickGetImagePixelColor(self.wand, x, y, pw.wand)
        } {
            MagickTrue => Some(pw),
            _ => None,
        }
    }

    /// Sets the image sampling factors.
    ///
    /// samplingFactors: An array of floats representing the sampling factor for each color component (in RGB order).
    pub fn set_sampling_factors(&self, samplingFactors: &[f64]) -> Result<()> {
        match unsafe {
            bindings::MagickSetSamplingFactors(
                self.wand,
                samplingFactors.len(),
                &samplingFactors[0],
            )
        } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Returns the image histogram as a vector of `PixelWand` instances for every unique color.
    pub fn get_image_histogram(&self) -> Option<Vec<PixelWand>> {
        let mut color_count: size_t = 0;

        unsafe {
            bindings::MagickGetImageHistogram(self.wand, &mut color_count)
                .as_mut()
                .map(|ptrs| {
                    slice::from_raw_parts(ptrs, color_count)
                        .iter()
                        .map(|raw_wand| PixelWand { wand: *raw_wand })
                        .collect()
                })
        }
    }

    /// Sharpens an image. We convolve the image with a Gaussian operator of the
    /// given radius and standard deviation (sigma). For reasonable results, the
    /// radius should be larger than sigma. Use a radius of 0 and SharpenImage()
    /// selects a suitable radius for you.
    ///
    /// radius: the radius of the Gaussian, in pixels, not counting the center pixel.
    ///
    /// sigma: the standard deviation of the Gaussian, in pixels.
    ///
    pub fn sharpen_image(&self, radius: f64, sigma: f64) -> Result<()> {
        match unsafe { bindings::MagickSharpenImage(self.wand, radius, sigma) } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Set the background color.
    pub fn set_background_color(&self, pixel_wand: &PixelWand) -> Result<()> {
        match unsafe { bindings::MagickSetBackgroundColor(self.wand, pixel_wand.wand) } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Set the image background color.
    pub fn set_image_background_color(&self, pixel_wand: &PixelWand) -> Result<()> {
        match unsafe { bindings::MagickSetImageBackgroundColor(self.wand, pixel_wand.wand) } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Returns the image resolution as a pair (horizontal resolution, vertical resolution)
    pub fn get_image_resolution(&self) -> Result<(f64, f64)> {
        let mut x_resolution = 0f64;
        let mut y_resolution = 0f64;
        match unsafe {
            bindings::MagickGetImageResolution(self.wand, &mut x_resolution, &mut y_resolution)
        } {
            MagickTrue => Ok((x_resolution, y_resolution)),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Sets the image resolution
    pub fn set_image_resolution(&self, x_resolution: f64, y_resolution: f64) -> Result<()> {
        match unsafe {
            bindings::MagickSetImageResolution(self.wand, x_resolution, y_resolution)
        } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Sets the wand resolution
    pub fn set_resolution(&self, x_resolution: f64, y_resolution: f64) -> Result<()> {
        match unsafe {
            bindings::MagickSetResolution(self.wand, x_resolution, y_resolution)
        } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Returns the image resolution as a pair (horizontal resolution, vertical resolution)
    pub fn sepia_tone_image(&self, threshold: f64) -> Result<()> {
        match unsafe {
            bindings::MagickSepiaToneImage(self.wand, threshold * self.quantum_range()?)
        } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Extracts pixel data from the image as a vector of 0..255 values defined by `map`.
    /// See <https://imagemagick.org/api/magick-image.php#MagickExportImagePixels> for more information.
    pub fn export_image_pixels(
        &self,
        x: isize,
        y: isize,
        width: usize,
        height: usize,
        map: &str,
    ) -> Option<Vec<u8>> {
        let c_map = CString::new(map).ok()?;
        let capacity = width * height * map.len();
        let mut pixels = Vec::with_capacity(capacity);
        pixels.resize(capacity, 0);

        unsafe {
            if bindings::MagickExportImagePixels(
                self.wand,
                x,
                y,
                width,
                height,
                c_map.as_ptr(),
                bindings::StorageType_CharPixel,
                pixels.as_mut_ptr() as *mut c_void,
            ) == MagickTrue
            {
                Some(pixels)
            } else {
                None
            }
        }
    }

    pub fn export_image_pixels_double(
        &self,
        x: isize,
        y: isize,
        width: usize,
        height: usize,
        map: &str,
    ) -> Option<Vec<f64>> {
        let c_map = CString::new(map).unwrap();
        let capacity = width * height * map.len();
        let mut pixels = Vec::with_capacity(capacity);
        pixels.resize(capacity, 0.0);

        unsafe {
            if bindings::MagickExportImagePixels(
                self.wand,
                x,
                y,
                width,
                height,
                c_map.as_ptr(),
                bindings::StorageType_DoublePixel,
                pixels.as_mut_ptr() as *mut c_void,
            ) == MagickTrue
            {
                Some(pixels)
            } else {
                None
            }
        }
    }

    /// Resize the image to the specified width and height, using the
    /// specified filter type.
    pub fn resize_image(&self, width: usize, height: usize, filter: FilterType) -> Result<()> {
        match unsafe {
            bindings::MagickResizeImage(self.wand, width.into(), height.into(), filter.into())
        } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Resize image by specifying the new size in percent of last size.
    ///
    /// Effectively resizes image to (current width * `width_scale`, current height *
    /// `height_scale`)
    pub fn scale_image(
        &self,
        width_scale: f64,
        height_scale: f64,
        filter: FilterType) -> Result<()> {
        if width_scale < 0.0 {
            return Err(MagickError("negative width scale given".to_string()));
        }
        if height_scale < 0.0 {
            return Err(MagickError("negative height scale given".to_string()));
        }

        let width = self.get_image_width();
        let height = self.get_image_height();

        let width = ((width as f64) * width_scale) as usize;
        let height = ((height as f64) * height_scale) as usize;

        return self.resize_image(width, height, filter);
    }

    /// Resize the image to the specified width and height, using the
    /// 'thumbnail' optimizations which remove a lot of image meta-data with the goal
    /// of producing small low cost images suited for display on the web.
    pub fn thumbnail_image(&self, width: usize, height: usize) -> Result<()> {
        match unsafe {
            bindings::MagickThumbnailImage(self.wand, width.into(), height.into())
        } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Extract a region of the image. The width and height is used as the size
    /// of the region. X and Y is the offset.
    pub fn crop_image(&self, width: usize, height: usize, x: isize, y: isize) -> Result<()> {
        let result = unsafe { bindings::MagickCropImage(self.wand, width, height, x, y) };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Sample the image to the target resolution
    ///
    /// This is incredibly fast, as it does 1-1 pixel mapping for downscales, and box filtering for
    /// upscales
    pub fn sample_image(&self, width: usize, height: usize) -> Result<()> {
        let result = unsafe { bindings::MagickSampleImage(self.wand, width, height) };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Resample the image to the specified horizontal and vertical resolution, using the
    /// specified filter type.
    pub fn resample_image(
        &self,
        x_resolution: f64,
        y_resolution: f64,
        filter: FilterType,
    ) -> Result<()> {
        match unsafe {
            bindings::MagickResampleImage(self.wand, x_resolution, y_resolution, filter.into())
        } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Rescale the image using seam carving algorithm
    pub fn liquid_rescale_image(
        &self,
        width: usize,
        height: usize,
        delta_x: f64,
        rigidity: f64,
    ) -> Result<()> {
        match unsafe {
            bindings::MagickLiquidRescaleImage(self.wand, width, height, delta_x, rigidity)
        } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Implodes the image towards the center by the specified percentage
    pub fn implode(&self, amount: f64, method: PixelInterpolateMethod) -> Result<()> {
        match unsafe { bindings::MagickImplodeImage(self.wand, amount, method.into()) } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Resize the image to fit within the given dimensions, maintaining
    /// the current aspect ratio.
    pub fn fit(&self, width: usize, height: usize) {
        let mut width_ratio = width as f64;
        width_ratio /= self.get_image_width() as f64;
        let mut height_ratio = height as f64;
        height_ratio /= self.get_image_height() as f64;
        let (new_width, new_height) = if width_ratio < height_ratio {
            (
                width,
                (self.get_image_height() as f64 * width_ratio) as usize,
            )
        } else {
            (
                (self.get_image_width() as f64 * height_ratio) as usize,
                height,
            )
        };
        unsafe {
            bindings::MagickResetIterator(self.wand);
            while bindings::MagickNextImage(self.wand) != MagickFalse {
                bindings::MagickResizeImage(
                    self.wand,
                    new_width.into(),
                    new_height.into(),
                    bindings::FilterType_LanczosFilter,
                );
            }
        }
    }

    /// Detect if the loaded image is not in top-left orientation, and
    /// hence should be "auto" oriented so it is suitable for viewing.
    pub fn requires_orientation(&self) -> bool {
        return self.get_image_orientation() != OrientationType::TopLeft;
    }

    /// Automatically adjusts the loaded image so that its orientation is
    /// suitable for viewing (i.e. top-left orientation).
    ///
    /// Returns `true` if successful or `false` if an error occurred.
    pub fn auto_orient(&self) -> bool {
        unsafe {
            bindings::MagickAutoOrientImage(self.wand) == MagickTrue
        }
    }

    /// Write the current image to the provided path.
    pub fn write_image(&self, path: &str) -> Result<()> {
        let c_name = CString::new(path).map_err(|_| "name string contains null byte")?;
        let result = unsafe { bindings::MagickWriteImage(self.wand, c_name.as_ptr()) };
        match result {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Write the image in the desired format to a new blob.
    ///
    /// The `format` argument may be any ImageMagick supported image
    /// format (e.g. GIF, JPEG, PNG, etc).
    pub fn write_image_blob(&self, format: &str) -> Result<Vec<u8>> {
        let c_format = CString::new(format).map_err(|_| "format string contains null byte")?;
        let mut length: size_t = 0;
        let blob = unsafe {
            bindings::MagickResetIterator(self.wand);
            bindings::MagickSetImageFormat(self.wand, c_format.as_ptr());
            bindings::MagickGetImageBlob(self.wand, &mut length)
        };
        if blob.is_null() {
            Err(MagickError(self.get_exception()?.0))
        } else {
            let mut bytes = Vec::with_capacity(length as usize);
            bytes.resize(length, 0);
            unsafe {
                ptr::copy_nonoverlapping(blob, bytes.as_mut_ptr(), length as usize);
                bindings::MagickRelinquishMemory(blob as *mut c_void);
            };
            Ok(bytes)
        }
    }

    /// Write the images in the desired format to a new blob.
    ///
    /// The `format` argument may be any ImageMagick supported image
    /// format (e.g. GIF, JPEG, PNG, etc).
    pub fn write_images_blob(&self, format: &str) -> Result<Vec<u8>> {
        let c_format = CString::new(format).map_err(|_| "format string contains null byte")?;
        let mut length: size_t = 0;
        let blob = unsafe {
            bindings::MagickSetIteratorIndex(self.wand, 0);
            bindings::MagickSetImageFormat(self.wand, c_format.as_ptr());
            bindings::MagickGetImagesBlob(self.wand, &mut length)
        };
        let mut bytes = Vec::with_capacity(length as usize);
        bytes.resize(length, 0);
        unsafe {
            ptr::copy_nonoverlapping(blob, bytes.as_mut_ptr(), length as usize);
            bindings::MagickRelinquishMemory(blob as *mut c_void);
        };
        Ok(bytes)
    }

    /// Return false if the image alpha channel is not activated.
    /// That is, the image is RGB rather than RGBA or CMYK rather than CMYKA
    pub fn get_image_alpha_channel(&self) -> bool {
        let res = unsafe { bindings::MagickGetImageAlphaChannel(self.wand) };
        res == MagickTrue
    }

    /// Renders the drawing wand on the current image
    pub fn draw_image(&mut self, drawing_wand: &DrawingWand) -> Result<()> {
        match unsafe { bindings::MagickDrawImage(self.wand, drawing_wand.wand) } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Removes skew from the image. Skew is an artifact that
    /// occurs in scanned images because of the camera being misaligned,
    /// imperfections in the scanning or surface, or simply because the paper was
    /// not placed completely flat when scanned
    pub fn deskew_image(&mut self, threshold: f64) -> Result<()> {
        match unsafe { bindings::MagickDeskewImage(self.wand, threshold) } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Sets image clip mask.
    ///
    /// * `pixel_mask`: type of mask, Read or Write.
    /// * `clip_mask`: the clip_mask wand.
    pub fn set_image_mask(
        &mut self,
        pixel_mask: PixelMask,
        clip_mask: &MagickWand
    ) -> Result<()> {
        match unsafe {
            bindings::MagickSetImageMask(
                self.wand,
                pixel_mask.into(),
                clip_mask.wand
            )
        } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Set image channel mask
    pub fn set_image_channel_mask(
        &mut self,
        option: ChannelType,
    ) -> ChannelType {
        unsafe { bindings::MagickSetImageChannelMask(self.wand, option.into()).into() }
    }

    /// Apply an arithmetic, relational, or logical
    /// expression to an image.  Use these operators to lighten or darken an image,
    /// to increase or decrease contrast in an image, or to produce the "negative"
    /// of an image.
    pub fn evaluate_image(&mut self, op: MagickEvaluateOperator, val: f64) -> Result<()> {
        let res = unsafe { bindings::MagickEvaluateImage(self.wand, op.into(), val) };
        match res {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Surround the image with a border of the color defined
    /// by the `pixel_wand`.
    pub fn border_image(
        &self,
        pixel_wand: &PixelWand,
        width: usize,
        height: usize,
        compose: CompositeOperator,
    ) -> Result<()> {
        match unsafe {
            bindings::MagickBorderImage(self.wand, pixel_wand.wand, width, height, compose.into())
        } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Simulate an image shadow
    pub fn shadow_image(&self, alpha: f64, sigma: f64, x: isize, y: isize) -> Result<()> {
        match unsafe {
            bindings::MagickShadowImage(self.wand, alpha, sigma, x, y)
        } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Accepts pixel data and stores it in the image at the location you specify.
    /// See <https://imagemagick.org/api/magick-image.php#MagickImportImagePixels> for more information.
    pub fn import_image_pixels(
        &mut self,
        x: isize,
        y: isize,
        columns: usize,
        rows: usize,
        pixels: &[u8],
        map: &str,
    ) -> Result<()> {
        let pixel_map = CString::new(map).map_err(|_| "map string contains null byte")?;
        match unsafe {
            bindings::MagickImportImagePixels(
                self.wand,
                x,
                y,
                columns,
                rows,
                pixel_map.as_ptr(),
                bindings::StorageType_CharPixel,
                pixels.as_ptr() as *const libc::c_void,
            )
        } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    pub fn import_image_pixels_double(
        &mut self,
        x: isize,
        y: isize,
        columns: usize,
        rows: usize,
        pixels: &[f64],
        map: &str,
    ) -> Result<()> {
        let pixel_map = CString::new(map).unwrap();
        match unsafe {
            bindings::MagickImportImagePixels(
                self.wand,
                x,
                y,
                columns,
                rows,
                pixel_map.as_ptr(),
                bindings::StorageType_DoublePixel,
                pixels.as_ptr() as *const libc::c_void,
            )
        } {
            MagickTrue => Ok(()),
            _ => Err(MagickError("unable to import pixels")),
        }
    }

    /// Set the wand iterator to the first image.
    /// See <https://imagemagick.org/api/magick-wand.php#MagickSetFirstIterator> for more information.
    pub fn set_first_iterator(&self) {
        unsafe {
            bindings::MagickSetFirstIterator(self.wand);
        }
    }

    /// Set the next image in the wand as the current image.
    /// See <https://imagemagick.org/api/magick-image.php#MagickNextImage> for more information.
    pub fn next_image(&self) -> bool {
        let res = unsafe { bindings::MagickNextImage(self.wand) };
        res == MagickTrue
    }

    /// Automatically performs threshold method to reduce grayscale data
    /// down to a binary black & white image. Included algorithms are
    /// Kapur, Otsu, and Triangle methods.
    /// See <https://imagemagick.org/api/magick-image.php#MagickAutoThresholdImage> for more information.
    pub fn auto_threshold(&self, method: AutoThresholdMethod) -> Result<()> {
        match unsafe { bindings::MagickAutoThresholdImage(self.wand, method.into()) } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Set the image colorspace, transforming (unlike `set_image_colorspace`) image data in
    /// the process.
    pub fn transform_image_colorspace(&self, colorspace: ColorspaceType) -> Result<()> {
        match unsafe { bindings::MagickTransformImageColorspace(self.wand, colorspace.into()) } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Reduce the number of colors in the image.
    pub fn quantize_image(
        &self,
        number_of_colors: usize,
        colorspace: ColorspaceType,
        tree_depth: usize,
        dither_method: DitherMethod,
        measure_error: bool) -> Result<()> {
        match unsafe { bindings::MagickQuantizeImage(
                self.wand,
                number_of_colors.into(),
                colorspace.into(),
                tree_depth.into(),
                dither_method.into(),
                measure_error.to_magick()) } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Reduce the number of colors in the images.
    pub fn quantize_images(
        &self,
        number_of_colors: usize,
        colorspace: ColorspaceType,
        tree_depth: usize,
        dither_method: DitherMethod,
        measure_error: bool) -> Result<()> {
        match unsafe { bindings::MagickQuantizeImages(
                self.wand,
                number_of_colors.into(),
                colorspace.into(),
                tree_depth.into(),
                dither_method.into(),
                measure_error.to_magick()) } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Applies an arithmetic, relational, or logical expression to an image. Use these operators
    /// to lighten or darken an image, to increase or decrease contrast in an image, or to produce
    /// the "negative" of an image.
    ///
    /// * `function`: the image function.
    /// * `args`: the function arguments.
    ///
    /// # Example
    ///
    /// This example show how you can apply smoothstep function (a polynomial `-2x^3 + 3x^2`) to
    /// every image pixel.
    ///
    /// ```
    /// use magick_rust::{MagickWand, PixelWand, MagickFunction};
    ///
    /// fn main() -> Result<(), magick_rust::MagickError> {
    ///     let mut wand1 = MagickWand::new();
    ///     wand1.new_image(4, 4, &PixelWand::new())?; // Replace with `read_image` to open your image file
    ///
    ///     // Apply smoothstep polynomial
    ///     wand1.function_image(MagickFunction::Polynomial, &[-2.0, 3.0, 0.0, 0.0])?;
    ///
    ///     Ok(())
    /// }
    /// ```
    pub fn function_image(
        &self,
        function: MagickFunction,
        args: &[f64]
    ) -> Result<()> {
        let num_of_args: size_t = args.len().into();
        match unsafe {
            bindings::MagickFunctionImage(
                self.wand,
                function.into(),
                num_of_args,
                args.as_ptr()
            )
        } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Returns an image where each pixel is the sum of the pixels in the image sequence after
    /// applying its corresponding terms (coefficient and degree pairs).
    ///
    /// * `terms`: the list of polynomial coefficients and degree pairs and a constant.
    pub fn polynomial_image(&self, terms: &[f64]) -> Result<()> {
        if terms.len() & 1 != 1 {
            return Err(MagickError("no constant coefficient given".to_string()));
        }
        let num_of_terms: size_t = (terms.len() >> 1).into();
        match unsafe {
            bindings::MagickPolynomialImage(
                self.wand,
                num_of_terms,
                terms.as_ptr()
            )
        } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Applies a custom convolution kernel to the image.
    ///
    /// * `kernel_info`: An array of doubles representing the convolution kernel.
    pub fn convolve_image(&self, kernel_info: &KernelInfo) -> Result<()> {
        match unsafe {
            bindings::MagickConvolveImage(
                self.wand,
                kernel_info.get_ptr()
            )
        } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Applies a user supplied kernel to the image according to the given morphology method.
    ///
    /// * `morphology_method`: the morphology method to be applied.
    /// * `iterations`: apply the operation this many times (or no change). A value of -1 means loop until no change found. How this is applied may depend on the morphology method. Typically this is a value of 1.
    /// * `kernel_info`: An array of doubles representing the morphology kernel.
    pub fn morphology_image(
        &self,
        morphology_method: MorphologyMethod,
        iterations: isize,
        kernel_info: &KernelInfo
    ) -> Result<()> {
        match unsafe {
            bindings::MagickMorphologyImage(
                self.wand,
                morphology_method.into(),
                iterations.into(),
                kernel_info.get_ptr()
            )
        } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Apply color transformation to an image. The method permits saturation changes, hue rotation,
    /// luminance to alpha, and various other effects. Although variable-sized transformation
    /// matrices can be used, typically one uses a 5x5 matrix for an RGBA image and a 6x6 for CMYKA
    /// (or RGBA with offsets). The matrix is similar to those used by Adobe Flash except offsets
    /// are in column 6 rather than 5 (in support of CMYKA images) and offsets are normalized
    /// (divide Flash offset by 255).
    ///
    /// * `color_matrix`: the color matrix.
    pub fn color_matrix_image(&self, color_matrix: &KernelInfo) -> Result<()> {
        match unsafe {
            bindings::MagickColorMatrixImage(
                self.wand,
                color_matrix.get_ptr()
            )
        } {
            MagickTrue => Ok(()),
            _ => Err(MagickError(self.get_exception()?.0)),
        }
    }

    /// Applies a channel expression to the specified image. The expression
    /// consists of one or more channels, either mnemonic or numeric (e.g. red, 1), separated by
    /// actions as follows:
    ///
    /// <=> exchange two channels (e.g. red<=>blue) => transfer a channel to another (e.g.
    /// red=>green) , separate channel operations (e.g. red, green) | read channels from next input
    /// image (e.g. red | green) ; write channels to next output image (e.g. red; green; blue) A
    /// channel without a operation symbol implies extract. For example, to create 3 grayscale
    /// images from the red, green, and blue channels of an image, use:
    ///
    /// * `expression`: the expression.
    pub fn channel_fx_image(&self, expression: &str) -> Result<MagickWand> {
        let c_expression = CString::new(expression).map_err(|_| "artifact string contains null byte")?;

        let result = unsafe {
            bindings::MagickChannelFxImage(
                self.wand,
                c_expression.as_ptr()
            )
        };

        return if result.is_null() {
            Err(MagickError(self.get_exception()?.0))
        } else {
            Ok(MagickWand{ wand: result })
        };
    }

    /// Combines one or more images into a single image. The grayscale value of the pixels of each
    /// image in the sequence is assigned in order to the specified channels of the combined image.
    /// The typical ordering would be image 1 => Red, 2 => Green, 3 => Blue, etc.
    ///
    /// * `colorspace`: the colorspace.
    pub fn combine_images(&self, colorspace: ColorspaceType) -> Result<MagickWand> {
        let result = unsafe {
            bindings::MagickCombineImages(self.wand, colorspace.into())
        };

        return if result.is_null() {
            Err(MagickError(self.get_exception()?.0))
        } else {
            Ok(MagickWand{ wand: result })
        }
    }

    /// Returns the current image from the magick wand.
    pub fn get_image<'wand>(&'wand self) -> Result<Image<'wand>> {
        let result = unsafe {
            bindings::GetImageFromMagickWand(self.wand)
        };

        return if result.is_null() {
            Err(MagickError(self.get_exception()?.0))
        } else {
            unsafe { Ok(Image::new(result)) }
        }
    }

    mutations!(
        /// Sets the image to the specified alpha level.
        MagickSetImageAlpha => set_image_alpha(alpha: f64)

        /// Control the brightness, saturation, and hue of an image
        MagickModulateImage => modulate_image(brightness: f64, saturation: f64, hue: f64)

        /// Control the brightness and contrast
        MagickBrightnessContrastImage => brightness_contrast_image(brightness: f64, contrast: f64)

        /// Set the image alpha channel mode.
        MagickSetImageAlphaChannel => set_image_alpha_channel(alpha_channel: AlphaChannelOption)

        /// Discard all but one of any pixel color.
        MagickUniqueImageColors => unique_image_colors()

        /// Applies k-means color reduction to the image.
        MagickKmeansImage => kmeans(number_colors: usize, max_iterations: usize, tolerance: f64)

        /// Extracts the 'mean' from the image and adjust the image to try make set its gamma appropriately.
        MagickAutoGammaImage => auto_gamma()

        /// Adjusts the levels of a particular image channel by scaling the minimum and maximum values to the full quantum range.
        MagickAutoLevelImage => auto_level()
    );

    get!(get_image_colors, MagickGetImageColors, usize);

    string_set_get!(
        get_filename,                    set_filename,                    MagickGetFilename,                 MagickSetFilename
        get_font,                        set_font,                        MagickGetFont,                     MagickSetFont
        get_format,                      set_format,                      MagickGetFormat,                   MagickSetFormat
        get_image_filename,              set_image_filename,              MagickGetImageFilename,            MagickSetImageFilename
        get_image_format,                set_image_format,                MagickGetImageFormat,              MagickSetImageFormat
    );

    set_get!(
        get_colorspace,                  set_colorspace,                  MagickGetColorspace,               MagickSetColorspace,              ColorspaceType
        get_image_compose,               set_image_compose,               MagickGetImageCompose,             MagickSetImageCompose,            CompositeOperator
        get_compression,                 set_compression,                 MagickGetCompression,              MagickSetCompression,             CompressionType
        get_compression_quality,         set_compression_quality,         MagickGetCompressionQuality,       MagickSetCompressionQuality,      usize
        get_gravity,                     set_gravity,                     MagickGetGravity,                  MagickSetGravity,                 GravityType
        get_image_colorspace,            set_image_colorspace,            MagickGetImageColorspace,          MagickSetImageColorspace,         ColorspaceType
        get_image_compression,           set_image_compression,           MagickGetImageCompression,         MagickSetImageCompression,        CompressionType
        get_image_compression_quality,   set_image_compression_quality,   MagickGetImageCompressionQuality,  MagickSetImageCompressionQuality, usize
        get_image_delay,                 set_image_delay,                 MagickGetImageDelay,               MagickSetImageDelay,              usize
        get_image_depth,                 set_image_depth,                 MagickGetImageDepth,               MagickSetImageDepth,              usize
        get_image_dispose,               set_image_dispose,               MagickGetImageDispose,             MagickSetImageDispose,            DisposeType
        get_image_endian,                set_image_endian,                MagickGetImageEndian,              MagickSetImageEndian,             EndianType
        get_image_fuzz,                  set_image_fuzz,                  MagickGetImageFuzz,                MagickSetImageFuzz,               f64
        get_image_gamma,                 set_image_gamma,                 MagickGetImageGamma,               MagickSetImageGamma,              f64
        get_image_gravity,               set_image_gravity,               MagickGetImageGravity,             MagickSetImageGravity,            GravityType
        get_image_interlace_scheme,      set_image_interlace_scheme,      MagickGetImageInterlaceScheme,     MagickSetImageInterlaceScheme,    InterlaceType
        get_image_interpolate_method,    set_image_interpolate_method,    MagickGetImageInterpolateMethod,   MagickSetImageInterpolateMethod,  PixelInterpolateMethod
        get_image_iterations,            set_image_iterations,            MagickGetImageIterations,          MagickSetImageIterations,         usize
        get_image_orientation,           set_image_orientation,           MagickGetImageOrientation,         MagickSetImageOrientation,        OrientationType
        get_image_rendering_intent,      set_image_rendering_intent,      MagickGetImageRenderingIntent,     MagickSetImageRenderingIntent,    RenderingIntent
        get_image_scene,                 set_image_scene,                 MagickGetImageScene,               MagickSetImageScene,              usize
        get_image_type,                  set_image_type,                  MagickGetImageType,                MagickSetImageType,               ImageType
        get_image_units,                 set_image_units,                 MagickGetImageUnits,               MagickSetImageUnits,              ResolutionType
        get_interlace_scheme,            set_interlace_scheme,            MagickGetInterlaceScheme,          MagickSetInterlaceScheme,         InterlaceType
        get_interpolate_method,          set_interpolate_method,          MagickGetInterpolateMethod,        MagickSetInterpolateMethod,       PixelInterpolateMethod
        get_iterator_index,              set_iterator_index,              MagickGetIteratorIndex,            MagickSetIteratorIndex,           isize
        get_orientation,                 set_orientation,                 MagickGetOrientation,              MagickSetOrientation,             OrientationType
        get_pointsize,                   set_pointsize,                   MagickGetPointsize,                MagickSetPointsize,               f64
        get_type,                        set_type,                        MagickGetType,                     MagickSetType,                    ImageType
    );
}

impl fmt::Debug for MagickWand {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        writeln!(f, "MagickWand {{")?;
        writeln!(f, "    Exception: {:?}", self.get_exception())?;
        writeln!(f, "    IsWand: {:?}", self.is_wand())?;
        self.fmt_string_settings(f, "    ")?;
        self.fmt_checked_settings(f, "    ")?;
        writeln!(f, "}}")
    }
}