<?php
defined( 'ABSPATH' ) || exit;

/**
 * Thin HTTP client for the ZeroConfig SaaS. Every call is best-effort: the
 * plugin must keep working when the API is unreachable.
 */
class ZeroConfig_API {

	/** Set only while turn_off() sends its last heartbeat (see heartbeat_off()). */
	private static $final_call = false;

	public static function url( $path ) {
		return rtrim( ZEROCONFIG_API, '/' ) . '/v1/' . ltrim( $path, '/' );
	}

	public static function request( $method, $path, $body = null, $timeout = 15 ) {
		// Consent is the Turn on button: nothing reaches the service while the engine is off. The one
		// exception is the heartbeat that tells the service the engine was turned off.
		if ( ! ZeroConfig_Options::get( 'engine' ) && ! self::$final_call ) {
			return new WP_Error( 'zc_off', 'engine is off; nothing is sent' );
		}
		$o    = ZeroConfig_Options::all();
		$args = array(
			'method'  => $method,
			'timeout' => $timeout,
			'headers' => array(
				'Content-Type'  => 'application/json',
				'Accept'        => 'application/json',
				'X-ZC-Site'     => (string) $o['site_id'],
				'X-ZC-Version'  => ZEROCONFIG_VERSION,
				'Authorization' => 'Bearer ' . $o['site_token'],
			),
		);
		if ( null !== $body ) {
			$args['body'] = wp_json_encode( $body );
		}
		$res = wp_remote_request( self::url( $path ), $args );
		if ( is_wp_error( $res ) ) {
			ZeroConfig_Options::set( 'last_error', $res->get_error_message() );
			return $res;
		}
		$code = (int) wp_remote_retrieve_response_code( $res );
		$data = json_decode( wp_remote_retrieve_body( $res ), true );
		if ( $code >= 400 ) {
			$msg = is_array( $data ) && ! empty( $data['error'] ) && is_string( $data['error'] ) ? sanitize_text_field( $data['error'] ) : 'HTTP ' . $code;
			ZeroConfig_Options::set( 'last_error', $msg );
			return new WP_Error( 'zc_api', $msg, array( 'status' => $code, 'data' => $data ) );
		}
		return is_array( $data ) ? $data : array();
	}

	const EDGE_CHECK = 'zeroconfig_edge_check';

	/**
	 * Is the edge reachable? Answered from the stored state only: a page render never waits on the
	 * network. When the state is older than its lifetime (5 minutes up, 1 minute down), a background
	 * check is queued. While the edge is down the rewriter leaves original URLs in place.
	 */
	public static function edge_healthy() {
		if ( false === get_transient( 'zeroconfig_edge' ) && ! wp_next_scheduled( self::EDGE_CHECK ) ) {
			wp_schedule_single_event( time(), self::EDGE_CHECK );
		}
		return 'down' !== get_option( 'zeroconfig_edge_last', 'up' );
	}

	/**
	 * Background check (WP-Cron), 2-second timeout. When the state flips, the page cache (which embeds
	 * edge URLs) is purged once, so visitors never see broken images because of us.
	 */
	public static function check_edge() {
		if ( ! ZeroConfig_Options::get( 'engine' ) ) {
			return; // queued while the engine was on; nothing is sent once it is off
		}
		$res  = wp_remote_get( rtrim( ZEROCONFIG_API, '/' ) . '/healthz', array( 'timeout' => 2 ) );
		$ok   = ! is_wp_error( $res ) && 200 === (int) wp_remote_retrieve_response_code( $res );
		$prev = get_option( 'zeroconfig_edge_last', 'up' );
		set_transient( 'zeroconfig_edge', $ok ? 'up' : 'down', $ok ? 5 * MINUTE_IN_SECONDS : MINUTE_IN_SECONDS );
		if ( ( $ok ? 'up' : 'down' ) !== $prev ) {
			update_option( 'zeroconfig_edge_last', $ok ? 'up' : 'down', false );
			ZeroConfig_Page_Cache::purge_all( 'edge' ); // cached HTML must not carry URLs for the other state
		}
		return $ok;
	}

	/** Free sites self-register. No form, no e-mail confirmation. */
	/** Host we compare against, e.g. "example.com" or "localhost:8085" (www. ignored). */
	public static function current_host() {
		$p = wp_parse_url( home_url() );
		$h = strtolower( isset( $p['host'] ) ? $p['host'] : '' ) . ( isset( $p['port'] ) ? ':' . $p['port'] : '' );
		return preg_replace( '/^www\./', '', $h );
	}

