<?php
/**
 * Approved-product sync: the run.
 *
 * @package CortexCommerce
 */

namespace CortexCommerce\Sync;

use CortexCommerce\Connect\KeyMinter;
use CortexCommerce\Settings\Flavor;
use CortexCommerce\Settings\Options;
use CortexCommerce\Support\Log;

defined( 'ABSPATH' ) || exit;

/**
 * One mechanism for the hourly timer and the Sync now button (spec §3.1).
 *
 * At most three products at once, by construction: the run's ids sit in one queue, and lane k (0, 1, 2) takes
 * positions k, k+3, k+6… Each product action, when it ends, queues the next action of its own lane and nothing else,
 * so one action per lane exists at any time, whatever Action Scheduler's concurrency, and no product is taken twice.
 *
 * The run goes until nothing is waiting: the last lane to finish queues finish(), which asks what's waiting? again
 * and starts another generation on the same lanes with whatever was approved meanwhile. A product is offered once per
 * run (a failure waits for the next sync). The run has no time budget; it stops early only on disconnect.
 *
 * A product action that dies without reaching its finally (a PHP fatal, max_execution_time, the host killing the
 * process) is picked up from Action Scheduler's failure hooks, which continue that lane in its place, so one fatal
 * never stalls the run until the lock goes stale. SyncProduct's in-flight marker reports the product itself.
 */
final class SyncRun {

	const LANES        = 3;
	const PRODUCT_HOOK = Flavor::HOOK_PREFIX . 'sync_product';
	const FINISH_HOOK  = Flavor::HOOK_PREFIX . 'sync_finish';
	const GROUP        = Flavor::GROUP . '-sync';

	public function register(): void {
		add_action( self::PRODUCT_HOOK, array( self::class, 'run_product' ), 10, 4 );
		add_action( self::FINISH_HOOK, array( self::class, 'finish' ), 10, 2 );
		foreach ( array( 'action_scheduler_unexpected_shutdown', 'action_scheduler_failed_execution', 'action_scheduler_failed_action' ) as $hook ) {
			add_action( $hook, array( self::class, 'action_died' ), 10, 1 );
		}
	}

	/**
	 * @param string $trigger 'hourly' or 'button'.
	 * @return string 'started', 'running', 'up_to_date', 'unreachable', 'no_user' or 'not_connected'.
	 */
	public static function start( string $trigger ): string {
		if ( ! Options::is_connected() || '' === Options::webhook_secret() ) {
			return 'not_connected';
		}
		if ( 0 === self::owner() ) {
			Log::error( 'Approved-product sync not started: the user who connected the store no longer exists or can no longer manage WooCommerce.' );
			return 'no_user';
		}
		$run_id   = wp_generate_uuid4();
		$replaced = null !== SyncLock::held();
		if ( ! SyncLock::acquire( $run_id ) ) {
			return 'running';
		}
		if ( $replaced ) {
			self::unschedule_actions(); // A dead run's leftovers.
		}
		SyncState::begin( $trigger );
		$ids = SyncApi::pending();
		if ( null === $ids ) {
			SyncState::abandon();
			SyncLock::release( $run_id, 0 );
			return 'unreachable';
		}
		if ( array() === $ids ) {
			self::complete( $run_id, 0 );
			return 'up_to_date';
		}
		self::save_queue( $ids );
		SyncState::add_total( count( $ids ) );
		self::launch( $run_id, 0, 0, count( $ids ) );
		return 'started';
	}

