<?php

/**

 * WordPress GD Image Editor

 *

 * @package WordPress

 * @subpackage Image_Editor

 */

/**

 * WordPress Image Editor Class for Image Manipulation through GD

 *

 * @since 3.5.0

 *

 * @see WP_Image_Editor

 */

class WP_Image_Editor_GD extends WP_Image_Editor {

	/**

	 * GD Resource.

	 *

	 * @var resource|GdImage

	 */

	protected $image;

	public function __destruct() {

		if ( $this->image ) {

			// We don't need the original in memory anymore.

			imagedestroy( $this->image );

		}

	}

	/**

	 * Checks to see if current environment supports GD.

	 *

	 * @since 3.5.0

	 *

	 * @param array $args

	 * @return bool

	 */

	public static function test( $args = array() ) {

		if ( ! extension_loaded( 'gd' ) || ! function_exists( 'gd_info' ) ) {

			return false;

		}

		// On some setups GD library does not provide imagerotate() - Ticket #11536.

		if ( isset( $args['methods'] ) &&

			in_array( 'rotate', $args['methods'], true ) &&

			! function_exists( 'imagerotate' ) ) {

				return false;

		}

		return true;

	}

	/**

	 * Checks to see if editor supports the mime-type specified.

	 *

	 * @since 3.5.0

	 *

	 * @param string $mime_type

	 * @return bool

	 */

	public static function supports_mime_type( $mime_type ) {

		$image_types = imagetypes();

		switch ( $mime_type ) {

			case 'image/jpeg':

			case 'image/png':

			case 'image/gif':

			case 'image/webp':

		}

		return false;

	}

	/**

	 * Loads image from $this->file into new GD Resource.

	 *

	 * @since 3.5.0

	 *

	 * @return true|WP_Error True if loaded successfully; WP_Error on failure.

	 */

	public function load() {

		if ( $this->image ) {

			return true;

		}

		if ( ! is_file( $this->file ) && ! preg_match( '|^https?://|', $this->file ) ) {

			return new WP_Error( 'error_loading_image', __( 'File does not exist?' ), $this->file );

		}

		// Set artificially high because GD uses uncompressed images in memory.

		wp_raise_memory_limit( 'image' );

		$file_contents = @file_get_contents( $this->file );

		if ( ! $file_contents ) {

			return new WP_Error( 'error_loading_image', __( 'File does not exist?' ), $this->file );

		}

		// WebP may not work with imagecreatefromstring().

		if (

			function_exists( 'imagecreatefromwebp' ) &&

			( 'image/webp' === wp_get_image_mime( $this->file ) )

		) {

			$this->image = @imagecreatefromwebp( $this->file );

		} else {

			$this->image = @imagecreatefromstring( $file_contents );

		}

		if ( ! is_gd_image( $this->image ) ) {

			return new WP_Error( 'invalid_image', __( 'File is not an image.' ), $this->file );

		}

		$size = wp_getimagesize( $this->file );

		if ( ! $size ) {

			return new WP_Error( 'invalid_image', __( 'Could not read image size.' ), $this->file );

		}

		if ( function_exists( 'imagealphablending' ) && function_exists( 'imagesavealpha' ) ) {

			imagealphablending( $this->image, false );

			imagesavealpha( $this->image, true );

		}

		$this->update_size( $size[0], $size[1] );

		$this->mime_type = $size['mime'];

		return $this->set_quality();

	}

	/**

	 * Sets or updates current image size.

	 *

	 * @since 3.5.0

	 *

	 * @param int $width

	 * @param int $height

	 * @return true

	 */

	protected function update_size( $width = false, $height = false ) {

		if ( ! $width ) {

			$width = imagesx( $this->image );

		}

		if ( ! $height ) {

			$height = imagesy( $this->image );

		}

		return parent::update_size( $width, $height );

	}

	/**

	 * Resizes current image.

	 *

	 * Wraps `::_resize()` which returns a GD resource or GdImage instance.

	 *

	 * At minimum, either a height or width must be provided. If one of the two is set

	 * to null, the resize will maintain aspect ratio according to the provided dimension.

	 *

	 * @since 3.5.0

	 *

	 * @return true|WP_Error

	 */

	public function resize( $max_w, $max_h, $crop = false ) {

			return true;

		}

		$resized = $this->_resize( $max_w, $max_h, $crop );

		if ( is_gd_image( $resized ) ) {

			imagedestroy( $this->image );

			$this->image = $resized;

			return true;

		} elseif ( is_wp_error( $resized ) ) {

			return $resized;

		}

