<?php
/**
 * Background processing: new uploads and the bulk optimizer.
 *
 * An attachment is waiting when its status is "queued", or, while a bulk run
 * is active, when it has no status at all. Work is done in short slices by
 * WP-Cron, and also by the bulk screen while it is open.
 *
 * @package LeanPixel
 */

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

class LeanPixel_Queue {

	const HOOK        = 'leanpixel_run_queue';
	const BULK_OPTION = 'leanpixel_bulk_running';
	const PAUSE       = 'leanpixel_pause';
	const LOCK        = 'leanpixel_lock';

	public static function init() {
		add_action( self::HOOK, array( __CLASS__, 'cron' ) );
		add_filter( 'wp_generate_attachment_metadata', array( __CLASS__, 'on_upload' ), 20, 3 );
		add_action( 'update_option_' . LeanPixel_Settings::OPTION, array( __CLASS__, 'on_settings_change' ), 10, 2 );
	}

	/**
	 * A hold placed by one way of working (a quota, a missing image library)
	 * does not apply to the other, so it is lifted when the mode changes.
	 *
	 * @param mixed $old Settings before the change.
	 * @param mixed $new Settings after the change.
	 */
	public static function on_settings_change( $old, $new ) {
		if ( empty( $old['local'] ) !== empty( $new['local'] ) ) {
			delete_option( self::PAUSE );
		}
		// New exclude rules: images skipped under the old ones are looked at again.
		$before = isset( $old['skip_rules'] ) ? (string) $old['skip_rules'] : '';
		$after  = isset( $new['skip_rules'] ) ? (string) $new['skip_rules'] : '';
		if ( $before !== $after ) {
			delete_metadata( 'post', 0, LeanPixel_Optimizer::STATUS, 'excluded', true );
		}
	}

	/**
	 * Queue a newly uploaded image.
	 *
	 * @param array  $metadata      Attachment metadata.
	 * @param int    $attachment_id Attachment ID.
	 * @param string $context       'create' for new uploads.
	 * @return array
	 */
	public static function on_upload( $metadata, $attachment_id, $context = 'create' ) {
		if ( 'create' === $context
			&& LeanPixel_Settings::is_ready()
			&& LeanPixel_Settings::get( 'auto_optimize' )
			&& LeanPixel_Optimizer::is_supported( $attachment_id ) ) {
			if ( LeanPixel_Optimizer::is_excluded( $attachment_id ) ) {
				update_post_meta( (int) $attachment_id, LeanPixel_Optimizer::STATUS, 'excluded' );
			} else {
				self::enqueue( $attachment_id );
			}
		}
		return $metadata;
	}

	public static function enqueue( $attachment_id ) {
		update_post_meta( (int) $attachment_id, LeanPixel_Optimizer::STATUS, 'queued' );
		self::schedule( 5 );
	}

	public static function schedule( $delay = 5 ) {
		if ( ! wp_next_scheduled( self::HOOK ) ) {
			wp_schedule_single_event( time() + max( 1, (int) $delay ), self::HOOK );
		}
	}

	public static function is_bulk_running() {
		return (bool) get_option( self::BULK_OPTION );
	}

	public static function start_bulk() {
		update_option( self::BULK_OPTION, 1, false );
		delete_option( self::PAUSE );
		self::schedule( 5 );
	}

	public static function stop_bulk() {
		delete_option( self::BULK_OPTION );
		delete_option( self::PAUSE );
	}

	/** Give failed images another try. */
	public static function retry_failed() {
		delete_metadata( 'post', 0, LeanPixel_Optimizer::STATUS, 'error', true );
	}

	/** @return array|false { code, message, until } while processing is on hold. */
	public static function pause_state() {
		$pause = get_option( self::PAUSE );
		return ( is_array( $pause ) && isset( $pause['until'] ) ) ? $pause : false;
	}

	/**
	 * Take a named lock. add_option() is a single INSERT on a unique key, so
	 * two requests can never both get it. A lock older than $ttl seconds was
	 * left by a request that died and is taken over.
	 *
	 * @param string $name Lock name.
	 * @param int    $ttl  Seconds after which a lock counts as abandoned.
	 * @return bool
	 */
	public static function lock( $name, $ttl ) {
		$option = self::LOCK . '_' . $name;
		if ( add_option( $option, time(), '', false ) ) {
			return true;
		}
		$since = (int) get_option( $option );
		if ( $since && time() - $since < $ttl ) {
			return false;
		}
		delete_option( $option );
		return add_option( $option, time(), '', false );
	}

	public static function unlock( $name ) {
		delete_option( self::LOCK . '_' . $name );
	}

	public static function cron() {
		self::run( 20 );
	}