	/**
	 * A database copied to staging or a new domain carries the production site's
	 * token. If this install now answers on another address, drop the connection:
	 * the copy must prove ownership of its own address before using the edge.
	 * Returns true when it disconnected.
	 */
	public static function guard_address( $reason = '' ) {
		$o = ZeroConfig_Options::all();
		if ( empty( $o['site_token'] ) ) {
			return false;
		}
		$now = self::current_host();
		if ( empty( $o['connected_host'] ) ) {
			ZeroConfig_Options::set( 'connected_host', $now ); // installs from before this check
			return false;
		}
		if ( $o['connected_host'] === $now && 'site_mismatch' !== $reason ) {
			return false;
		}
		ZeroConfig_Options::update(
			array(
				'site_id'        => '',
				'site_token'     => '',
				'connected_host' => '',
				'pending_reg'    => array(),
				'critical_css'   => array(),
				'last_selftest'  => array(),
				'quota'          => array(),
				'cdn_paused'     => false,
				'plan'           => 'free',
				'last_error'     => sprintf(
					/* translators: 1: old address, 2: new address */
					__( 'This site moved from %1$s to %2$s (a staging copy or a migration), so it was disconnected from the edge. Press Try again to confirm the new address.', 'zeroconfig' ),
					$o['connected_host'],
					$now
				),
			)
		);
		ZeroConfig_Page_Cache::purge_all( 'settings' ); // cached pages carry the old site's edge URLs
		return true;
	}

	/** Admin e-mail is shared only when the admin ticked the box under "Turn on". */
	public static function shared_email() {
		return ZeroConfig_Options::get( 'share_email' ) ? (string) get_option( 'admin_email' ) : '';
	}

	public static function register_site() {
		if ( ! ZeroConfig_Options::get( 'engine' ) ) {
			return new WP_Error( 'zc_off', 'engine is off; the site is not connected' );
		}
		$data = self::request(
			'POST',
			'sites/register',
			array(
				'url'            => home_url(),
				'name'           => get_bloginfo( 'name' ),
				'email'          => self::shared_email(),
				'wp_version'     => get_bloginfo( 'version' ),
				'php_version'    => PHP_VERSION,
				'plugin_version' => ZEROCONFIG_VERSION,
				'fingerprint'    => ZeroConfig_Compat::fingerprint(),
			),
			10
		);
		if ( is_wp_error( $data ) ) {
			return $data;
		}
		if ( empty( $data['challenge'] ) || empty( $data['code'] ) || ! preg_match( '/^r_[A-Za-z0-9_-]{10,64}$/', (string) $data['challenge'] ) || ! preg_match( '/^[A-Za-z0-9_-]{16,128}$/', (string) $data['code'] ) ) {
			return new WP_Error( 'zc_api', 'unexpected registration response' );
		}
		// The edge will fetch /?zc_verify=<challenge> from this site and expects this code back.
		$ttl = isset( $data['expires_in'] ) ? max( 60, min( 3600, (int) $data['expires_in'] ) ) : 900;
		set_transient( self::verify_key( $data['challenge'] ), (string) $data['code'], $ttl );
		ZeroConfig_Options::update( array( 'pending_reg' => array( 'challenge' => (string) $data['challenge'], 'code' => (string) $data['code'], 'at' => time(), 'ttl' => $ttl ), 'last_error' => '' ) );
		wp_schedule_single_event( time() + 15, ZeroConfig_Cron::CLAIM ); // finish in the background if nobody reloads the page
		return array( 'status' => 'pending' );
	}

	public static function verify_key( $challenge ) {
		return 'zeroconfig_verify_' . md5( (string) $challenge );
	}

	/** Answer the edge's ownership check. Runs before themes and most plugins load. */
	public static function serve_verification() {
		$c = isset( $_GET['zc_verify'] ) ? sanitize_text_field( wp_unslash( $_GET['zc_verify'] ) ) : ''; // phpcs:ignore WordPress.Security.NonceVerification.Recommended -- public ownership check answered with a one-time code, no state change
		if ( ! preg_match( '/^r_[A-Za-z0-9_-]{10,64}$/', $c ) ) {
			return;
		}
		$code = get_transient( self::verify_key( $c ) );
		nocache_headers();
		header( 'X-Robots-Tag: noindex' );
		header( 'Content-Type: text/plain; charset=utf-8' );
		if ( ! $code ) {
			status_header( 404 );
			exit;
		}
		echo esc_html( $code );
		exit;
	}

