<?php
/**
 * Approved-product sync: what the Sync screen shows.
 *
 * @package CortexCommerce
 */

namespace CortexCommerce\Sync;

use CortexCommerce\Settings\Options;

defined( 'ABSPATH' ) || exit;

/**
 * The run state of spec §3.2. Stored in two places so no two writers ever share an option:
 * - cortexcommerce_sync_state: the run (trigger, started_at, total, last_synced_at, last_updated_count), written only by
 *   SyncRun::start() and SyncRun::finish(), which never overlap (the lock's generation swap serialises them);
 * - cortexcommerce_sync_lane_0..2: each lane's updated count, the product it is writing, its recent products and its
 *   heartbeat, written only by that lane's own chain of actions. Each lane records the run and generation it belongs
 *   to, and a write naming any other run or generation is dropped (a run that was taken over cannot touch the new one).
 *   Those writes are a compare-and-swap on the row they read, so a lane begun by another run in between drops them too.
 * read() merges them into the one JSON object the REST route and the screen use. Failures are never part of it.
 * Every read goes past the object cache (Options::fresh()): other Action Scheduler processes write these options.
 */
final class SyncState {

	const RECENT = 10;

	const LANES = 3;

	public static function begin( string $trigger ): void {
		$run                 = self::run();
		$run['running']      = true;
		$run['trigger']      = 'hourly' === $trigger ? 'hourly' : 'button';
		$run['started_at']   = time();
		$run['heartbeat_at'] = time();
		$run['total']        = 0;
		self::save_run( $run );
		self::clear_lanes();
	}

	public static function add_total( int $count ): void {
		$run                 = self::run();
		$run['total']       += $count;
		$run['heartbeat_at'] = time();
		self::save_run( $run );
	}

	/**
	 * The run never got going (what's waiting? failed): not running, nothing recorded.
	 */
	public static function abandon(): void {
		$run            = self::run();
		$run['running'] = false;
		$run['total']   = 0;
		self::save_run( $run );
		self::clear_lanes();
	}

	public static function complete(): void {
		$run                       = self::run();
		$run['last_updated_count'] = self::updated();
		$run['last_synced_at']     = time();
		$run['running']            = false;
		$run['total']              = 0;
		self::save_run( $run );
		self::clear_lanes();
	}

	public static function clear(): void {
		delete_option( Options::SYNC_STATE );
		self::clear_lanes();
	}

	/**
	 * Starts lane $lane for generation $gen of run $run_id. The lane remembers whose it is: every later lane write
	 * names the run and generation, and is dropped when they are not the lane's, so an action left over from a run
	 * that was taken over can neither change the new run's counts nor keep its heartbeat alive. Call it only once the
	 * run holds the lock for $gen (after SyncLock::acquire() or SyncLock::advance()).
	 */
	public static function lane_begin( int $lane, string $run_id, int $gen, bool $done ): void {
		$state = self::lane( $lane );
		if ( $run_id !== $state['run_id'] ) { // Another run's leftovers: this run's counts start from nothing.
			$state['updated'] = 0;
			$state['handled'] = 0;
			$state['recent']  = array();
		}
		$state['run_id']       = $run_id;
		$state['gen']          = $gen;
		$state['done']         = $done;
		$state['current']      = null;
		$state['heartbeat_at'] = time();
		self::save_lane( $lane, $state );
	}

	public static function lane_working( int $lane, string $run_id, int $gen, int $id, string $name ): void {
		self::write_owned_lane(
			$lane,
			$run_id,
			$gen,
			static function ( array $state ) use ( $id, $name ): array {
				$state['current'] = array(
					'id'   => $id,
					'name' => $name,
				);
				return $state;
			}
		);
	}

	/**
	 * @param string|null $synced_name The product's name when it was synced; null when it was not.
	 */
	public static function lane_handled( int $lane, string $run_id, int $gen, int $id, ?string $synced_name ): void {
		self::write_owned_lane(
			$lane,
			$run_id,
			$gen,
			static function ( array $state ) use ( $id, $synced_name ): array {
				$state['current'] = null;
				++$state['handled']; // Synced, failed or skipped: the bar moves either way.
				if ( null !== $synced_name ) {
					++$state['updated'];
					array_unshift(
						$state['recent'],
						array(
							'id'    => $id,
							'name'  => $synced_name,
							'at'    => time(),
							// Orders products synced in the same second; dropped by read().
							'order' => microtime( true ),
						)
					);
					$state['recent'] = array_slice( $state['recent'], 0, self::RECENT );
				}
				return $state;
			}
		);
	}

