<?php
/**
 * Prepare placeholder and lazy load.
 *
 * @package visual-portfolio/images
 */

if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

/**
 * Class Visual_Portfolio_Images
 */
class Visual_Portfolio_Images {
	/**
	 * When image process in progress with method get_attachment_image, this variable will be 'true'.
	 *
	 * @var bool
	 */
	public static $image_processing = false;

	/**
	 * Allow Visual Portfolio images to use lazyload.
	 *
	 * @var bool
	 */
	public static $allow_vp_lazyload = false;

	/**
	 * Allow WordPress images to use lazyload.
	 *
	 * @var bool
	 */
	public static $allow_wp_lazyload = false;

	/**
	 * The list of exclusions from the plugin settings.
	 *
	 * @var array
	 */
	public static $lazyload_user_exclusions = array();

	/**
	 * Visual_Portfolio_Images constructor.
	 */
	public static function construct() {
		add_action( 'wp', 'Visual_Portfolio_Images::init_lazyload' );
		add_action( 'after_setup_theme', 'Visual_Portfolio_Images::add_image_sizes' );
		add_filter( 'image_size_names_choose', 'Visual_Portfolio_Images::image_size_names_choose' );

		/**
		 * Allow `data:` inside image src attribute.
		 * Don't place this hook inside the `wp` hook.
		 *
		 * @link https://wordpress.org/support/topic/lazy-load-404-error-with-image-like-png/#post-16439422
		 */
		add_filter( 'kses_allowed_protocols', 'Visual_Portfolio_Images::kses_allowed_protocols', 15 );
	}

	/**
	 * Add image sizes.
	 */
	public static function add_image_sizes() {
		$sm       = Visual_Portfolio_Settings::get_option( 'sm', 'vp_images' );
		$md       = Visual_Portfolio_Settings::get_option( 'md', 'vp_images' );
		$lg       = Visual_Portfolio_Settings::get_option( 'lg', 'vp_images' );
		$xl       = Visual_Portfolio_Settings::get_option( 'xl', 'vp_images' );
		$sm_popup = Visual_Portfolio_Settings::get_option( 'sm_popup', 'vp_images' );
		$md_popup = Visual_Portfolio_Settings::get_option( 'md_popup', 'vp_images' );
		$xl_popup = Visual_Portfolio_Settings::get_option( 'xl_popup', 'vp_images' );

		// custom image sizes.
		add_image_size( 'vp_sm', $sm, 9999 );
		add_image_size( 'vp_md', $md, 9999 );
		add_image_size( 'vp_lg', $lg, 9999 );
		add_image_size( 'vp_xl', $xl, 9999 );
		add_image_size( 'vp_sm_popup', $sm_popup, 9999 );
		add_image_size( 'vp_md_popup', $md_popup, 9999 );
		add_image_size( 'vp_xl_popup', $xl_popup, 9999 );
	}

	/**
	 * Custom image sizes
	 *
	 * @param array $sizes - registered image sizes.
	 *
	 * @return array
	 */
	public static function image_size_names_choose( $sizes ) {
		return array_merge(
			$sizes,
			array(
				'vp_sm' => esc_html__( 'Small (VP)', 'visual-portfolio' ),
				'vp_md' => esc_html__( 'Medium (VP)', 'visual-portfolio' ),
				'vp_lg' => esc_html__( 'Large (VP)', 'visual-portfolio' ),
				'vp_xl' => esc_html__( 'Extra Large (VP)', 'visual-portfolio' ),
			)
		);
	}

	/**
	 * Get blocked attributes to prevent our images lazy loading.
	 */
	public static function get_image_blocked_attributes() {
		$blocked_attributes = array(
			'data-skip-lazy',
			'data-no-lazy',
			'data-src',
			'data-srcset',
			'data-lazy-original',
			'data-lazy-src',
			'data-lazysrc',
			'data-lazyload',
			'data-bgposition',
			'data-envira-src',
			'fullurl',
			'lazy-slider-img',
		);

		/**
		 * Allow plugins and themes to tell lazy images to skip an image with a given attribute.
		 */
		return apply_filters( 'vpf_lazyload_images_blocked_attributes', $blocked_attributes );
	}

