<?php
/**
 * Duolangue — Slugs & URLs.
 *
 * Per-language URL bases for post types and taxonomies. The default-language
 * base is injected via register_(post_type|taxonomy)_args; the secondary
 * base is served through cloned rewrite rules under the language directory.
 */

defined( 'ABSPATH' ) || exit;

class Duolangue_Slugs {

	public function __construct() {
		add_filter( 'register_post_type_args', array( $this, 'filter_post_type_args' ), 20, 2 );
		add_filter( 'register_taxonomy_args', array( $this, 'filter_taxonomy_args' ), 20, 2 );
		add_filter( 'rewrite_rules_array', array( $this, 'filter_rewrite_rules' ), 999 );
		add_filter( 'wp_unique_post_slug', array( $this, 'allow_cross_language_slug' ), 10, 6 );
		add_action( 'admin_post_duolangue_save_slugs', array( $this, 'handle_save' ) );
	}

	/**
	 * Allow the SAME slug in both languages (e.g. /contact/ and /en/contact/):
	 * when WP appends -2 because of a conflict, keep the original slug if
	 * every conflicting sibling belongs to the other language.
	 */
	public function allow_cross_language_slug( $slug, $post_id, $post_status, $post_type, $post_parent, $original_slug ) {
		global $wpdb;

		if ( $slug === $original_slug || ! in_array( $post_type, duolangue_post_types(), true ) ) {
			return $slug;
		}

		$lang = duolangue_get_post_lang( $post_id );

		// Direct query mirrors core's own conflict check in wp_unique_post_slug();
		// runs once at save time on an unhooked filter, so caching is not applicable.
		// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching
		$conflicts = $wpdb->get_col( $wpdb->prepare(
			"SELECT ID FROM $wpdb->posts WHERE post_name = %s AND post_type = %s AND post_parent = %d AND ID != %d",
			$original_slug,
			$post_type,
			$post_parent,
			$post_id
		) );

		if ( ! $conflicts ) {
			return $slug;
		}

		foreach ( $conflicts as $conflict_id ) {
			if ( duolangue_get_post_lang( (int) $conflict_id ) === $lang ) {
				return $slug; // Real conflict within the same language.
			}
		}

		return $original_slug; // Conflicts only across languages: allowed.
	}

	/* ------------------------------------------------------------------
	 * Bases
	 * ---------------------------------------------------------------- */

	/**
	 * Configured base for an object in a language, or ''.
	 */
	public static function get_base( $name, $kind, $lang_code ) {
		$settings = duolangue_get_settings();
		return isset( $settings['bases'][ $kind ][ $name ][ $lang_code ] )
			? (string) $settings['bases'][ $kind ][ $name ][ $lang_code ]
			: '';
	}

	/**
	 * The base actually used in rewrite rules for the default language:
	 * the configured default base, otherwise the originally registered slug.
	 */
	public static function effective_default_base( $name, $kind ) {
		$configured = self::get_base( $name, $kind, duolangue_default_lang()['code'] );
		if ( $configured ) {
			return $configured;
		}

		if ( 'post_type' === $kind ) {
			$obj = get_post_type_object( $name );
			if ( $obj && ! empty( $obj->rewrite['slug'] ) ) {
				return $obj->rewrite['slug'];
			}
		} else {
			$obj = get_taxonomy( $name );
			if ( $obj && ! empty( $obj->rewrite['slug'] ) ) {
				return $obj->rewrite['slug'];
			}
		}
		return '';
	}

	/**
	 * Inject the default-language base as the registered rewrite slug.
	 */
	public function filter_post_type_args( $args, $post_type ) {
		$base = self::get_base( $post_type, 'post_type', duolangue_default_lang()['code'] );
		if ( $base && ! empty( $args['rewrite'] ) ) {
			$rewrite         = is_array( $args['rewrite'] ) ? $args['rewrite'] : array();
			$rewrite['slug'] = $base;
			$args['rewrite'] = $rewrite;
		}
		return $args;
	}

	public function filter_taxonomy_args( $args, $taxonomy ) {
		$base = self::get_base( $taxonomy, 'taxonomy', duolangue_default_lang()['code'] );
		if ( $base && ! empty( $args['rewrite'] ) ) {
			$rewrite         = is_array( $args['rewrite'] ) ? $args['rewrite'] : array();
			$rewrite['slug'] = $base;
			$args['rewrite'] = $rewrite;
		}
		return $args;
	}

	/* ------------------------------------------------------------------
	 * Rewrite rules
	 * ---------------------------------------------------------------- */