	public static function lane_done( int $lane, string $run_id, int $gen ): void {
		self::write_owned_lane(
			$lane,
			$run_id,
			$gen,
			static function ( array $state ): array {
				$state['done'] = true;
				return $state;
			}
		);
	}

	/**
	 * Whether every lane belongs to generation $gen of run $run_id and is done: another run's lanes never are.
	 */
	public static function lanes_done( int $gen, string $run_id ): bool {
		for ( $lane = 0; $lane < self::LANES; $lane++ ) {
			$state = self::lane( $lane );
			if ( $run_id !== $state['run_id'] || $gen !== $state['gen'] || ! $state['done'] ) {
				return false;
			}
		}
		return true;
	}

	/**
	 * Whether lane $lane of generation $gen of run $run_id shows product $id as being written: it started that product
	 * and never got to lane_handled(). A lane that moved on, or another run's lane, is not.
	 */
	public static function is_lane_working_on( int $lane, string $run_id, int $gen, int $id ): bool {
		$state = self::lane( $lane );
		return $run_id === $state['run_id'] && $gen === $state['gen'] && ! $state['done'] && null !== $state['current'] && $id === $state['current']['id'];
	}

	public static function heartbeat_at(): int {
		$latest = self::run()['heartbeat_at'];
		for ( $lane = 0; $lane < self::LANES; $lane++ ) {
			$latest = max( $latest, self::lane( $lane )['heartbeat_at'] );
		}
		return $latest;
	}

	/**
	 * @return array{running: bool, trigger: string, started_at: int, heartbeat_at: int, total: int, updated: int, handled: int, in_progress: array<int, array{id: int, name: string}>, recent: array<int, array{id: int, name: string, at: int}>, last_synced_at: int, last_updated_count: int, next_sync_at: int|null}
	 */
	public static function read(): array {
		$run         = self::run();
		$running     = $run['running'] && null !== SyncLock::held() && ! SyncLock::is_stale();
		$in_progress = array();
		$recent      = array();
		if ( $running ) {
			for ( $lane = 0; $lane < self::LANES; $lane++ ) {
				$state = self::lane( $lane );
				if ( null !== $state['current'] ) {
					$in_progress[] = $state['current'];
				}
				$recent = array_merge( $recent, $state['recent'] );
			}
			usort(
				$recent,
				static function ( array $a, array $b ): int {
					return $b['order'] <=> $a['order'];
				}
			);
			$recent = array_map(
				static function ( array $item ): array {
					return array(
						'id'   => $item['id'],
						'name' => $item['name'],
						'at'   => $item['at'],
					);
				},
				array_slice( $recent, 0, self::RECENT )
			);
		}
		return array(
			'running'            => $running,
			'trigger'            => $run['trigger'],
			'started_at'         => $run['started_at'],
			'heartbeat_at'       => self::heartbeat_at(),
			'total'              => $running ? $run['total'] : 0,
			'updated'            => $running ? self::updated() : 0,
			'handled'            => $running ? self::handled() : 0,
			'in_progress'        => $in_progress,
			'recent'             => $recent,
			'last_synced_at'     => $run['last_synced_at'],
			'last_updated_count' => $run['last_updated_count'],
			'next_sync_at'       => SyncSchedule::next(),
		);
	}

	private static function updated(): int {
		$updated = 0;
		for ( $lane = 0; $lane < self::LANES; $lane++ ) {
			$updated += self::lane( $lane )['updated'];
		}
		return $updated;
	}

	private static function handled(): int {
		$handled = 0;
		for ( $lane = 0; $lane < self::LANES; $lane++ ) {
			$handled += self::lane( $lane )['handled'];
		}
		return $handled;
	}