		return new WP_Error( 'image_resize_error', __( 'Image resize failed.' ), $this->file );

	}

	/**

	 * @param int        $max_w

	 * @param int        $max_h

	 * @return resource|GdImage|WP_Error

	 */

	protected function _resize( $max_w, $max_h, $crop = false ) {

		$dims = image_resize_dimensions( $this->size['width'], $this->size['height'], $max_w, $max_h, $crop );

		if ( ! $dims ) {

			return new WP_Error( 'error_getting_dimensions', __( 'Could not calculate resized image dimensions' ), $this->file );

		}

		list( $dst_x, $dst_y, $src_x, $src_y, $dst_w, $dst_h, $src_w, $src_h ) = $dims;

		$resized = wp_imagecreatetruecolor( $dst_w, $dst_h );

		imagecopyresampled( $resized, $this->image, $dst_x, $dst_y, $src_x, $src_y, $dst_w, $dst_h, $src_w, $src_h );

		if ( is_gd_image( $resized ) ) {

			$this->update_size( $dst_w, $dst_h );

			return $resized;

		}

		return new WP_Error( 'image_resize_error', __( 'Image resize failed.' ), $this->file );

	}

	/**

	 * Create multiple smaller images from a single source.

	 *

	 * Attempts to create all sub-sizes and returns the meta data at the end. This

	 * may result in the server running out of resources. When it fails there may be few

	 * "orphaned" images left over as the meta data is never returned and saved.

	 *

	 * As of 5.3.0 the preferred way to do this is with `make_subsize()`. It creates

	 * the new images one at a time and allows for the meta data to be saved after

	 * each new image is created.

	 *

	 * @since 3.5.0

	 *

	 * @param array $sizes {

	 *     An array of image size data arrays.

	 *

	 *     Either a height or width must be provided.

	 *     If one of the two is set to null, the resize will

	 *     maintain aspect ratio according to the source image.

	 *

	 *     @type array ...$0 {

	 *         Array of height, width values, and whether to crop.

	 *

	 *     }

	 * }

	 * @return array An array of resized images' metadata by size.

	 */

	public function multi_resize( $sizes ) {

		$metadata = array();

		foreach ( $sizes as $size => $size_data ) {

			$meta = $this->make_subsize( $size_data );

			if ( ! is_wp_error( $meta ) ) {

				$metadata[ $size ] = $meta;

			}

		}

		return $metadata;

	}

	/**

	 * Create an image sub-size and return the image meta data value for it.

	 *

	 * @since 5.3.0

	 *

	 * @param array $size_data {

	 *     Array of size data.

	 *

	 * }

	 * @return array|WP_Error The image data array for inclusion in the `sizes` array in the image meta,

	 *                        WP_Error object on error.

	 */

	public function make_subsize( $size_data ) {

		if ( ! isset( $size_data['width'] ) && ! isset( $size_data['height'] ) ) {

			return new WP_Error( 'image_subsize_create_error', __( 'Cannot resize the image. Both width and height are not set.' ) );

		}

		$orig_size = $this->size;

		if ( ! isset( $size_data['width'] ) ) {

			$size_data['width'] = null;

		}

		if ( ! isset( $size_data['height'] ) ) {

			$size_data['height'] = null;

		}

		if ( ! isset( $size_data['crop'] ) ) {

			$size_data['crop'] = false;

		}

		$resized = $this->_resize( $size_data['width'], $size_data['height'], $size_data['crop'] );

		if ( is_wp_error( $resized ) ) {

			$saved = $resized;

		} else {

			$saved = $this->_save( $resized );

			imagedestroy( $resized );

		}

		$this->size = $orig_size;

		if ( ! is_wp_error( $saved ) ) {

			unset( $saved['path'] );

		}

		return $saved;

	}

	/**

	 * Crops Image.

	 *

	 * @since 3.5.0

	 *

	 * @param int  $src_x   The start x position to crop from.

	 * @param int  $src_y   The start y position to crop from.

	 * @param int  $src_w   The width to crop.

	 * @param int  $src_h   The height to crop.

	 * @param int  $dst_w   Optional. The destination width.

	 * @param int  $dst_h   Optional. The destination height.

	 * @param bool $src_abs Optional. If the source crop points are absolute.

	 * @return true|WP_Error

	 */

	public function crop( $src_x, $src_y, $src_w, $src_h, $dst_w = null, $dst_h = null, $src_abs = false ) {

		if ( ! $dst_w ) {

			$dst_w = $src_w;

		}

		if ( ! $dst_h ) {

			$dst_h = $src_h;

		}

		foreach ( array( $src_w, $src_h, $dst_w, $dst_h ) as $value ) {

			if ( ! is_numeric( $value ) || (int) $value <= 0 ) {

				return new WP_Error( 'image_crop_error', __( 'Image crop failed.' ), $this->file );

			}

		}

		$dst = wp_imagecreatetruecolor( (int) $dst_w, (int) $dst_h );

		if ( $src_abs ) {

			$src_w -= $src_x;

			$src_h -= $src_y;

		}

		if ( function_exists( 'imageantialias' ) ) {

			imageantialias( $dst, true );

		}

		imagecopyresampled( $dst, $this->image, 0, 0, (int) $src_x, (int) $src_y, (int) $dst_w, (int) $dst_h, (int) $src_w, (int) $src_h );

		if ( is_gd_image( $dst ) ) {

			imagedestroy( $this->image );

			$this->image = $dst;

			$this->update_size();

			return true;

		}

		return new WP_Error( 'image_crop_error', __( 'Image crop failed.' ), $this->file );

	}

	/**

	 * Rotates current image counter-clockwise by $angle.

	 * Ported from image-edit.php

	 *

	 * @since 3.5.0

	 *

	 * @param float $angle

	 * @return true|WP_Error

	 */

	public function rotate( $angle ) {

		if ( function_exists( 'imagerotate' ) ) {

			$transparency = imagecolorallocatealpha( $this->image, 255, 255, 255, 127 );

			$rotated      = imagerotate( $this->image, $angle, $transparency );

			if ( is_gd_image( $rotated ) ) {