	/**
	 * Init Lazyload
	 */
	public static function init_lazyload() {
		// Don't lazy load for feeds, previews and admin side.
		if ( is_feed() || is_preview() || is_admin() ) {
			return;
		}

		// Don't add on AMP endpoint.
		if ( function_exists( 'is_amp_endpoint' ) && is_amp_endpoint() ) {
			return;
		}

		// Disable using filter.
		// Same filter used in `class-assets.php`.
		if ( ! apply_filters( 'vpf_images_lazyload', true ) ) {
			return;
		}

		self::$allow_vp_lazyload = ! ! Visual_Portfolio_Settings::get_option( 'lazy_loading', 'vp_images' );
		self::$allow_wp_lazyload = 'full' === Visual_Portfolio_Settings::get_option( 'lazy_loading', 'vp_images' );

		// Check for plugin settings.
		if ( ! self::$allow_vp_lazyload && ! self::$allow_wp_lazyload ) {
			return;
		}

		$lazyload_exclusions = Visual_Portfolio_Settings::get_option( 'lazy_loading_excludes', 'vp_images' );
		if ( $lazyload_exclusions ) {
			self::$lazyload_user_exclusions = explode( "\n", $lazyload_exclusions );

			add_filter( 'vpf_lazyload_skip_image_with_attributes', 'Visual_Portfolio_Images::add_lazyload_exclusions', 10, 2 );
		}

		if ( self::$allow_wp_lazyload ) {
			add_filter( 'the_content', 'Visual_Portfolio_Images::add_image_placeholders', 9999 );
			add_filter( 'post_thumbnail_html', 'Visual_Portfolio_Images::add_image_placeholders', 9999 );
			add_filter( 'get_avatar', 'Visual_Portfolio_Images::add_image_placeholders', 9999 );
			add_filter( 'widget_text', 'Visual_Portfolio_Images::add_image_placeholders', 9999 );
			add_filter( 'get_image_tag', 'Visual_Portfolio_Images::add_image_placeholders', 9999 );
		}

		add_action( 'wp_kses_allowed_html', 'Visual_Portfolio_Images::allow_lazy_attributes' );
		add_action( 'wp_head', 'Visual_Portfolio_Images::add_nojs_fallback' );
	}

	/**
	 * Get the URL of an image attachment.
	 *
	 * @param int          $attachment_id Image attachment ID.
	 * @param string|array $size          Optional. Image size to retrieve. Accepts any valid image size, or an array
	 *                                    of width and height values in pixels (in that order). Default 'thumbnail'.
	 * @param bool         $icon          Optional. Whether the image should be treated as an icon. Default false.
	 *
	 * @return string|false Attachment URL or false if no image is available.
	 */
	public static function wp_get_attachment_image_url( $attachment_id, $size = 'thumbnail', $icon = false ) {
		$mime_type = get_post_mime_type( $attachment_id );

		// Prevent usage of resized GIFs, since GIFs animated only in full size.
		if ( $mime_type && 'image/gif' === $mime_type ) {
			$size = 'full';
		}

		return wp_get_attachment_image_url( $attachment_id, $size, $icon );
	}

	/**
	 * Allow attributes of Lazy Load for wp_kses.
	 *
	 * @param array $allowed_tags The allowed tags and their attributes.
	 *
	 * @return array
	 */
	public static function allow_lazy_attributes( $allowed_tags ) {
		if ( ! isset( $allowed_tags['img'] ) ) {
			return $allowed_tags;
		}

		// But, if images are allowed, ensure that our attributes are allowed!
		$img_attributes = array_merge(
			$allowed_tags['img'],
			array(
				'data-src'     => 1,
				'data-sizes'   => 1,
				'data-srcset'  => 1,
				'data-no-lazy' => 1,
				'loading'      => 1,
			)
		);

		$allowed_tags['img'] = $img_attributes;

		return $allowed_tags;
	}

	/**
	 * Fix img src attribute correction in wp_kses.
	 *
	 * @param array $protocols protocols array.
	 *
	 * @return array
	 */
	public static function kses_allowed_protocols( $protocols ) {
		$protocols[] = 'data';
		return $protocols;
	}

	/**
	 * Add image placeholders.
	 *
	 * @param string $content Content.
	 * @return string
	 */
	public static function add_image_placeholders( $content ) {
		// This is a pretty simple regex, but it works.
		//
		// 1. Find <img> tags
		// 2. Exclude tags, placed inside <noscript>.
		$content = preg_replace_callback( '#(?<!noscript\>)<(img)([^>]+?)(>(.*?)</\\1>|[\/]?>)#si', 'Visual_Portfolio_Images::process_image', $content );

		return $content;
	}

