<?php
/**
 * The onboarding wizard: its assets, its inline payload and its shell.
 *
 * @package AcidStudios\AEO
 */

declare(strict_types=1);

namespace AcidStudios\AEO\Admin;

use AcidStudios\AEO\Bots\Registry;
use AcidStudios\AEO\Data\SiteData;
use AcidStudios\AEO\Detect\Environment;
use AcidStudios\AEO\Options;

defined( 'ABSPATH' ) || exit;

/**
 * Everything the setup wizard needs before a single pixel is drawn.
 *
 * The wizard itself is `assets/admin/wizard.js`: seven steps rendered client
 * side against one draft of the settings, saved a step at a time. This class is
 * the seam it hangs from — it loads the skeleton template, enqueues the two
 * files the script needs, and assembles the one payload the script is handed.
 *
 * Nothing here renders a control. The wizard draws every field in JavaScript,
 * because the same field has to react to a preset, a preview and a validation
 * error without a page load; what PHP contributes is the data those controls
 * are built from — the users, the pages, the crawler catalogue — and the copy,
 * which is reused from `Fields::ui()` so the wizard and the settings screen
 * cannot drift apart in wording.
 */
final class Wizard {

	/**
	 * Body class the wizard screen adds, which the stylesheet hangs the
	 * full width layout off.
	 *
	 * @var string
	 */
	public const BODY_CLASS = 'acid-aeo-wizard-body';

	/**
	 * Last step an administrator can be resumed onto.
	 *
	 * Step 6 runs the audit and marks the wizard finished, so resuming there
	 * would finish a setup nobody asked to finish.
	 *
	 * @var int
	 */
	public const LAST_INPUT_STEP = 5;

	/**
	 * Largest number of pages offered to the key pages picker.
	 *
	 * @var int
	 */
	private const MAX_PAGES = 300;

	/**
	 * Largest number of users offered to the team and author pickers.
	 *
	 * @var int
	 */
	private const MAX_USERS = 100;

	/**
	 * Settings paths whose label, help and options the wizard reuses.
	 *
	 * The wizard asks a subset of the settings screen's questions, in a
	 * friendlier order. Rather than write that copy a second time, the paths it
	 * does ask about are listed here and their `FieldsUi` entries travel with
	 * the payload, so a wording change lands on both screens at once.
	 *
	 * @var array<int,string>
	 */
	private const LABEL_PATHS = [
		'general.site_type',
		'general.agency_credit',
		'identity.schema_type',
		'identity.name',
		'identity.tagline',
		'identity.description',
		'identity.logo_id',
		'identity.email',
		'identity.phone',
		'identity.founding_date',
		'identity.tax_id',
		'identity.address.street',
		'identity.address.city',
		'identity.address.region',
		'identity.address.postal',
		'identity.address.country',
		'identity.geo.lat',
		'identity.geo.lng',
		'identity.opening_hours',
		'identity.languages',
		'identity.same_as',
		'identity.founder_user_id',
		'policy.preset',
		'policy.bots',
		'policy.content_signal.search',
		'policy.content_signal.ai_input',
		'policy.content_signal.ai_train',
		'policy.license',
		'policy.license_url',
		'policy.permissions_contact',
		'policy.noai_meta',
		'llms.about_text',
		'llms.key_pages',
		'llms.post_types',
		'llms.posts_limit',
		'llms.taxonomies',
		'llms.include_faq',
		'llms.include_offerings',
		'llms.full_enabled',
		'offerings.name',
		'offerings.url',
		'offerings.summary',
		'offerings.price_from',
		'offerings.currency',
		'offerings.delivery',
		'faq.q',
		'faq.a',
		'humans.enabled',
		'humans.team',
		'humans.team.name',
		'humans.team.role',
		'humans.team.url',
		'security.contact',
		'security.policy_url',
		'security.languages',
		'schema.post_type_map',
		'schema.defer_to_seo',
		'schema.pieces.organization',
		'schema.pieces.website',
		'schema.pieces.webpage',
		'schema.pieces.breadcrumb',
		'schema.pieces.article',
		'schema.pieces.person',
		'schema.pieces.faq',
		'schema.pieces.speakable',
		'schema.pieces.image_meta',
		'content.blocks',
		'content.meta_box',
		'content.last_updated',
		'content.editor_panel',
		'content.markdown',
		'indexnow.enabled',
		'indexnow.key',
		'indexnow.auto_submit',
		'citations.enabled',
		'citations.beacon',
		'citations.retention_days',
		'static_files.enabled',
		'static_files.files',
		'headers.enabled',
		'headers.link_header',
		'headers.content_signal_header',
	];