	/**
	 * Build the secondary-language rule set:
	 *  1. Clone every rule whose regex starts with a translated base,
	 *     swapping in the secondary base.
	 *  2. Prefix those clones + all original rules with `{lang}/`,
	 *     appending &lang={lang}.
	 * Original rules stay untouched at the root (default language).
	 */
	public function filter_rewrite_rules( $rules ) {
		$settings = duolangue_get_settings();
		if ( 'directory' !== $settings['url_mode'] || ! is_array( $rules ) ) {
			return $rules;
		}

		$secondary = duolangue_secondary_lang()['code'];

		// Base pairs: effective default base => secondary base.
		$pairs = array();
		foreach ( duolangue_post_types() as $post_type ) {
			$sec = self::get_base( $post_type, 'post_type', $secondary );
			$def = self::effective_default_base( $post_type, 'post_type' );
			if ( $sec && $def && $sec !== $def ) {
				$pairs[ $def ] = $sec;
			}
		}
		foreach ( duolangue_taxonomies() as $taxonomy ) {
			$sec = self::get_base( $taxonomy, 'taxonomy', $secondary );
			$def = self::effective_default_base( $taxonomy, 'taxonomy' );
			if ( $sec && $def && $sec !== $def ) {
				$pairs[ $def ] = $sec;
			}
		}

		// 1. Clones with the secondary base (only served under the prefix).
		$clones = array();
		foreach ( $pairs as $def_base => $sec_base ) {
			foreach ( $rules as $regex => $query ) {
				if ( 0 === strpos( $regex, $def_base . '/' ) || $regex === $def_base . '/?$' ) {
					$clones[ $sec_base . substr( $regex, strlen( $def_base ) ) ] = $query;
				}
			}
		}

		// 2. Prefixed rules for the secondary language.
		$prefixed = array(
			$secondary . '/?$' => 'index.php?lang=' . $secondary,
		);
		foreach ( $clones + $rules as $regex => $query ) {
			$prefixed[ $secondary . '/' . $regex ] = $query . '&lang=' . $secondary;
		}

		// Prefixed (more specific) first, then the original root rules.
		return $prefixed + $rules;
	}

	/**
	 * Swap the default base for the secondary base inside a permalink.
	 */
	public static function swap_base_in_url( $url, $name, $kind ) {
		$secondary = duolangue_secondary_lang()['code'];
		$sec_base  = self::get_base( $name, $kind, $secondary );
		$def_base  = self::effective_default_base( $name, $kind );

		if ( ! $sec_base || ! $def_base || $sec_base === $def_base ) {
			return $url;
		}

		$pos = strpos( $url, '/' . $def_base . '/' );
		if ( false === $pos ) {
			return $url;
		}
		return substr_replace( $url, '/' . $sec_base . '/', $pos, strlen( '/' . $def_base . '/' ) );
	}

	/* ------------------------------------------------------------------
	 * Screen
	 * ---------------------------------------------------------------- */

