<?php
/**
 * One source of SEO data, normalised.
 *
 * @package AiRankSuite
 */

declare(strict_types=1);

namespace AiRankSuite\Modules\ImportExport\Adapters;

use AiRankSuite\Modules\ImportExport\Services\Variables;

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

/**
 * Every SEO plugin keeps the same handful of facts about a page — a title, a
 * description, a keyword, whether to index it — and every one of them stores
 * those facts differently: Yoast in post meta with `%%vars%%`, Rank Math in
 * post meta with `%vars%` and a robots array, All in One SEO in a table of
 * its own, Slim SEO in a single serialised blob, SEOPress with "yes" for
 * noindex. An importer written per plugin ends up as one long function with a
 * branch per plugin and a mapping that only its author can check.
 *
 * An adapter is that plugin's dialect, and nothing else: it answers what data
 * it holds, and it returns **records** in one shape. Everything downstream —
 * the writer, the undo journal, the progress reporting, the CSV importer —
 * works on that shape and never learns which plugin a record came from.
 *
 * A record is an array with only the keys the source actually has:
 *
 *   title, desc            string, already in this plugin's variable dialect
 *   keywords               string[] (the first is the focus keyword)
 *   canonical              string
 *   robots                 string[] out of noindex/nofollow/noarchive/nosnippet/noimageindex
 *   social                 array{og_title,og_desc,og_image,tw_title,tw_desc,tw_image}
 *   breadcrumb_title       string
 *   schema_type            string
 *   exclude_sitemap        bool
 *   redirect               array{target: string, type: int}
 *
 * Adapters are strictly read-only towards the source plugin. Nothing here
 * writes, deletes or deactivates anything: a customer must be able to run the
 * import, look at the result, and go back.
 */
abstract class Adapter {

	/** Stable id, used in the REST payload and stored with every import run. */
	abstract public function id(): string;

	/** Human name of the source plugin. */
	abstract public function label(): string;

	/** Is the source plugin installed and running right now? */
	public function active(): bool {
		return false;
	}

	/**
	 * How much this source holds on this site. Counting is cheap (one COUNT
	 * per storage location) and never loads a post.
	 *
	 * @return array{posts:int, terms:int, redirects:int, settings:bool}
	 */
	public function counts(): array {
		return array(
			'posts'     => $this->count_meta( $this->post_meta_keys() ),
			'terms'     => $this->count_term_meta( $this->term_meta_keys() ),
			'redirects' => 0,
			'settings'  => $this->has_settings(),
		);
	}

	/**
	 * Post ids this source has data for, from a keyset cursor. Only ids with
	 * data — importing a 50,000-post site from a plugin that wrote 40 values
	 * must cost 40 records, not 50,000.
	 *
	 * @return array<int, int>
	 */
	public function post_ids( int $after, int $limit ): array {
		return $this->ids_with_meta( $this->post_meta_keys(), $after, $limit, false );
	}

	/**
	 * @return array<int, int>
	 */
	public function term_ids( int $after, int $limit ): array {
		return $this->ids_with_meta( $this->term_meta_keys(), $after, $limit, true );
	}

	/**
	 * One post's data, normalised.
	 *
	 * @return array<string, mixed>
	 */
	abstract public function post_record( int $post_id ): array;

	/**
	 * One term's data, normalised.
	 *
	 * @return array<string, mixed>
	 */
	public function term_record( int $term_id ): array {
		return array();
	}

	/**
	 * Site-wide settings, normalised. Keys mirror this plugin's own settings
	 * (see ImportWriter::apply_settings) — separator, home_title, templates,
	 * taxonomy_templates, noindex_types, noindex_taxonomies, author_*, date_*,
	 * search_title, og_default_image, twitter_site, organisation, local.
	 *
	 * @return array<string, mixed>
	 */
	public function settings(): array {
		return array();
	}

	/**
	 * Redirects, from a keyset cursor over the source's own rows.
	 *
	 * @return array<int, array{id:int, source:string, target:string, type:int}>
	 */
	public function redirects( int $after, int $limit ): array {
		return array();
	}

	// ------------------------------------------------------------- helpers --

