<?php
/**
 * The Import tab's actions (#21).
 *
 * @package ActivityLog404
 */

namespace ActivityLog404\Import;

defined( 'ABSPATH' ) || exit;

/**
 * Starts, drives and stops an import.
 *
 * Two drivers move a run forward, and either alone finishes it:
 *
 * - WP-Cron: starting a run schedules a single event, and each event runs
 *   batches for CRON_SECONDS and schedules the next while the run lasts.
 * - The open Import tab: its script calls the `step` AJAX action in a loop,
 *   each call running batches for STEP_SECONDS. This is what finishes an
 *   import on a site with DISABLE_WP_CRON and no system cron -- the owner
 *   watching the progress bar is the scheduler.
 *
 * Both go through Importer::run(), which a named lock serialises, so they
 * never run a batch of one source at the same time. A budget of a few
 * seconds per request keeps every request far inside any host's timeout,
 * and a batch reads at most Importer::BATCH_SIZE rows, so neither time nor
 * memory grows with the source's size.
 *
 * Every write checks, in this order: the nonce (bound to the operation and
 * the source, so a nonce for one cannot start another), then
 * `manage_options`, the capability of the screen this lives on. The
 * decision is perform() / step(), which return values and never exit
 * (OPERATIONS.md: an admin-post handler ending in exit kills PHPUnit).
 */
final class ImportActions {

	public const ACTION      = 'ops404_al_import';
	public const STEP_ACTION = 'ops404_al_import_step';
	public const CRON_HOOK   = 'ops404_al_import_cron';

	/** The result query argument the tab reads back. */
	public const RESULT_ARG = 'ops404_al_import_result';

	public const OP_START  = 'start';
	public const OP_CANCEL = 'cancel';

	/** Seconds of batches per browser step. */
	public const STEP_SECONDS = 4.0;

	/** Seconds of batches per cron event. */
	public const CRON_SECONDS = 20.0;

	/** Result codes; ImportTab maps each to its notice. */
	public const RESULTS = array(
		'started',
		'running',
		'empty',
		'unsupported',
		'cancelled',
		'not_running',
		'bad_request',
		'bad_nonce',
		'forbidden',
	);

	public static function register(): void {
		add_action( 'admin_post_' . self::ACTION, array( __CLASS__, 'handle' ) );
		add_action( 'wp_ajax_' . self::STEP_ACTION, array( __CLASS__, 'handle_step' ) );
		add_action( self::CRON_HOOK, array( __CLASS__, 'cron' ) );
	}

	/**
	 * The nonce action for one operation on one source.
	 *
	 * @param string $op     Operation.
	 * @param string $source Source key.
	 */
	public static function nonce_action( string $op, string $source ): string {
		return self::ACTION . '|' . $op . '|' . $source;
	}

	/**
	 * admin-post handler: decide, then redirect back to the tab.
	 */
	public static function handle(): void {
		// phpcs:ignore WordPress.Security.NonceVerification.Missing -- perform() verifies the nonce first thing.
		$result = self::perform( wp_unslash( $_POST ) );

		wp_safe_redirect(
			add_query_arg(
				array(
					'page'           => '404ops-activity-log',
					'tab'            => 'import',
					self::RESULT_ARG => $result,
				),
				admin_url( 'admin.php' )
			)
		);
		exit;
	}

	/**
	 * Start or cancel a run.
	 *
	 * @param array<string, mixed> $request The posted fields, unslashed.
	 * @return string A RESULTS code.
	 */
	public static function perform( array $request ): string {
		$op     = isset( $request['op'] ) && is_string( $request['op'] ) ? sanitize_key( $request['op'] ) : '';
		$key    = isset( $request['source'] ) && is_string( $request['source'] ) ? sanitize_key( $request['source'] ) : '';
		$nonce  = isset( $request['_wpnonce'] ) && is_string( $request['_wpnonce'] ) ? sanitize_text_field( $request['_wpnonce'] ) : '';
		$source = Importer::source( $key );

		if ( ! in_array( $op, array( self::OP_START, self::OP_CANCEL ), true ) || null === $source ) {
			return 'bad_request';
		}
		if ( ! wp_verify_nonce( $nonce, self::nonce_action( $op, $key ) ) ) {
			return 'bad_nonce';
		}
		if ( ! current_user_can( Importer::capability( $key ) ) ) {
			return 'forbidden';
		}

		if ( self::OP_CANCEL === $op ) {
			wp_clear_scheduled_hook( self::CRON_HOOK, array( $key ) );
			return Importer::cancel( $key ) ? 'cancelled' : 'not_running';
		}

		$result = Importer::start( $source, get_current_user_id() );
		if ( 'started' === $result ) {
			self::schedule( $key );
		}

		return $result;
	}

	/**
	 * AJAX handler for the tab's progress loop.
	 */
	public static function handle_step(): void {
		// phpcs:ignore WordPress.Security.NonceVerification.Missing -- step() verifies the nonce first thing.
		$response = self::step( wp_unslash( $_POST ) );

		if ( isset( $response['error'] ) ) {
			wp_send_json_error( $response, 'forbidden' === $response['error'] ? 403 : 400 );
		}
		wp_send_json_success( $response );
	}

	/**
	 * Run one step of a source's import and report where it stands.
	 *
	 * @param array<string, mixed> $request The posted fields, unslashed.
	 * @return array<string, mixed> Progress, or `error` with a code.
	 */
	public static function step( array $request ): array {
		$key   = isset( $request['source'] ) && is_string( $request['source'] ) ? sanitize_key( $request['source'] ) : '';
		$nonce = isset( $request['_wpnonce'] ) && is_string( $request['_wpnonce'] ) ? sanitize_text_field( $request['_wpnonce'] ) : '';

		if ( null === Importer::source( $key ) ) {
			return array( 'error' => 'bad_request' );
		}
		if ( ! wp_verify_nonce( $nonce, self::nonce_action( 'step', $key ) ) ) {
			return array( 'error' => 'bad_nonce' );
		}
		if ( ! current_user_can( Importer::capability( $key ) ) ) {
			return array( 'error' => 'forbidden' );
		}

		return self::progress( Importer::run( $key, self::STEP_SECONDS ) );
	}

	/**
	 * WP-Cron handler: run for a while, and come back while there is more.
	 *
	 * @param mixed $key Source key, the event's one argument.
	 */
	public static function cron( $key ): void {
		$key = is_string( $key ) ? $key : '';
		if ( null === Importer::source( $key ) ) {
			return;
		}

		$state = Importer::run( $key, self::CRON_SECONDS );
		if ( Importer::RUNNING === $state['status'] ) {
			self::schedule( $key );
		}
	}

	/**
	 * @param string $key Source key.
	 */
	private static function schedule( string $key ): void {
		if ( ! wp_next_scheduled( self::CRON_HOOK, array( $key ) ) ) {
			wp_schedule_single_event( time(), self::CRON_HOOK, array( $key ) );
		}
	}

	/**
	 * A run's state as the progress bar reads it.
	 *
	 * @param array<string, mixed> $state Importer::state().
	 * @return array<string, mixed>
	 */
	public static function progress( array $state ): array {
		$total     = (int) $state['total'];
		$processed = min( $total, (int) $state['processed'] );

		return array(
			'status'    => (string) $state['status'],
			'total'     => $total,
			'processed' => $processed,
			'imported'  => (int) $state['imported'],
			'generic'   => (int) $state['generic'],
			'skipped'   => array_map( 'intval', (array) $state['skipped'] ),
			'percent'   => $total > 0 ? (int) floor( 100 * $processed / $total ) : 100,
		);
	}
}