	/**
	 * Action Scheduler callback: one product, then this lane's next one.
	 *
	 * @param mixed $run_id   Run id.
	 * @param mixed $gen      Generation.
	 * @param mixed $lane     Lane, 0 to 2.
	 * @param mixed $position Queue position.
	 */
	public static function run_product( $run_id, $gen, $lane, $position ): void {
		$run_id   = (string) $run_id;
		$gen      = (int) $gen;
		$lane     = (int) $lane;
		$position = (int) $position;
		if ( ! Options::is_connected() || ! SyncLock::is_held_by( $run_id, $gen ) ) {
			return; // Disconnected, or a run that was replaced: the chain ends here.
		}
		$queue = self::queue();
		if ( ! isset( $queue['ids'][ $position ] ) ) {
			Log::error( sprintf( 'Approved-product sync: run %s lane %d has no queue position %d; the lane goes on.', $run_id, $lane, $position ) );
			self::next( $run_id, $gen, $lane, $position + self::LANES, $queue['to'] );
			return;
		}
		$product_id = $queue['ids'][ $position ];
		SyncState::lane_working( $lane, $run_id, $gen, (int) $product_id, self::name( $product_id ) );
		$outcome = 'skipped';
		try {
			$outcome = self::as_sync( $product_id, $run_id );
		} catch ( \Throwable $e ) {
			Log::error( sprintf( 'Approved-product sync: product %s stopped with %s.', $product_id, get_class( $e ) ) );
		} finally {
			// Unless a failure hook already moved this lane on (Action Scheduler timed the action out while it ran).
			if ( SyncLock::is_held_by( $run_id, $gen ) && SyncState::is_lane_working_on( $lane, $run_id, $gen, (int) $product_id ) ) {
				SyncState::lane_handled( $lane, $run_id, $gen, (int) $product_id, 'synced' === $outcome ? self::name( $product_id ) : null );
				self::next( $run_id, $gen, $lane, $position + self::LANES, $queue['to'] );
			}
		}
	}

	/**
	 * Action Scheduler failure hooks (unexpected shutdown, failed execution, timed out): when the action that died is
	 * one of this run's product actions and its lane still shows that product, the lane goes on from here. The lane
	 * check keeps a lane from being continued twice: an action that reached its finally has already moved it on.
	 *
	 * @param mixed $action_id Action Scheduler action id.
	 */
	public static function action_died( $action_id ): void {
		$action = \ActionScheduler::store()->fetch_action( (int) $action_id );
		$args   = array_values( $action->get_args() );
		if ( self::PRODUCT_HOOK !== $action->get_hook() || 4 !== count( $args ) ) {
			return;
		}
		list( $run_id, $gen, $lane, $position ) = array( (string) $args[0], (int) $args[1], (int) $args[2], (int) $args[3] );
		if ( ! Options::is_connected() || ! SyncLock::is_held_by( $run_id, $gen ) ) {
			return;
		}
		$queue = self::queue();
		if ( ! isset( $queue['ids'][ $position ] ) || ! SyncState::is_lane_working_on( $lane, $run_id, $gen, (int) $queue['ids'][ $position ] ) ) {
			return;
		}
		Log::error( sprintf( 'Approved-product sync: the process died while writing product %s (action %d); its lane goes on.', $queue['ids'][ $position ], (int) $action_id ) );
		SyncState::lane_handled( $lane, $run_id, $gen, (int) $queue['ids'][ $position ], null );
		self::next( $run_id, $gen, $lane, $position + self::LANES, $queue['to'] );
	}

	/**
	 * Action Scheduler callback, queued by every lane that runs out: the last one to finish goes on.
	 *
	 * @param mixed $run_id Run id.
	 * @param mixed $gen    Generation.
	 */
	public static function finish( $run_id, $gen ): void {
		$run_id = (string) $run_id;
		$gen    = (int) $gen;
		if ( ! SyncLock::is_held_by( $run_id, $gen ) || ! SyncState::lanes_done( $gen, $run_id ) ) {
			return; // A lane still working queues its own finish.
		}
		if ( ! SyncLock::advance( $run_id, $gen ) ) {
			return; // Another finish of this generation won.
		}
		$next  = $gen + 1;
		$queue = self::queue();
		$fresh = Options::is_connected() ? SyncApi::pending() : null;
		$taken = array_flip( $queue['ids'] );
		$new   = array();
		foreach ( null === $fresh ? array() : $fresh as $id ) {
			if ( ! isset( $taken[ $id ] ) ) {
				$new[] = $id;
			}
		}
		if ( array() === $new ) {
			self::complete( $run_id, $next );
			return;
		}
		$ids = array_merge( $queue['ids'], $new );
		self::save_queue( $ids );
		SyncState::add_total( count( $new ) );
		self::launch( $run_id, $next, count( $queue['ids'] ), count( $ids ) );
	}