	/**
	 * The post meta keys that mean "this source has data for this post".
	 *
	 * @return array<int, string>
	 */
	protected function post_meta_keys(): array {
		return array();
	}

	/**
	 * @return array<int, string>
	 */
	protected function term_meta_keys(): array {
		return array();
	}

	protected function has_settings(): bool {
		return false;
	}

	/** A meta value as a trimmed string, whatever the source stored. */
	protected function meta( int $post_id, string $key, bool $term = false ): string {
		if ( '' === $key ) {
			return '';
		}
		$value = $term ? get_term_meta( $post_id, $key, true ) : get_post_meta( $post_id, $key, true );
		return is_scalar( $value ) ? trim( (string) $value ) : '';
	}

	/**
	 * Translate the source's template variables into this plugin's.
	 */
	protected function vars( string $value ): string {
		return Variables::translate( $value );
	}

	/**
	 * Robots directives from a value that may be '1', 'yes', 'noindex', an
	 * array, or a comma list — every plugin picked a different one.
	 *
	 * @param mixed $raw
	 * @return array<int, string>
	 */
	protected function robots_from( $raw, string $directive = 'noindex' ): array {
		$known = array( 'noindex', 'nofollow', 'noarchive', 'nosnippet', 'noimageindex' );
		if ( is_array( $raw ) ) {
			return array_values( array_intersect( $known, array_map( 'strval', $raw ) ) );
		}
		$value = strtolower( trim( (string) $raw ) );
		if ( '' === $value ) {
			return array();
		}
		if ( str_contains( $value, ',' ) ) {
			$parts = array_map( 'trim', explode( ',', $value ) );
			return array_values( array_intersect( $known, $parts ) );
		}
		if ( in_array( $value, $known, true ) ) {
			return array( $value );
		}
		return in_array( $value, array( '1', 'yes', 'true', 'on' ), true ) ? array( $directive ) : array();
	}

	/**
	 * Drop the keys with nothing in them, so "the source has no value here"
	 * and "the source has an empty value here" cannot be confused downstream.
	 *
	 * @param array<string, mixed> $record
	 * @return array<string, mixed>
	 */
	protected function clean( array $record ): array {
		foreach ( $record as $key => $value ) {
			if ( '' === $value || array() === $value || null === $value || false === $value ) {
				unset( $record[ $key ] );
			}
			if ( 'social' === $key && is_array( $value ) ) {
				$social = array_filter( array_map( 'strval', $value ), static fn( $v ) => '' !== trim( $v ) );
				if ( empty( $social ) ) {
					unset( $record['social'] );
				} else {
					$record['social'] = $social;
				}
			}
		}
		return $record;
	}

	/**
	 * @param array<int, string> $keys
	 */
	/**
	 * Which meta keys actually hold data, primed once for the whole adapter
	 * fleet. detect() asked fourteen adapters for two COUNTs each, most of
	 * them counting nothing; two grouped queries answer "which keys are
	 * non-empty" for everyone, and only adapters with a live key still run
	 * their precise count. Null means "not primed" — every count stays exact.
	 *
	 * @var array<string, bool>|null
	 */
	private static ?array $key_has_data = null;

	/** The keys this adapter reads, for the fleet-wide prime. @return array{post: array<int,string>, term: array<int,string>} */
	public function key_map(): array {
		return array(
			'post' => array_values( array_filter( $this->post_meta_keys() ) ),
			'term' => array_values( array_filter( $this->term_meta_keys() ) ),
		);
	}