	/**
	 * Renders the wizard shell.
	 *
	 * The template is a skeleton: a header, an empty rail, an empty main column
	 * and an empty preview pane, which the script fills. It carries the step so
	 * the layout does not shift once the script boots, and a `<noscript>` so a
	 * browser without JavaScript is sent to the settings screen rather than
	 * left looking at four empty boxes.
	 *
	 * @return void
	 */
	public static function render(): void {
		$data = [
			'step'         => self::current_step(),
			'version'      => ACID_AEO_VERSION,
			'settings_url' => admin_url( 'admin.php?page=acid-aeo-settings' ),
		];

		require ACID_AEO_DIR . 'templates/wizard.php';
	}

	/**
	 * Loads the wizard's stylesheet, script and inline payload.
	 *
	 * Called from `Admin::enqueue()` once it has decided the wizard is the
	 * screen being rendered, so the handles depend on `acid-aeo-admin` and the
	 * script can reuse the helpers `admin.js` exports on `window.acidAeoAdmin`.
	 *
	 * @return void
	 */
	public static function enqueue(): void {
		wp_enqueue_media();

		wp_enqueue_style(
			'acid-aeo-wizard',
			ACID_AEO_URL . 'assets/admin/wizard.css',
			[ 'acid-aeo-admin' ],
			ACID_AEO_VERSION
		);

		wp_enqueue_script(
			'acid-aeo-wizard',
			ACID_AEO_URL . 'assets/admin/wizard.js',
			[ 'acid-aeo-admin', 'wp-api-fetch', 'wp-i18n', 'wp-url' ],
			ACID_AEO_VERSION,
			true
		);

		wp_set_script_translations( 'acid-aeo-wizard', 'acid-aeo', ACID_AEO_DIR . 'languages' );

		wp_add_inline_script(
			'acid-aeo-wizard',
			'window.acidAeoWizard = ' . (string) wp_json_encode( self::data(), JSON_HEX_TAG | JSON_HEX_AMP ) . ';',
			'before'
		);
	}

	/**
	 * Everything `wizard.js` is handed on the way in.
	 *
	 * @return array<string,mixed> Payload assigned to `window.acidAeoWizard`.
	 */
	public static function data(): array {
		$environment = Environment::detect();
		$seo         = is_array( $environment['seo_plugin'] ?? null ) ? $environment['seo_plugin'] : null;
		$cache       = is_array( $environment['cache_plugin'] ?? null ) ? $environment['cache_plugin'] : null;

		return [
			'settings'     => Options::all(),
			'defaults'     => Options::defaults(),
			'environment'  => $environment,
			'users'        => self::user_rows( self::users() ),
			'pages'        => self::page_rows( self::published_pages() ),
			'menuPages'    => self::menu_page_ids(),
			'postTypes'    => self::post_types(),
			'taxonomies'   => self::taxonomies(),
			'bots'         => Registry::grouped_by_vendor(),
			'presets'      => Registry::presets(),
			'step'         => self::current_step(),
			'completed'    => (bool) Options::get( 'general.wizard_completed', false ),
			'dashboardUrl' => admin_url( 'admin.php?page=acid-aeo' ),
			'settingsUrl'  => admin_url( 'admin.php?page=acid-aeo-settings' ),
			'editUserUrl'  => admin_url( 'user-edit.php' ),
			'homeUrl'      => home_url( '/' ),
			'mediaEnabled' => current_user_can( 'upload_files' ),
			'fileUrls'     => SiteData::file_urls(),
			'seoPlugin'    => null !== $seo ? (string) ( $seo['name'] ?? '' ) : null,
			'cachePlugin'  => null !== $cache ? (string) ( $cache['name'] ?? '' ) : null,
			'labels'       => self::labels(),
			'i18n'         => self::strings(),
		];
	}