	/**
	 * Disconnect, deactivation: nothing more is written, nothing is scheduled, nothing shows as running.
	 */
	public static function stop(): void {
		SyncSchedule::unschedule();
		self::unschedule_actions();
		SyncLock::clear();
		SyncState::clear();
		delete_option( Options::SYNC_QUEUE );
	}

	/**
	 * Starts generation $gen on every lane: lane k takes positions $from + k, $from + k + 3, … below $to. Called only
	 * once this run holds the lock for $gen (after acquire() or advance()), so the lanes it begins are this run's.
	 */
	private static function launch( string $run_id, int $gen, int $from, int $to ): void {
		for ( $lane = 0; $lane < self::LANES; $lane++ ) {
			$position = $from + $lane;
			SyncState::lane_begin( $lane, $run_id, $gen, $position >= $to );
			if ( $position < $to ) {
				as_enqueue_async_action( self::PRODUCT_HOOK, array( $run_id, $gen, $lane, $position ), self::GROUP );
			}
		}
	}

	private static function next( string $run_id, int $gen, int $lane, int $position, int $to ): void {
		if ( $position < $to ) {
			as_enqueue_async_action( self::PRODUCT_HOOK, array( $run_id, $gen, $lane, $position ), self::GROUP );
			return;
		}
		SyncState::lane_done( $lane, $run_id, $gen );
		as_enqueue_async_action( self::FINISH_HOOK, array( $run_id, $gen ), self::GROUP );
	}

	private static function complete( string $run_id, int $gen ): void {
		SyncState::complete();
		EnrichedApi::flush();
		delete_option( Options::SYNC_QUEUE );
		SyncLock::release( $run_id, $gen );
	}

	/**
	 * Writes one product with no user and product-only permissions (SyncPermissions), never as the key's owner or any
	 * administrator. The owner is only checked: a store whose connecting user was removed or can no longer manage
	 * WooCommerce writes nothing, which is how the merchant revokes the sync without disconnecting.
	 */
	private static function as_sync( string $product_id, string $run_id ): string {
		if ( 0 === self::owner() ) {
			Log::error( 'Approved-product sync: the user who connected the store can no longer manage WooCommerce; product ' . $product_id . ' skipped.' );
			return 'skipped';
		}
		return SyncPermissions::run(
			(int) $product_id,
			static function () use ( $product_id, $run_id ): string {
				return SyncProduct::sync( $product_id, $run_id );
			}
		);
	}

	/**
	 * The user who connected the store, while they may still manage WooCommerce; 0 otherwise. Checked, never used to
	 * write.
	 */
	private static function owner(): int {
		$owner = ( new KeyMinter() )->owner( Options::key_id() );
		return $owner > 0 && user_can( $owner, 'manage_woocommerce' ) ? $owner : 0;
	}

	private static function name( string $product_id ): string {
		$product = wc_get_product( (int) $product_id );
		return $product instanceof \WC_Product ? $product->get_name() : '#' . $product_id;
	}

	/**
	 * @param array<int, string> $ids Every id this run has taken, in order.
	 */
	private static function save_queue( array $ids ): void {
		update_option(
			Options::SYNC_QUEUE,
			array(
				'ids' => $ids,
				'to'  => count( $ids ),
			),
			false
		);
	}

	/**
	 * @return array{ids: array<int, string>, to: int}
	 */
	private static function queue(): array {
		$queue = Options::fresh( Options::SYNC_QUEUE );
		$ids   = is_array( $queue ) && isset( $queue['ids'] ) && is_array( $queue['ids'] ) ? array_values( array_map( 'strval', $queue['ids'] ) ) : array();
		return array(
			'ids' => $ids,
			'to'  => is_array( $queue ) && isset( $queue['to'] ) ? min( (int) $queue['to'], count( $ids ) ) : 0,
		);
	}

	private static function unschedule_actions(): void {
		if ( ! function_exists( 'as_unschedule_all_actions' ) ) {
			return;
		}
		foreach ( array( self::PRODUCT_HOOK, self::FINISH_HOOK ) as $hook ) {
			// @phpstan-ignore-next-line argument.type -- null means "any args" to Action Scheduler (see OrderEvents::unschedule_all()).
			as_unschedule_all_actions( $hook, null, self::GROUP );
		}
	}
}