	/**
	 * Step 2: exchange a verified registration for the site token.
	 * Returns 'connected', 'pending', or WP_Error when verification failed.
	 */
	public static function claim_pending() {
		$p = ZeroConfig_Options::get( 'pending_reg' );
		if ( empty( $p['challenge'] ) ) {
			return ZeroConfig_Options::is_connected() ? 'connected' : new WP_Error( 'zc_api', 'no registration in progress' );
		}
		$clear = function () use ( $p ) {
			delete_transient( self::verify_key( $p['challenge'] ) );
			ZeroConfig_Options::set( 'pending_reg', array() );
		};
		if ( time() - (int) $p['at'] > (int) $p['ttl'] ) {
			$clear();
			ZeroConfig_Options::set( 'last_error', __( 'Site verification timed out. Press Try again.', 'zeroconfig' ) );
			return new WP_Error( 'zc_api', 'verification expired' );
		}
		$data = self::request( 'POST', 'sites/claim', array( 'challenge' => $p['challenge'], 'code' => $p['code'] ), 10 );
		if ( is_wp_error( $data ) ) {
			$status = (int) ( $data->get_error_data()['status'] ?? 0 );
			if ( in_array( $status, array( 404, 422 ), true ) ) {
				$clear();
			}
			return $data;
		}
		if ( empty( $data['site_token'] ) ) {
			return 'pending';
		}
		$clear();
		self::apply_site_payload( $data );
		ZeroConfig_Options::set( 'connected_host', self::current_host() );
		ZeroConfig_Engine::on_connected();
		return 'connected';
	}

	public static function activate_license( $key ) {
		$key = trim( (string) $key );
		if ( ! ZeroConfig_Options::is_connected() || ! ZeroConfig_Options::get( 'engine' ) ) {
			// Not connected: the key stays here only. on_connected() sends it after Turn on.
			ZeroConfig_Options::set( 'license_key', $key );
			return array( 'status' => 'saved' );
		}
		$data = self::request( 'POST', 'license/activate', array( 'key' => $key, 'url' => home_url() ) );
		if ( is_wp_error( $data ) ) {
			return $data;
		}
		ZeroConfig_Options::set( 'license_key', $key );
		self::apply_site_payload( $data );
		return $data;
	}

	public static function deactivate_license() {
		$connected = ZeroConfig_Options::is_connected() && ZeroConfig_Options::get( 'engine' );
		if ( $connected ) {
			self::request( 'POST', 'license/deactivate', array( 'url' => home_url() ) );
		}
		ZeroConfig_Options::update( array( 'license_key' => '', 'plan' => 'free' ) );
		if ( $connected ) {
			self::heartbeat();
		}
	}

	private static function heartbeat_body() {
		return array(
			'url'            => home_url(),
			'plugin_version' => ZEROCONFIG_VERSION,
			'wp_version'     => get_bloginfo( 'version' ),
			'engine'         => (bool) ZeroConfig_Options::get( 'engine' ),
			'email'          => self::shared_email(), // '' clears it on the service
			'badge'          => (bool) ZeroConfig_Options::get( 'badge' ),
			'disabled'       => ZeroConfig_Options::get( 'disabled' ),
			'fingerprint'    => ZeroConfig_Compat::fingerprint(),
		);
	}

	/**
	 * Turn off (and deactivation): one last heartbeat with engine false, so the service stops its
	 * scheduled visits to this site. After it nothing is sent until Turn on.
	 */
	public static function heartbeat_off() {
		if ( ! ZeroConfig_Options::is_connected() ) {
			return;
		}
		self::$final_call = true;
		self::request( 'POST', 'sites/heartbeat', self::heartbeat_body(), 5 );
		self::$final_call = false;
	}