	/**
	 * Returns true when a given array of attributes contains attributes or class signifying lazy images.
	 * should not process the image.
	 *
	 * @param array $attributes all available image attributes.
	 *
	 * @return bool
	 */
	public static function should_skip_image_with_blocked_attributes( $attributes ) {
		// Check for blocked classes.
		if ( ! empty( $attributes['class'] ) ) {
			$blocked_classes = array(
				'lazy',
				'lazyload',
				'lazy-load',
				'skip-lazy',
				'no-lazy',
				'gazette-featured-content-thumbnail',
			);

			/**
			 * Allow plugins and themes to tell lazy images to skip an image with a given class.
			 */
			$blocked_classes = apply_filters( 'vpf_lazyload_images_blocked_classes', $blocked_classes );

			if ( is_array( $blocked_classes ) && ! empty( $blocked_classes ) ) {
				foreach ( $blocked_classes as $class ) {
					if ( false !== strpos( $attributes['class'], $class ) ) {
						return true;
					}
				}
			}
		}

		// Check for blocked src.
		if ( ! empty( $attributes['src'] ) ) {
			$blocked_src = array(
				'/wpcf7_captcha/',
				'timthumb.php?src',
			);

			/**
			 * Allow plugins and themes to tell lazy images to skip an image with a given class.
			 */
			$blocked_src = apply_filters( 'vpf_lazyload_images_blocked_src', $blocked_src );

			if ( is_array( $blocked_src ) && ! empty( $blocked_src ) ) {
				foreach ( $blocked_src as $src ) {
					if ( false !== strpos( $attributes['src'], $src ) ) {
						return true;
					}
				}
			}
		}

		$blocked_attributes = self::get_image_blocked_attributes();

		foreach ( $blocked_attributes as $attr ) {
			if ( isset( $attributes[ $attr ] ) ) {
				return true;
			}
		}

		/**
		 * Allow plugins and themes to conditionally skip processing an image via its attributes.
		 */
		if ( apply_filters( 'vpf_lazyload_skip_image_with_attributes', false, $attributes ) ) {
			return true;
		}

		return false;
	}

	/**
	 * Skip lazy loading using exclusion settings.
	 *
	 * @param boolean $return - default return value.
	 * @param array   $attributes - image attributes.
	 *
	 * @return boolean
	 */
	public static function add_lazyload_exclusions( $return, $attributes ) {
		if ( ! empty( self::$lazyload_user_exclusions ) && ! empty( $attributes ) ) {
			$full_attributes_string = '';

			foreach ( $attributes as $k => $attr ) {
				$full_attributes_string .= ' ' . $k . '="' . $attr . '"';
			}

			foreach ( self::$lazyload_user_exclusions as $exclusion ) {
				if ( $exclusion && false !== strpos( $full_attributes_string, $exclusion ) ) {
					// `true` means - exclude this image from lazy loading.
					return true;
				}
			}
		}

		return $return;
	}

	/**
	 * Processes images in content by acting as the preg_replace_callback.
	 *
	 * @param array $matches Matches.
	 *
	 * @return string The image with updated lazy attributes.
	 */
	public static function process_image( $matches ) {
		$old_attributes_str       = $matches[2];
		$old_attributes_kses_hair = wp_kses_hair( $old_attributes_str, wp_allowed_protocols() );

		$fallback = $matches[0];

		if ( empty( $old_attributes_kses_hair['src'] ) ) {
			return $fallback;
		}

		$old_attributes = self::flatten_kses_hair_data( $old_attributes_kses_hair );

		// Return original image if image is already lazy loaded.
		if ( ! empty( $old_attributes['class'] ) && false !== strpos( $old_attributes['class'], 'vp-lazyload' ) ) {
			return $fallback;
		}

		$new_attributes = self::process_image_attributes( $old_attributes );

		// Return original image if new attributes does not contains the lazyload class.
		if ( empty( $new_attributes['class'] ) || false === strpos( $new_attributes['class'], 'vp-lazyload' ) ) {
			return $fallback;
		}

		// Skip 3rd-party lazy loading from noscript img tag.
		$fallback = str_replace( ' src="', ' data-skip-lazy src="', $fallback );

		$new_attributes_str = self::build_attributes_string( $new_attributes );

		return sprintf( '<noscript>%1$s</noscript><img %2$s>', $fallback, $new_attributes_str );
	}