	/**
	 * The step the wizard opens on.
	 *
	 * A finished setup starts again at the welcome step, where the copy turns
	 * into "Reconfigure". An unfinished one resumes where it stopped, but never
	 * on the last step: that one runs the audit and marks the wizard complete,
	 * and reopening the page is not the same as asking for that.
	 *
	 * @return int Step index, 0–5.
	 */
	public static function current_step(): int {
		if ( (bool) Options::get( 'general.wizard_completed', false ) ) {
			return 0;
		}

		$step = (int) Options::get( 'general.wizard_step', 0 );

		return max( 0, min( $step, self::LAST_INPUT_STEP ) );
	}

	/**
	 * Shapes a list of users into the rows the pickers render.
	 *
	 * Pure shaping: whatever `get_users()` handed back goes in, and what comes
	 * out is JSON with no objects left in it. A row the script cannot address —
	 * anything without an ID — is dropped rather than sent as a half row.
	 *
	 * @param array<int,mixed> $users Users, as `get_users()` returns them.
	 * @return array<int,array<string,mixed>> Each row: `id`, `name`, `role`, `jobTitle`, `url`, `hasPosts`, `hasSocial`.
	 */
	public static function user_rows( array $users ): array {
		$rows = [];

		foreach ( $users as $user ) {
			if ( ! is_object( $user ) || ! isset( $user->ID ) ) {
				continue;
			}

			$id = (int) $user->ID;

			if ( $id <= 0 ) {
				continue;
			}

			$roles  = isset( $user->roles ) && is_array( $user->roles ) ? array_values( $user->roles ) : [];
			$social = (string) get_user_meta( $id, UserFields::SAME_AS, true );

			$rows[] = [
				'id'        => $id,
				'name'      => (string) ( $user->display_name ?? '' ),
				'role'      => (string) ( $roles[0] ?? '' ),
				'jobTitle'  => (string) get_user_meta( $id, UserFields::JOB_TITLE, true ),
				'url'       => (string) get_author_posts_url( $id ),
				'hasPosts'  => (int) count_user_posts( $id, 'post', true ) > 0,
				'hasSocial' => '' !== trim( $social ),
			];
		}

		return $rows;
	}

	/**
	 * Shapes a list of pages into the rows the key pages picker renders.
	 *
	 * @param array<int,mixed> $pages Pages, as `get_pages()` returns them.
	 * @return array<int,array<string,mixed>> Each row: `id`, `title`, `url`.
	 */
	public static function page_rows( array $pages ): array {
		$rows = [];

		foreach ( $pages as $page ) {
			if ( ! is_object( $page ) || ! isset( $page->ID ) ) {
				continue;
			}

			$id = (int) $page->ID;

			if ( $id <= 0 ) {
				continue;
			}

			$title = trim( (string) ( $page->post_title ?? '' ) );
			$url   = get_permalink( $id );

			$rows[] = [
				'id'    => $id,
				'title' => '' !== $title ? $title : sprintf(
					/* translators: %d: page ID. */
					__( '(no title) #%d', 'acid-aeo' ),
					$id
				),
				'url'   => is_string( $url ) ? $url : '',
			];

			if ( count( $rows ) >= self::MAX_PAGES ) {
				break;
			}
		}

		return $rows;
	}

	/**
	 * The pages sitting at the top level of the site's navigation menu.
	 *
	 * These are what the key pages picker suggests, because a site has already
	 * answered "which pages matter" once, in its own menu.
	 *
	 * @return array<int,int> Page IDs.
	 */
	public static function menu_page_ids(): array {
		$menu_id = self::primary_menu_id();

		if ( $menu_id <= 0 ) {
			return [];
		}

		$items = wp_get_nav_menu_items( $menu_id );
		$ids   = [];

		foreach ( is_array( $items ) ? $items : [] as $item ) {
			if ( ! is_object( $item ) ) {
				continue;
			}

			if ( '0' !== (string) ( $item->menu_item_parent ?? '0' ) ) {
				continue;
			}

			if ( 'page' !== (string) ( $item->object ?? '' ) ) {
				continue;
			}

			$ids[] = (int) ( $item->object_id ?? 0 );
		}

		return array_values( array_unique( array_filter( $ids ) ) );
	}