	public static function heartbeat() {
		if ( ! ZeroConfig_Options::is_connected() ) {
			$p = ZeroConfig_Options::get( 'pending_reg' );
			return empty( $p['challenge'] ) ? self::register_site() : self::claim_pending();
		}
		$data = self::request( 'POST', 'sites/heartbeat', self::heartbeat_body() );
		if ( is_wp_error( $data ) ) {
			// Token no longer valid (site forgotten, or re-verified from another install): reconnect with a fresh proof.
			$status = (int) ( $data->get_error_data()['status'] ?? 0 );
			if ( 401 === $status ) {
				ZeroConfig_Options::update( array( 'site_token' => '' ) );
				return self::register_site();
			}
			// The service saw this token arrive from another address than the one it was issued for.
			if ( 409 === $status && 'site_mismatch' === ( $data->get_error_data()['data']['code'] ?? '' ) ) {
				self::guard_address( 'site_mismatch' );
			}
			return $data;
		}
		self::apply_site_payload( $data );
		return $data;
	}

	public static function fetch_rules() {
		$data = self::request( 'POST', 'rules', array( 'fingerprint' => ZeroConfig_Compat::fingerprint() ) );
		if ( is_wp_error( $data ) ) {
			return $data;
		}
		ZeroConfig_Options::update( array( 'rules' => ZeroConfig_Compat::clean_rules( $data ), 'rules_fetched' => time() ) );
		return $data;
	}

	public static function request_critical( array $urls ) {
		return self::request( 'POST', 'critical', array( 'urls' => $urls ) );
	}

	public static function get_critical() {
		return self::request( 'GET', 'critical' );
	}

	public static function request_selftest( array $urls, $mode = 'normal' ) {
		return self::request( 'POST', 'selftest', array( 'urls' => $urls, 'mode' => $mode ) );
	}

	public static function get_selftest( $job_id ) {
		return self::request( 'GET', 'selftest/' . rawurlencode( $job_id ) );
	}

	public static function purge() {
		return self::request( 'POST', 'purge', array( 'url' => home_url() ), 10 );
	}

	public static function report_issue( $message, $url = '' ) {
		return self::request(
			'POST',
			'issues',
			array(
				'message'     => (string) $message,
				'url'         => (string) $url,
				'fingerprint' => ZeroConfig_Compat::fingerprint(),
				'state'       => array(
					'features' => ZeroConfig_Options::get( 'features' ),
					'disabled' => ZeroConfig_Options::get( 'disabled' ),
				),
			)
		);
	}

	/**
	 * Critical CSS is printed raw inside <style>. Whatever route it arrives by (heartbeat or the
	 * critical pull), keep only sane sizes and nothing that could close the tag.
	 */
	public static function clean_critical( array $sheets ) {
		$clean = array();
		foreach ( $sheets as $k => $css ) {
			$css = is_string( $css ) ? $css : '';
			if ( '' === sanitize_key( $k ) || count( $clean ) >= 40 ) { // a key nothing can look up; a runaway payload
				continue;
			}
			if ( strlen( $css ) > 200 && strlen( $css ) < 120000 && false === stripos( $css, '</style' ) ) {
				$clean[ sanitize_key( $k ) ] = $css;
			}
		}
		return $clean;
	}

	/**
	 * The CDN address every optimised file is served from. Only https on the service's own domain
	 * (or the API's own host, for a local test setup) is accepted; anything else returns null.
	 */
	public static function clean_cdn_base( $url ) {
		$url  = esc_url_raw( rtrim( (string) $url, '/' ), array( 'https', 'http' ) );
		$host = strtolower( (string) wp_parse_url( $url, PHP_URL_HOST ) );
		$api  = strtolower( (string) wp_parse_url( ZEROCONFIG_API, PHP_URL_HOST ) );
		if ( '' === $host ) {
			return null;
		}
		if ( '' !== $api && $host === $api ) {
			return $url;
		}
		$ours = 'zeroconfigwp.com' === $host || '.zeroconfigwp.com' === substr( $host, -17 );
		return $ours && 0 === strpos( $url, 'https://' ) ? $url : null;
	}