	/**
	 * Given an array of image attributes, updates the `src`, `srcset`, and `sizes` attributes so
	 * that they load lazily.
	 *
	 * @param array $attributes Attributes.
	 *
	 * @return array The updated image attributes array with lazy load attributes.
	 */
	public static function process_image_attributes( $attributes ) {
		// Skip lazy load from VPF images if option disabled.
		if ( ! self::$allow_vp_lazyload && self::$image_processing ) {
			return $attributes;
		}

		// Skip lazy load from WordPress images if option disabled.
		if ( ! self::$allow_wp_lazyload && ! self::$image_processing ) {
			return $attributes;
		}

		if ( empty( $attributes['src'] ) ) {
			return $attributes;
		}

		if ( self::should_skip_image_with_blocked_attributes( $attributes ) ) {
			return $attributes;
		}

		// Default Placeholder.
		$placeholder   = false;
		$placeholder_w = isset( $attributes['width'] ) ? $attributes['width'] : false;
		$placeholder_h = isset( $attributes['height'] ) ? $attributes['height'] : false;

		// Trying to get image size from metadata.
		if ( ! $placeholder_w || ! $placeholder_h ) {
			$image_id = self::attributes_to_image_id( $attributes );
			$metadata = get_post_meta( $image_id, '_wp_attachment_metadata', true );

			if ( isset( $metadata['width'] ) && isset( $metadata['height'] ) ) {
				$placeholder_w = $metadata['width'];
				$placeholder_h = $metadata['height'];
			}
		}

		if ( $placeholder_w && $placeholder_h ) {
			$placeholder = self::get_image_placeholder( $placeholder_w, $placeholder_h );
		}

		$attributes['data-src'] = $attributes['src'];

		if ( ! empty( $attributes['srcset'] ) ) {
			$attributes['data-srcset'] = $attributes['srcset'];

			if ( $placeholder ) {
				$attributes['srcset'] = $placeholder;
			} else {
				unset( $attributes['srcset'] );
			}

			// In case if the image doesn't have `srcset`, we need to add placeholder to `src`.
		} elseif ( $placeholder ) {
			$attributes['src'] = $placeholder;
		}

		if ( isset( $attributes['sizes'] ) ) {
			unset( $attributes['sizes'] );
		}

		$attributes['data-sizes'] = 'auto';

		// Prevent Native lazy loading.
		$attributes['loading'] = 'eager';

		// Add custom classname.
		$attributes['class']  = empty( $attributes['class'] ) ? '' : ( $attributes['class'] . ' ' );
		$attributes['class'] .= 'vp-lazyload';

		/**
		 * Allow plugins and themes to override the attributes on the image before the content is updated.
		 *
		 * One potential use of this filter is for themes that set `height:auto` on the `img` tag.
		 * With this filter, the theme could get the width and height attributes from the
		 * $attributes array and then add a style tag that sets those values as well, which could
		 * minimize reflow as images load.
		 */
		return apply_filters( 'vpf_lazyload_images_new_attributes', $attributes );
	}

	/**
	 * Get attachment image wrapper.
	 *
	 * @param string|int   $attachment_id attachment image id.
	 * @param string|array $size image size.
	 * @param bool         $icon icon.
	 * @param string|array $attr image attributes.
	 * @param bool         $lazyload DEPRECATED use lazyload tags.
	 *
	 * @return string
	 */
	public static function get_attachment_image( $attachment_id, $size = 'thumbnail', $icon = false, $attr = '', $lazyload = true ) {
		$mime_type = get_post_mime_type( $attachment_id );

		// Prevent usage of resized GIFs, since GIFs animated only in full size.
		if ( $mime_type && 'image/gif' === $mime_type ) {
			$size = 'full';
		}

		self::$image_processing = true;

		$image = apply_filters( 'vpf_wp_get_attachment_image', false, $attachment_id, $size, $attr, $lazyload );

		if ( ! $image && false === strripos( $attachment_id, 'vpf_pro_social' ) ) {
			if ( ! is_array( $attr ) ) {
				$attr = array();
			}
			if ( ! isset( $attr['class'] ) ) {
				$attr['class'] = '';
			}

			// Add class `wp-image-ID` to allow parsers to get current image ID and make manipulations.
			// For example, this class is used in our lazyloading script to determine the image ID.
			$attr['class'] .= ( $attr['class'] ? ' ' : '' ) . 'wp-image-' . $attachment_id;

			$image = wp_get_attachment_image( $attachment_id, $size, $icon, $attr );
		}

		// Maybe prepare lazy load output.
		if ( self::$allow_vp_lazyload ) {
			$image = self::add_image_placeholders( $image );
		}

		self::$image_processing = false;

		return $image;
	}

