<?php

/**
 * Host-Abgleich fuer Erlaubnisliste, eigene Adresse und Live-Adresse.
 *
 * Reine Logik; einzige WordPress-Funktion ist wp_parse_url() (in Tests bereitgestellt). Muster stammen
 * aus Wp360_Staging_Guard_Settings::normalize_host_pattern(): ein Host oder
 * `*.suffix` mit mindestens zwei Namensteilen hinter dem Stern.
 */
if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

class Wp360_Staging_Guard_Host_Matcher {

	/**
	 * Hosts, die immer die eigene Maschine meinen.
	 *
	 * @var string[]
	 */
	const LOOPBACK_HOSTS = array( 'localhost', '127.0.0.1', '::1' );

	/**
	 * Host einer URL in Kleinschreibung, ohne Port, Zugangsdaten und
	 * abschliessenden Punkt. Leer, wenn die URL keinen Host hat.
	 *
	 * @param mixed $url URL oder nackter Host.
	 * @return string
	 */
	public static function host_of( $url ) {
		if ( ! is_string( $url ) ) {
			return '';
		}

		$url = trim( $url );
		if ( '' === $url ) {
			return '';
		}

		// Steuerzeichen und Leerzeichen gehoeren in keine Adresse (PHP ersetzt ein
		// NUL im Host durch einen Unterstrich und liefert einen lesbaren Host).
		if ( preg_match( '/[ - ]/', $url ) ) {
			return '';
		}

		// Ein Rueckwaertsschraegstrich im Anfang der Adresse wird von PHP und
		// von curl unterschiedlich gedeutet (Host oder Pfad): nicht raten.
		$authority = preg_match( '#^(?:[a-z][a-z0-9+.\-]*:)?//([^/?\#]*)#i', $url, $m ) ? $m[1] : (string) preg_replace( '#[/?\#].*$#', '', $url );
		if ( false !== strpos( $authority, '\\' ) ) {
			return '';
		}

		// Ohne Schema (z. B. "api.example.com/pfad") versteht parse_url() den Host als Pfad.
		$candidate = ( false === strpos( $url, '://' ) && 0 !== strpos( $url, '//' ) ) ? '//' . $url : $url;
		$host      = wp_parse_url( $candidate, PHP_URL_HOST );
		if ( ! is_string( $host ) || '' === $host ) {
			return '';
		}

		// Prozent-Kodierung ("live%2eexample.com") und Umlaut-Domains
		// (Punycode) wie der HTTP-Client aufloesen, bevor verglichen wird.
		$host = self::to_ascii( rawurldecode( trim( $host, "[] \t\n\r\0\x0B" ) ) );
		$host = rtrim( $host, '.' );

		// Nur Zeichen eines Hostnamens (oder einer IPv6-Adresse); alles andere ist kein Host.
		if ( ! preg_match( '/^[a-z0-9._:-]{1,253}$/', $host ) ) {
			return '';
		}

		return $host;
	}

	/**
	 * Kleinschreibung und Umwandlung von Umlaut-Domains in Punycode
	 * (`müller.at` wird `xn--mller-kva.at`). Ohne die PHP-Erweiterung intl
	 * bleibt ein Host mit Nicht-ASCII-Zeichen unveraendert und faellt spaeter
	 * durch die Zeichenpruefung.
	 *
	 * @param string $host Host.
	 * @return string
	 */
	public static function to_ascii( $host ) {
		$host = strtolower( (string) $host );

		if ( preg_match( '/[^\x20-\x7E]/', $host ) && function_exists( 'idn_to_ascii' ) ) {
			$variant   = defined( 'INTL_IDNA_VARIANT_UTS46' ) ? INTL_IDNA_VARIANT_UTS46 : 0;
			$converted = $variant ? idn_to_ascii( $host, IDNA_DEFAULT, $variant ) : idn_to_ascii( $host );
			if ( is_string( $converted ) && '' !== $converted ) {
				return strtolower( $converted );
			}
		}

		return $host;
	}

