<?php
/**
 * Wraps wp_remote_* with a hard timeout and controlled retries.
 *
 * On shared hosting, an HTTP call without a timeout is the fastest way to keep a PHP worker
 * stuck until the server kills the request. Every outbound call in AI House must go through
 * this class.
 *
 * @package AI House
 */

defined( 'ABSPATH' ) || exit;

/**
 * Class MYBOT_HTTP
 */
class MYBOT_HTTP {

	/**
	 * Maximum allowed timeout in seconds. Higher values are clamped down.
	 *
	 * @var int
	 */
	const MAX_TIMEOUT = 20;

	/**
	 * Sends a POST request with JSON and returns the decoded array.
	 *
	 * @param string $url     URL.
	 * @param array  $body    Data that will be passed to json_encode.
	 * @param array  $headers Additional headers.
	 * @param int    $timeout Maximum number of seconds.
	 * @param int    $retries Number of retries on network errors or 5xx responses.
	 * @return array|WP_Error
	 */
	public static function post_json( $url, $body, $headers = array(), $timeout = 8, $retries = 0 ) {
		return self::request( 'POST', $url, $headers, wp_json_encode( $body ), $timeout, $retries );
	}

	/**
	 * Sends a GET request and returns the decoded array.
	 *
	 * @param string $url     URL.
	 * @param array  $headers Additional headers.
	 * @param int    $timeout Maximum number of seconds.
	 * @param int    $retries Number of retries.
	 * @return array|WP_Error
	 */
	public static function get_json( $url, $headers = array(), $timeout = 8, $retries = 0 ) {
		return self::request( 'GET', $url, $headers, null, $timeout, $retries );
	}

	/**
	 * Sends a PATCH request and returns the decoded array (1.22.8).
	 *
	 * The request mirror needs it: the status of a request changes after it is stored, and PostgREST updates a row with
	 * PATCH. Added here rather than calling `request()` from the caller, because that method is protected and making it
	 * public would invite every other class to invent its own HTTP layer.
	 *
	 * @param string $url     URL.
	 * @param mixed  $body    Body, encoded as JSON.
	 * @param array  $headers Headers.
	 * @param int    $timeout Maximum number of seconds.
	 * @param int    $retries Number of retries.
	 * @return array|WP_Error
	 */
	public static function patch_json( $url, $body, $headers = array(), $timeout = 8, $retries = 0 ) {
		return self::request( 'PATCH', $url, $headers, wp_json_encode( $body ), $timeout, $retries );
	}

	/**
	 * Performs the request.
	 *
	 * @param string      $method  HTTP method.
	 * @param string      $url     URL.
	 * @param array       $headers Headers.
	 * @param string|null $body    Request body.
	 * @param int         $timeout Maximum number of seconds.
	 * @param int         $retries Number of retries.
	 * @return array|WP_Error
	 */
	protected static function request( $method, $url, $headers, $body, $timeout, $retries ) {
		$timeout = max( 1, min( self::MAX_TIMEOUT, (int) $timeout ) );
		$attempt = 0;

		$args = array(
			'method'      => $method,
			'timeout'     => $timeout,
			'redirection' => 0,
			'sslverify'   => true,
			'blocking'    => true,
			'headers'     => array_merge(
				array(
					'Accept'     => 'application/json',
					'User-Agent' => 'AI House/' . MYBOT_VERSION . '; ' . home_url(),
				),
				$headers
			),
		);

		if ( null !== $body ) {
			$args['body']                    = $body;
			$args['headers']['Content-Type'] = 'application/json';
		}

		while ( true ) {
			++$attempt;

			$response = wp_remote_request( $url, $args );

			if ( is_wp_error( $response ) ) {
				if ( $attempt <= $retries ) {
					self::backoff( $attempt );
					continue;
				}

				return new WP_Error(
					'mybot_http_error',
					$response->get_error_message(),
					array( 'attempts' => $attempt )
				);
			}

			$code = (int) wp_remote_retrieve_response_code( $response );
			$raw  = wp_remote_retrieve_body( $response );

			if ( $code >= 500 && $attempt <= $retries ) {
				self::backoff( $attempt );
				continue;
			}

			$decoded = json_decode( $raw, true );

			if ( $code < 200 || $code >= 300 ) {
				return new WP_Error(
					'mybot_http_status',
					self::extract_error_message( $decoded, $code ),
					array(
						'status'   => $code,
						'response' => $decoded,
					)
				);
			}

			if ( null === $decoded && '' !== trim( (string) $raw ) ) {
				return new WP_Error( 'mybot_http_json', __( 'The response is not valid JSON.', 'aihouse' ) );
			}

			return is_array( $decoded ) ? $decoded : array();
		}
	}

	/**
	 * Extracts a readable error message from the response.
	 *
	 * @param mixed $decoded Decoded data.
	 * @param int   $code    HTTP status code.
	 * @return string
	 */
	protected static function extract_error_message( $decoded, $code ) {
		if ( is_array( $decoded ) ) {
			if ( isset( $decoded['error']['message'] ) ) {
				return (string) $decoded['error']['message'];
			}

			if ( isset( $decoded['message'] ) && is_string( $decoded['message'] ) ) {
				return $decoded['message'];
			}

			if ( isset( $decoded['error'] ) && is_string( $decoded['error'] ) ) {
				return $decoded['error'];
			}
		}

		/* translators: %d: HTTP status code */
		return sprintf( __( 'The provider returned HTTP %d.', 'aihouse' ), $code );
	}

	/**
	 * Waits with exponential backoff before retrying.
	 *
	 * @param int $attempt Current attempt number.
	 * @return void
	 */
	protected static function backoff( $attempt ) {
		$microseconds = (int) ( 250000 * pow( 2, max( 0, $attempt - 1 ) ) );

		// Only used in background tasks, never on the hot path.
		usleep( min( $microseconds, 2000000 ) );
	}
}