	/**
	 * @return array{running: bool, trigger: string, started_at: int, heartbeat_at: int, total: int, last_synced_at: int, last_updated_count: int}
	 */
	private static function run(): array {
		$raw = Options::fresh( Options::SYNC_STATE );
		$raw = is_array( $raw ) ? $raw : array();
		return array(
			'running'            => isset( $raw['running'] ) && true === $raw['running'],
			'trigger'            => isset( $raw['trigger'] ) && 'hourly' === $raw['trigger'] ? 'hourly' : 'button',
			'started_at'         => isset( $raw['started_at'] ) ? (int) $raw['started_at'] : 0,
			'heartbeat_at'       => isset( $raw['heartbeat_at'] ) ? (int) $raw['heartbeat_at'] : 0,
			'total'              => isset( $raw['total'] ) ? (int) $raw['total'] : 0,
			'last_synced_at'     => isset( $raw['last_synced_at'] ) ? (int) $raw['last_synced_at'] : 0,
			'last_updated_count' => isset( $raw['last_updated_count'] ) ? (int) $raw['last_updated_count'] : 0,
		);
	}

	/**
	 * @param array<string, mixed> $run Run fields.
	 */
	private static function save_run( array $run ): void {
		update_option( Options::SYNC_STATE, $run, false );
	}

	/**
	 * @return array{run_id: string, gen: int, done: bool, updated: int, handled: int, current: array{id: int, name: string}|null, recent: array<int, array{id: int, name: string, at: int, order: float}>, heartbeat_at: int}
	 */
	private static function lane( int $lane ): array {
		return self::lane_fields( Options::fresh( Options::SYNC_LANE . $lane ) );
	}

	/**
	 * @param mixed $raw A lane option's stored value.
	 * @return array{run_id: string, gen: int, done: bool, updated: int, handled: int, current: array{id: int, name: string}|null, recent: array<int, array{id: int, name: string, at: int, order: float}>, heartbeat_at: int}
	 */
	private static function lane_fields( $raw ): array {
		$raw = is_array( $raw ) ? $raw : array();
		return array(
			'run_id'       => isset( $raw['run_id'] ) ? (string) $raw['run_id'] : '',
			'gen'          => isset( $raw['gen'] ) ? (int) $raw['gen'] : -1,
			'done'         => isset( $raw['done'] ) && true === $raw['done'],
			'updated'      => isset( $raw['updated'] ) ? (int) $raw['updated'] : 0,
			'handled'      => isset( $raw['handled'] ) ? (int) $raw['handled'] : 0,
			'current'      => isset( $raw['current']['id'], $raw['current']['name'] ) ? array(
				'id'   => (int) $raw['current']['id'],
				'name' => (string) $raw['current']['name'],
			) : null,
			'recent'       => isset( $raw['recent'] ) && is_array( $raw['recent'] ) ? $raw['recent'] : array(),
			'heartbeat_at' => isset( $raw['heartbeat_at'] ) ? (int) $raw['heartbeat_at'] : 0,
		);
	}

	/**
	 * Applies $change to lane $lane only while it belongs to generation $gen of run $run_id, and only if nothing else
	 * wrote the lane since it was read: the new value replaces the row read with one compare-and-swap. A write that
	 * loses (the lane was begun by a run that took over, between this read and this write) is dropped, so an action
	 * left over from an old run can never land in the new run's lane.
	 *
	 * @param callable(array{run_id: string, gen: int, done: bool, updated: int, handled: int, current: array{id: int, name: string}|null, recent: array<int, array{id: int, name: string, at: int, order: float}>, heartbeat_at: int}): array<string, mixed> $change
	 */
	private static function write_owned_lane( int $lane, string $run_id, int $gen, callable $change ): void {
		$name = Options::SYNC_LANE . $lane;
		$read = Options::raw( $name );
		if ( null === $read ) {
			return;
		}
		$state = self::lane_fields( maybe_unserialize( $read ) );
		if ( $run_id !== $state['run_id'] || $gen !== $state['gen'] ) {
			return;
		}
		$state                 = $change( $state );
		$state['heartbeat_at'] = time();
		Options::compare_and_swap( $name, $read, maybe_serialize( $state ) );
	}

	/**
	 * @param array<string, mixed> $state Lane fields.
	 */
	private static function save_lane( int $lane, array $state ): void {
		update_option( Options::SYNC_LANE . $lane, $state, false );
	}

	private static function clear_lanes(): void {
		for ( $lane = 0; $lane < self::LANES; $lane++ ) {
			delete_option( Options::SYNC_LANE . $lane );
		}
	}
}