	/**
	 * The label, help and options of every path the wizard reuses.
	 *
	 * @return array<string,array<string,mixed>> Dot path => `FieldsUi` entry.
	 */
	public static function labels(): array {
		$labels = [];

		foreach ( self::LABEL_PATHS as $path ) {
			$labels[ $path ] = Fields::entry( $path );
		}

		return $labels;
	}

	/**
	 * The ID of the menu the site shows first.
	 *
	 * The `primary` location if the theme registered one, otherwise whichever
	 * location has a menu assigned — a theme is free to call its main menu
	 * anything, and one menu is a better suggestion than none.
	 *
	 * @return int Menu ID, or 0 when no location has a menu.
	 */
	private static function primary_menu_id(): int {
		$locations = get_nav_menu_locations();
		$locations = is_array( $locations ) ? array_filter( array_map( 'intval', $locations ) ) : [];

		if ( isset( $locations['primary'] ) ) {
			return (int) $locations['primary'];
		}

		$first = reset( $locations );

		return false !== $first ? (int) $first : 0;
	}

	/**
	 * The users the team and author pickers can offer.
	 *
	 * @return array<int,mixed> Users.
	 */
	private static function users(): array {
		$users = get_users(
			[
				'orderby' => 'display_name',
				'order'   => 'ASC',
				'number'  => self::MAX_USERS,
			]
		);

		return is_array( $users ) ? $users : [];
	}

	/**
	 * The published pages the key pages picker can offer.
	 *
	 * @return array<int,mixed> Pages.
	 */
	private static function published_pages(): array {
		$pages = get_pages(
			[
				'sort_column' => 'menu_order,post_title',
				'post_status' => 'publish',
				'number'      => self::MAX_PAGES,
			]
		);

		return is_array( $pages ) ? $pages : [];
	}

	/**
	 * Public post types, as the wizard's checkbox lists want them.
	 *
	 * @return array<int,array<string,string>> Each entry: `slug`, `label`.
	 */
	private static function post_types(): array {
		$types = [];

		foreach ( get_post_types( [ 'public' => true ], 'objects' ) as $slug => $type ) {
			$types[] = [
				'slug'  => (string) $slug,
				'label' => (string) ( $type->labels->name ?? $slug ),
			];
		}

		return $types;
	}

	/**
	 * Public taxonomies, as the wizard's checkbox lists want them.
	 *
	 * @return array<int,array<string,string>> Each entry: `slug`, `label`.
	 */
	private static function taxonomies(): array {
		$taxonomies = [];

		foreach ( get_taxonomies( [ 'public' => true ], 'objects' ) as $slug => $taxonomy ) {
			$taxonomies[] = [
				'slug'  => (string) $slug,
				'label' => (string) ( $taxonomy->labels->name ?? $slug ),
			];
		}

		return $taxonomies;
	}

	/**
	 * The strings `wizard.js` needs that carry server side context.
	 *
	 * Everything else in the script is translated with `wp.i18n.__()`; these
	 * are the tables the wizard shares with the dashboard, plus the four
	 * messages the save and preview cycle announces.
	 *
	 * @return array<string,mixed> Key => translated string or table.
	 */
	private static function strings(): array {
		return [
			'saving'       => __( 'Saving…', 'acid-aeo' ),
			'saved'        => __( 'Saved.', 'acid-aeo' ),
			'saveFailed'   => __( 'This step could not be saved.', 'acid-aeo' ),
			'requestError' => __( 'Something went wrong. Please try again.', 'acid-aeo' ),
			'previewFail'  => __( 'Preview unavailable.', 'acid-aeo' ),
			'statuses'     => Pages::status_labels(),
			'bands'        => Admin::band_labels(),
		];
	}
}