	/** Keep only what the plugin uses from a service answer, each value in its expected type. */
	private static function clean_payload( array $data ) {
		$patch = array();
		if ( isset( $data['site_id'] ) && preg_match( '/^[A-Za-z0-9_-]{1,64}$/', (string) $data['site_id'] ) ) {
			$patch['site_id'] = (string) $data['site_id'];
		}
		if ( isset( $data['site_token'] ) && preg_match( '/^[A-Za-z0-9_-]{16,128}$/', (string) $data['site_token'] ) ) {
			$patch['site_token'] = (string) $data['site_token'];
		}
		if ( isset( $data['plan'] ) ) {
			$plan          = sanitize_key( (string) $data['plan'] );
			$patch['plan'] = in_array( $plan, array( 'free', 'pro', 'business', 'agency' ), true ) ? $plan : 'free';
		}
		if ( array_key_exists( 'cdn_base', $data ) ) {
			$cdn = '' === (string) $data['cdn_base'] ? '' : self::clean_cdn_base( $data['cdn_base'] );
			if ( null !== $cdn ) {
				$patch['cdn_base'] = $cdn;
			}
		}
		if ( isset( $data['features'] ) && is_array( $data['features'] ) ) {
			$patch['features'] = array();
			foreach ( array_keys( ZeroConfig_Options::defaults()['features'] ) as $k ) {
				$patch['features'][ $k ] = ! empty( $data['features'][ $k ] );
			}
		}
		if ( isset( $data['quota'] ) && is_array( $data['quota'] ) ) {
			$patch['quota'] = self::clean_scalars( $data['quota'] );
		}
		if ( array_key_exists( 'cdn_paused', $data ) ) {
			$patch['cdn_paused'] = ! empty( $data['cdn_paused'] );
		}
		if ( isset( $data['last_score'] ) && is_array( $data['last_score'] ) ) {
			$patch['last_score'] = self::clean_scalars( $data['last_score'] );
		}
		return $patch;
	}

	/** A flat map of numbers, booleans and short strings; anything else is dropped. */
	private static function clean_scalars( array $in ) {
		$out = array();
		foreach ( $in as $k => $v ) {
			$k = sanitize_key( (string) $k );
			if ( '' === $k || count( $out ) >= 20 ) {
				continue;
			}
			if ( is_bool( $v ) ) {
				$out[ $k ] = $v;
			} elseif ( is_int( $v ) || is_float( $v ) ) {
				$out[ $k ] = $v;
			} elseif ( is_string( $v ) && strlen( $v ) <= 40 ) {
				$out[ $k ] = sanitize_text_field( $v );
			}
		}
		return $out;
	}

	/** Shared shape returned by register / activate / heartbeat. */
	private static function apply_site_payload( array $data ) {
		$patch = self::clean_payload( $data );
		if ( ! empty( $data['rules'] ) && is_array( $data['rules'] ) ) {
			$patch['rules']         = ZeroConfig_Compat::clean_rules( $data['rules'] );
			$patch['rules_fetched'] = time();
		}
		if ( ! empty( $data['critical_css'] ) && is_array( $data['critical_css'] ) ) {
			$patch['critical_css'] = self::clean_critical( $data['critical_css'] );
		}
		$patch['last_error'] = '';
		// Cached HTML was built for the old plan: a Free → Pro upgrade (new features), a paused or moved
		// CDN, or new compatibility rules must reach visitors now, not when the cached copy expires.
		$changed = false;
		foreach ( array( 'plan', 'features', 'cdn_base', 'cdn_paused', 'rules', 'critical_css' ) as $k ) {
			if ( array_key_exists( $k, $patch ) && $patch[ $k ] != ZeroConfig_Options::get( $k ) ) { // phpcs:ignore Universal.Operators.StrictComparisons -- arrays compared by value
				$changed = true;
			}
		}
		// A feature that was not allowed before (Free → Pro: critical CSS) goes live untested
		// unless a Safety Check follows. The check is what makes turning features on safe.
		$before  = (array) ZeroConfig_Options::get( 'features' );
		$gained  = isset( $patch['features'] ) && is_array( $patch['features'] )
			&& array_diff_key( array_filter( $patch['features'] ), array_filter( $before ) );
		$css_new = isset( $patch['critical_css'] ) && $patch['critical_css'] != ZeroConfig_Options::get( 'critical_css' ); // phpcs:ignore Universal.Operators.StrictComparisons
		ZeroConfig_Options::update( $patch );
		if ( $changed && ZeroConfig_Options::get( 'engine' ) ) {
			ZeroConfig_Page_Cache::purge_all( 'settings' );
		}
		if ( ( $gained || $css_new ) && ZeroConfig_Options::get( 'engine' ) && ZeroConfig_Options::is_connected() ) {
			ZeroConfig_Safe_Mode::schedule( 60 );
		}
	}
}