	public static function render_screen() {
		$default   = duolangue_default_lang();
		$secondary = duolangue_secondary_lang();
		// Rows MUST follow the same order as the headers: default first.
		$langs     = array( $default, $secondary );
		?>
		<div class="card duolangue-card">
			<h2><?php esc_html_e( 'Slugs & URLs', 'duolangue' ); ?></h2>
			<p class="description">
				<?php esc_html_e( 'Individual post slugs are translated in the editor. Here you translate the URL bases — the fixed part in front of the slug for each content type listed below.', 'duolangue' ); ?>
			</p>

			<form method="post" action="<?php echo esc_url( admin_url( 'admin-post.php' ) ); ?>">
				<?php wp_nonce_field( 'duolangue_save_slugs' ); ?>
				<input type="hidden" name="action" value="duolangue_save_slugs" />

				<table class="widefat striped duolangue-slugs-table">
					<thead>
						<tr>
							<th><?php esc_html_e( 'Type / taxonomy', 'duolangue' ); ?></th>
							<th>
								<?php
								/* translators: %s: language name. */
								printf( esc_html__( 'Base — %s', 'duolangue' ), esc_html( $default['name'] ) );
								?>
								<span class="description"><?php esc_html_e( '(default — served at the root)', 'duolangue' ); ?></span>
							</th>
							<th>
								<?php
								/* translators: %s: language name. */
								printf( esc_html__( 'Base — %s', 'duolangue' ), esc_html( $secondary['name'] ) );
								?>
							</th>
						</tr>
					</thead>
					<tbody>
					<?php
					foreach ( duolangue_post_types() as $post_type ) :
						$obj = get_post_type_object( $post_type );
						if ( ! $obj ) {
							continue;
						}
						$has_rewrite = 'page' !== $post_type && ! empty( $obj->rewrite );
						?>
						<tr>
							<td>
								<strong><?php echo esc_html( $obj->labels->name ); ?></strong>
								<span class="description">(<?php echo esc_html( $post_type ); ?>)</span>
							</td>
							<?php foreach ( $langs as $lang ) : ?>
								<td>
									<?php if ( $has_rewrite ) : ?>
										<span class="duolangue-base-input">
											<code>/</code><input type="text"
												name="bases[post_type][<?php echo esc_attr( $post_type ); ?>][<?php echo esc_attr( $lang['code'] ); ?>]"
												value="<?php echo esc_attr( self::get_base( $post_type, 'post_type', $lang['code'] ) ); ?>"
												placeholder="<?php echo esc_attr( 'post' === $post_type ? '' : (string) ( $obj->rewrite['slug'] ?? '' ) ); ?>" /><code>/…/</code>
										</span>
									<?php else : ?>
										<span class="description"><?php esc_html_e( 'No base — pages live at the root.', 'duolangue' ); ?></span>
									<?php endif; ?>
								</td>
							<?php endforeach; ?>
						</tr>
					<?php endforeach; ?>

					<?php
					foreach ( duolangue_taxonomies() as $taxonomy ) :
						$obj = get_taxonomy( $taxonomy );
						if ( ! $obj || empty( $obj->rewrite ) ) {
							continue;
						}
						?>
						<tr>
							<td>
								<strong><?php echo esc_html( $obj->labels->name ); ?></strong>
								<span class="description">(<?php echo esc_html( $taxonomy ); ?>)</span>
							</td>
							<?php foreach ( $langs as $lang ) : ?>
								<td>
									<span class="duolangue-base-input">
										<code>/</code><input type="text"
											name="bases[taxonomy][<?php echo esc_attr( $taxonomy ); ?>][<?php echo esc_attr( $lang['code'] ); ?>]"
											value="<?php echo esc_attr( self::get_base( $taxonomy, 'taxonomy', $lang['code'] ) ); ?>"
											placeholder="<?php echo esc_attr( (string) ( $obj->rewrite['slug'] ?? '' ) ); ?>" /><code>/…/</code>
									</span>
								</td>
							<?php endforeach; ?>
						</tr>
					<?php endforeach; ?>
					</tbody>
				</table>

				<div class="notice notice-warning inline duolangue-inline-notice">
					<p>
						<span class="dashicons dashicons-warning"></span>
						<?php esc_html_e( 'Changing URL bases changes public URLs. Set up 301 redirects if the site is already live.', 'duolangue' ); ?>
					</p>
				</div>

				<p class="description">
					<?php esc_html_e( 'Note: the built-in "Posts" base only applies when your permalink structure starts with a fixed prefix matching it (e.g. /blog/%postname%/). In "URL parameter" mode, translated bases are not applied.', 'duolangue' ); ?>
				</p>

				<p class="submit">
					<button type="submit" class="button button-primary"><?php esc_html_e( 'Save & flush permalinks', 'duolangue' ); ?></button>
				</p>
			</form>
		</div>
		<?php
	}

	public function handle_save() {
		check_admin_referer( 'duolangue_save_slugs' );
		if ( ! current_user_can( 'manage_options' ) ) {
			wp_die( esc_html__( 'You are not allowed to do that.', 'duolangue' ) );
		}

		$raw   = isset( $_POST['bases'] ) && is_array( $_POST['bases'] ) ? map_deep( wp_unslash( $_POST['bases'] ), 'sanitize_text_field' ) : array();
		$clean = array( 'post_type' => array(), 'taxonomy' => array() );

		foreach ( array( 'post_type', 'taxonomy' ) as $kind ) {
			if ( empty( $raw[ $kind ] ) || ! is_array( $raw[ $kind ] ) ) {
				continue;
			}
			foreach ( $raw[ $kind ] as $name => $by_lang ) {
				$name = sanitize_key( $name );
				if ( ! is_array( $by_lang ) ) {
					continue;
				}
				foreach ( $by_lang as $code => $base ) {
					if ( ! is_string( $base ) ) {
						continue;
					}
					$code = sanitize_key( $code );
					if ( ! in_array( $code, duolangue_lang_codes(), true ) ) {
						continue;
					}
					$base = trim( sanitize_title( $base ), '/' );
					if ( '' !== $base ) {
						$clean[ $kind ][ $name ][ $code ] = $base;
					}
				}
			}
		}

		$settings          = Duolangue_Settings::get();
		$settings['bases'] = $clean;
		Duolangue_Settings::update( $settings );

		flush_rewrite_rules();

		wp_safe_redirect( admin_url( 'admin.php?page=duolangue&tab=slugs&duolangue_msg=slugs_saved' ) );
		exit;
	}
}