	/**
	 * @param array<int, string> $post_keys
	 * @param array<int, string> $term_keys
	 */
	public static function prime_key_data( array $post_keys, array $term_keys ): void {
		global $wpdb;
		self::$key_has_data = array();
		if ( ! empty( $post_keys ) ) {
			$in = implode( ',', array_fill( 0, count( $post_keys ), '%s' ) );
			// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, WordPress.DB.PreparedSQL.InterpolatedNotPrepared
			foreach ( (array) $wpdb->get_col( $wpdb->prepare( "SELECT DISTINCT meta_key FROM {$wpdb->postmeta} WHERE meta_key IN ({$in}) AND meta_value <> '' AND meta_value <> 'a:0:{}'", ...$post_keys ) ) as $k ) {
				self::$key_has_data[ 'p:' . $k ] = true;
			}
		}
		if ( ! empty( $term_keys ) ) {
			$in = implode( ',', array_fill( 0, count( $term_keys ), '%s' ) );
			// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, WordPress.DB.PreparedSQL.InterpolatedNotPrepared
			foreach ( (array) $wpdb->get_col( $wpdb->prepare( "SELECT DISTINCT meta_key FROM {$wpdb->termmeta} WHERE meta_key IN ({$in}) AND meta_value <> '' AND meta_value <> 'a:0:{}'", ...$term_keys ) ) as $k ) {
				self::$key_has_data[ 't:' . $k ] = true;
			}
		}
	}

	/** @param array<int, string> $keys */
	private static function any_primed( string $prefix, array $keys ): ?bool {
		if ( null === self::$key_has_data ) {
			return null;
		}
		foreach ( $keys as $k ) {
			if ( ! empty( self::$key_has_data[ $prefix . $k ] ) ) {
				return true;
			}
		}
		return false;
	}

	protected function count_meta( array $keys ): int {
		global $wpdb;
		$keys = array_values( array_filter( $keys ) );
		if ( empty( $keys ) ) {
			return 0;
		}
		if ( false === self::any_primed( 'p:', $keys ) ) {
			return 0;
		}
		$in = implode( ',', array_fill( 0, count( $keys ), '%s' ) );
		// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, WordPress.DB.PreparedSQL.InterpolatedNotPrepared
		return (int) $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(DISTINCT post_id) FROM {$wpdb->postmeta} WHERE meta_key IN ({$in}) AND meta_value <> '' AND meta_value <> 'a:0:{}'", ...$keys ) );
	}

	/**
	 * @param array<int, string> $keys
	 */
	protected function count_term_meta( array $keys ): int {
		global $wpdb;
		$keys = array_values( array_filter( $keys ) );
		if ( empty( $keys ) ) {
			return 0;
		}
		if ( false === self::any_primed( 't:', $keys ) ) {
			return 0;
		}
		$in = implode( ',', array_fill( 0, count( $keys ), '%s' ) );
		// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, WordPress.DB.PreparedSQL.InterpolatedNotPrepared
		return (int) $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(DISTINCT term_id) FROM {$wpdb->termmeta} WHERE meta_key IN ({$in}) AND meta_value <> ''", ...$keys ) );
	}

	/**
	 * @param array<int, string> $keys
	 * @return array<int, int>
	 */
	protected function ids_with_meta( array $keys, int $after, int $limit, bool $term ): array {
		global $wpdb;
		$keys = array_values( array_filter( $keys ) );
		if ( empty( $keys ) ) {
			return array();
		}
		$table  = $term ? $wpdb->termmeta : $wpdb->postmeta;
		$column = $term ? 'term_id' : 'post_id';
		$in     = implode( ',', array_fill( 0, count( $keys ), '%s' ) );
		// Table and id column travel as identifiers; only the generated %s
		// list is interpolated.
		$args = array_merge( array( $column, $table ), $keys, array( $column, $after, $column, max( 1, $limit ) ) );
		// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, WordPress.DB.PreparedSQL.InterpolatedNotPrepared
		$ids = $wpdb->get_col( $wpdb->prepare( "SELECT DISTINCT %i FROM %i WHERE meta_key IN ({$in}) AND meta_value <> '' AND meta_value <> 'a:0:{}' AND %i > %d ORDER BY %i ASC LIMIT %d", ...$args ) );
		return array_map( 'intval', (array) $ids );
	}

	/** Does this table exist? Sources that keep their own table ask first. */
	protected function table_exists( string $table ): bool {
		global $wpdb;
		// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching
		return $wpdb->get_var( $wpdb->prepare( 'SHOW TABLES LIKE %s', $table ) ) === $table;
	}

	/**
	 * An option as an array, whatever the source left there.
	 *
	 * @return array<string, mixed>
	 */
	protected function option( string $name ): array {
		$value = get_option( $name, array() );
		return is_array( $value ) ? $value : array();
	}
}