	/**
	 * Work through the queue for up to $seconds.
	 *
	 * @param int $seconds Time budget.
	 * @return string 'idle' | 'working' | 'paused' | 'busy'
	 */
	public static function run( $seconds ) {
		if ( ! LeanPixel_Settings::is_ready() ) {
			return 'idle';
		}

		$pause = self::pause_state();
		if ( $pause ) {
			if ( time() < (int) $pause['until'] ) {
				return 'paused';
			}
			delete_option( self::PAUSE );
		}

		if ( ! self::lock( 'queue', 3 * MINUTE_IN_SECONDS ) ) {
			self::schedule( 30 );
			return 'busy';
		}

		if ( function_exists( 'set_time_limit' ) ) {
			@set_time_limit( 180 ); // phpcs:ignore WordPress.PHP.NoSilencedErrors.Discouraged, Squiz.PHP.DiscouragedFunctions.Discouraged -- best effort.
		}
		wp_raise_memory_limit( 'image' );

		$deadline = microtime( true ) + $seconds;
		$state    = 'idle';

		while ( true ) {
			$id = self::next_id();
			if ( ! $id ) {
				delete_option( self::BULK_OPTION );
				break;
			}
			$state  = 'working';
			$result = LeanPixel_Optimizer::optimize_attachment( $id, $deadline );

			if ( is_wp_error( $result ) ) {
				self::pause( $result );
				$state = 'paused';
				break;
			}
			if ( 'partial' === $result || 'locked' === $result || microtime( true ) > $deadline ) {
				break;
			}
		}

		self::unlock( 'queue' );

		if ( 'working' === $state && self::next_id() ) {
			self::schedule( 5 );
		} elseif ( 'working' === $state ) {
			$state = 'idle';
			delete_option( self::BULK_OPTION );
		}
		return $state;
	}

	/**
	 * Put the queue on hold after an error that would hit every image.
	 *
	 * @param WP_Error $error The error.
	 */
	private static function pause( WP_Error $error ) {
		$code = $error->get_error_code();
		switch ( $code ) {
			case 'rate_limited':
				$wait = MINUTE_IN_SECONDS;
				break;
			case 'quota_exceeded':
				$wait = HOUR_IN_SECONDS;
				break;
			case 'invalid_key':
			case 'key_suspended':
			case 'site_limit':
			case 'site_unverified':
			case 'not_connected':
				$wait = YEAR_IN_SECONDS; // Needs the site owner; cleared when they reconnect or press Start.
				break;
			default:
				$wait = 5 * MINUTE_IN_SECONDS;
		}
		update_option(
			self::PAUSE,
			array(
				'code'    => $code,
				'message' => $error->get_error_message(),
				'until'   => time() + $wait,
			),
			false
		);
		if ( $wait < YEAR_IN_SECONDS ) {
			wp_clear_scheduled_hook( self::HOOK );
			wp_schedule_single_event( time() + $wait, self::HOOK );
		}
	}

	/** @return int ID of the next attachment to process, or 0. */
	public static function next_id() {
		$meta_query = array(
			'relation' => 'OR',
			array(
				'key'   => LeanPixel_Optimizer::STATUS,
				'value' => 'queued',
			),
		);
		if ( self::is_bulk_running() ) {
			$meta_query[] = array(
				'key'     => LeanPixel_Optimizer::STATUS,
				'compare' => 'NOT EXISTS',
			);
		}

		$ids = get_posts(
			array(
				'post_type'        => 'attachment',
				'post_status'      => 'inherit',
				'post_mime_type'   => LeanPixel_Optimizer::mimes(),
				'posts_per_page'   => 1,
				'fields'           => 'ids',
				'orderby'          => 'ID',
				'order'            => 'DESC',
				'no_found_rows'    => true,
				'meta_query'       => $meta_query, // phpcs:ignore WordPress.DB.SlowDBQuery.slow_db_query_meta_query -- one row.
			)
		);
		return $ids ? (int) $ids[0] : 0;
	}

	/**
	 * Numbers for the bulk screen.
	 *
	 * @return array { total, optimized, error, queued, restored, excluded, remaining }
	 */
	public static function counts() {
		global $wpdb;

		$total = 0;
		$mimes = (array) wp_count_attachments();
		foreach ( LeanPixel_Optimizer::mimes() as $mime ) {
			$total += isset( $mimes[ $mime ] ) ? (int) $mimes[ $mime ] : 0;
		}

		$counts = array(
			'total'     => $total,
			'optimized' => 0,
			'error'     => 0,
			'queued'    => 0,
			'restored'  => 0,
			'excluded'  => 0,
		);

		// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- live progress numbers.
		$rows = $wpdb->get_results(
			$wpdb->prepare(
				"SELECT pm.meta_value AS status, COUNT(*) AS n
				 FROM {$wpdb->postmeta} pm
				 INNER JOIN {$wpdb->posts} p ON p.ID = pm.post_id AND p.post_type = 'attachment'
				 WHERE pm.meta_key = %s
				 GROUP BY pm.meta_value",
				LeanPixel_Optimizer::STATUS
			)
		);
		foreach ( (array) $rows as $row ) {
			if ( isset( $counts[ $row->status ] ) ) {
				$counts[ $row->status ] = (int) $row->n;
			}
		}

		$counts['remaining'] = max( 0, $total - $counts['optimized'] - $counts['error'] - $counts['restored'] - $counts['excluded'] );
		return $counts;
	}
}