<?php
/**
 * Find & Replace Rule value object.
 *
 * @package Shiftora\Migration\FindReplace
 */

declare(strict_types=1);

namespace Shiftora\Migration\FindReplace;

// Prevent direct file access.
if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

/**
 * Immutable value object for a single find/replace rule.
 *
 * Scope is the set of tables a rule may touch. Null means every selected table
 * (what the automatic URL rules use); an explicit list narrows it and never widens
 * the run, since the caller intersects it with the selected tables.
 *
 * A generated rule is one UrlRuleBuilder wrote for the site address. Those run
 * together in one pass because each rewrites the same URL in a different spelling.
 */
final class Rule {

	/**
	 * @param string        $find           Literal text to replace.
	 * @param string        $replace        Replacement text.
	 * @param bool          $case_sensitive Whether the match respects case.
	 * @param string[]|null $tables         Tables this rule may touch, or null for every selected table.
	 * @param bool          $generated      Written by UrlRuleBuilder rather than by an operator.
	 */
	public function __construct(
		public readonly string $find,
		public readonly string $replace,
		public readonly bool   $case_sensitive = true,
		public readonly ?array $tables         = null,
		public readonly bool   $generated      = false
	) {}

		/**
		 * Create a Rule from an array (e.g. a DB JSON column).
		 *
		 * @param array{find: string, replace: string, case_sensitive?: bool, tables?: string[], generated?: bool} $data Rule data.
		 */
	public static function from_array( array $data ): self {
		return new self(
			find:           (string) ( $data['find'] ?? '' ),
			replace:        (string) ( $data['replace'] ?? '' ),
			case_sensitive: (bool) ( $data['case_sensitive'] ?? true ),
			tables:         self::normalise_tables( $data['tables'] ?? null ),
			generated:      (bool) ( $data['generated'] ?? false )
		);
	}

		/**
		 * Export the rule for JSON storage.
		 *
		 * @return array{find: string, replace: string, case_sensitive: bool, tables: string[]|null, generated: bool}
		 */
	public function to_array(): array {
		return [
			'find'           => $this->find,
			'replace'        => $this->replace,
			'case_sensitive' => $this->case_sensitive,
			'tables'         => $this->tables,
			'generated'      => $this->generated,
		];
	}

		/**
		 * Whether this rule may touch the given table.
		 *
		 * A scope can be prefixed or bare. Bare is portable, since a rule written on one
		 * site must mean the same on another with a different prefix.
		 *
		 * @param string $table  Prefixed table name.
		 * @param string $prefix Site prefix if known. Without it a bare name matches
		 *                       nothing rather than everything.
		 */
	public function applies_to_table( string $table, string $prefix = '' ): bool {
		if ( null === $this->tables ) {
			return true;
		}

		if ( in_array( $table, $this->tables, true ) ) {
			return true;
		}

		return '' !== $prefix
			&& str_starts_with( $table, $prefix )
			&& in_array( substr( $table, strlen( $prefix ) ), $this->tables, true );
	}

		/**
		 * An empty list would make the rule touch nothing, never intended, so it is
		 * treated as unscoped.
		 *
		 * @param mixed $tables Raw value from a request or a stored rule.
		 *
		 * @return string[]|null
		 */
	private static function normalise_tables( mixed $tables ): ?array {
		if ( ! is_array( $tables ) ) {
			return null;
		}

		$clean = array_values( array_unique( array_map( 'strval', $tables ) ) );
		sort( $clean );

		return [] === $clean ? null : $clean;
	}
}