	/**
	 * Trifft ein Host ein Muster? Exakt oder `*.suffix` (jede Ebene darunter,
	 * nie der Suffix selbst).
	 *
	 * @param string $host    Host (normalisiert).
	 * @param string $pattern Muster.
	 * @return bool
	 */
	public static function matches( $host, $pattern ) {
		$host    = strtolower( (string) $host );
		$pattern = strtolower( trim( (string) $pattern ) );
		if ( '' === $host || '' === $pattern ) {
			return false;
		}

		if ( 0 === strpos( $pattern, '*.' ) ) {
			$suffix = substr( $pattern, 1 ); // ".example.net"
			if ( strlen( $suffix ) < 4 || false === strpos( substr( $suffix, 1 ), '.' ) ) {
				return false; // `*.de`: ein Namensteil hinter dem Stern reicht nicht.
			}

			return strlen( $host ) > strlen( $suffix ) && substr( $host, -strlen( $suffix ) ) === $suffix;
		}

		return $host === $pattern;
	}

	/**
	 * Trifft ein Host irgendein Muster der Liste?
	 *
	 * @param string          $host     Host.
	 * @param string[]|string $patterns Muster als Array oder Text mit einem Eintrag je Zeile.
	 * @return bool
	 */
	public static function matches_any( $host, $patterns ) {
		if ( is_string( $patterns ) ) {
			$patterns = preg_split( '/[\r\n]+/', $patterns );
		}

		foreach ( (array) $patterns as $pattern ) {
			if ( is_string( $pattern ) && self::matches( $host, $pattern ) ) {
				return true;
			}
		}

		return false;
	}

	/**
	 * Ist der Host die eigene Maschine oder die eigene Website?
	 * `www.` und Gross-/Kleinschreibung spielen keine Rolle.
	 *
	 * @param string   $host      Host.
	 * @param string[] $own_hosts Hosts der eigenen Website (siteurl, home).
	 * @return bool
	 */
	public static function is_own_host( $host, array $own_hosts ) {
		$host = self::strip_www( strtolower( (string) $host ) );
		if ( '' === $host ) {
			return false;
		}

		if ( in_array( $host, self::LOOPBACK_HOSTS, true ) ) {
			return true;
		}

		foreach ( $own_hosts as $own ) {
			$own = self::strip_www( self::host_of( $own ) );
			if ( '' !== $own && $own === $host ) {
				return true;
			}
		}

		return false;
	}

	/**
	 * Zeigt die aktuelle Adresse auf einen anderen Host als die gespeicherte
	 * Live-Adresse? Ohne Live-Adresse oder bei ungueltiger Eingabe: nein.
	 * Verglichen wird nur der Host (ohne `www.`), nicht Schema oder Port.
	 *
	 * @param string $current_url Aktuelle Adresse der Website.
	 * @param string $live_url    Gespeicherte Live-Adresse.
	 * @return bool
	 */
	public static function differs_from_live( $current_url, $live_url ) {
		$live    = self::strip_www( self::host_of( $live_url ) );
		$current = self::strip_www( self::host_of( $current_url ) );
		if ( '' === $live || '' === $current ) {
			return false;
		}

		return $live !== $current;
	}

	/**
	 * Ist der Host die gespeicherte Live-Adresse?
	 *
	 * @param string $host     Host.
	 * @param string $live_url Gespeicherte Live-Adresse.
	 * @return bool
	 */
	public static function is_live_host( $host, $live_url ) {
		$live = self::strip_www( self::host_of( $live_url ) );
		$host = self::strip_www( strtolower( (string) $host ) );

		return '' !== $live && $live === $host;
	}

	/**
	 * @param string $host Host.
	 * @return string
	 */
	private static function strip_www( $host ) {
		return 0 === strpos( $host, 'www.' ) ? substr( $host, 4 ) : $host;
	}
}