	/**
	 * Generation placeholder.
	 *
	 * @param int $width  Width of image.
	 * @param int $height Height of image.
	 *
	 * @return string
	 */
	public static function get_image_placeholder( $width = 1, $height = 1 ) {
		if ( ! (int) $width || ! (int) $height ) {
			return false;
		}

		// We need to use base64 to prevent rare cases when users use plugins
		// that replaces http to https in xmlns attribute.
        // phpcs:ignore WordPress.PHP.DiscouragedPHPFunctions.obfuscation_base64_encode
		$placeholder = base64_encode( '<svg width="' . $width . '" height="' . $height . '" viewBox="0 0 ' . $width . ' ' . $height . '" fill="none" xmlns="http://www.w3.org/2000/svg"></svg>' );

		$escape_search  = array( '<', '>', '#', '"' );
		$escape_replace = array( '%3c', '%3e', '%23', '\'' );

		return apply_filters(
			'vpf_lazyload_image_placeholder',
			'data:image/svg+xml;base64,' . str_replace( $escape_search, $escape_replace, $placeholder )
		);
	}

	/**
	 * Flatter KSES hair data.
	 *
	 * @param array $attributes Attributes.
	 *
	 * @return array
	 */
	private static function flatten_kses_hair_data( $attributes ) {
		$flattened_attributes = array();

		foreach ( $attributes as $name => $attribute ) {
			$flattened_attributes[ $name ] = $attribute['value'];
		}

		return $flattened_attributes;
	}

	/**
	 * Build attributes string.
	 *
	 * @param array $attributes Attributes.
	 *
	 * @return string
	 */
	public static function build_attributes_string( $attributes ) {
		$string = array();

		foreach ( $attributes as $name => $value ) {
			if ( '' === $value ) {
				$string[] = sprintf( '%s', $name );
			} else {
				$string[] = sprintf( '%s="%s"', $name, esc_attr( $value ) );
			}
		}

		return implode( ' ', $string );
	}

	/**
	 * Tries to convert an attachment IMG attr into a post object.
	 *
	 * @param array $attributes image attributes.
	 *
	 * @return int|bool
	 */
	private static function attributes_to_image_id( $attributes ) {
		$img_id = false;

		// Get ID from class.
		if ( isset( $attributes['class'] ) && preg_match( '/wp-image-(\d*)/i', $attributes['class'], $match ) ) {
			$img_id = $match[1];
		}

		if ( ! $img_id && isset( $attributes['src'] ) ) {
			// Remove the thumbnail size.
			$src    = preg_replace( '~-[0-9]+x[0-9]+(?=\..{2,6})~', '', $attributes['src'] );
			$img_id = attachment_url_to_postid( $src );

			// Sometimes, when the uploaded image larger than max-size, this image scaled and filename changed to `NAME-scaled.EXT`.
			if ( ! $img_id ) {
				$src    = preg_replace( '~-[0-9]+x[0-9]+(?=\..{2,6})~', '-scaled', $attributes['src'] );
				$img_id = attachment_url_to_postid( $src );
			}
		}

		return $img_id;
	}

	/**
	 * Adds JavaScript to check if the current browser supports JavaScript as well as some styles to hide lazy
	 * images when the browser does not support JavaScript.
	 */
	public static function add_nojs_fallback() {
		?>
		<style type="text/css">
			/* If html does not have either class, do not show lazy loaded images. */
			html:not(.vp-lazyload-enabled):not(.js) .vp-lazyload {
				display: none;
			}
		</style>
		<script>
			document.documentElement.classList.add(
				'vp-lazyload-enabled'
			);
		</script>
		<?php
	}
}
Visual_Portfolio_Images::construct();