<?php
/**
 * Receives Fabrixa fulfilment webhooks (order.created / order.updated).
 *
 * The endpoint mutates orders, so an unverified request must never reach the
 * handler: the signature check lives in the permission callback, and a missing
 * shared secret fails closed rather than open. Comparison uses hash_equals() so
 * the response time cannot be used to guess the signature byte by byte.
 *
 * Orders reach Fabrixa through the shop's channel connection, not through this
 * plugin, so the first event about an order usually arrives before the shop
 * holds any Fabrixa id for it. It is matched on the order number Fabrixa sends,
 * which the channel took from WooCommerce; the id is recorded then and later
 * events match on it directly.
 *
 * Endpoint: POST /wp-json/fabrixa-studio/v1/webhook
 *
 * @package Fabrixa_Studio
 */

if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

class Fabrixa_Webhook {

	const REST_NAMESPACE    = 'fabrixa-studio/v1';
	const REST_ROUTE        = '/webhook';
	const SIGNATURE_HEADER  = 'x-webhook-signature';
	const META_REMOTE_ID    = '_fabrixa_remote_order_id';
	const META_REMOTE_NUM   = '_fabrixa_remote_order_number';
	const META_FULFILLMENT  = '_fabrixa_fulfillment_status';
	const META_REMOTE_STATE = '_fabrixa_remote_status';
	const META_TRACKING     = '_fabrixa_tracking';

	/**
	 * Custom wc_get_orders() argument carrying a Fabrixa order id.
	 *
	 * The legacy posts datastore only understands it because cpt_query_remote_id()
	 * translates it, so the two must agree.
	 */
	const QUERY_VAR_REMOTE_ID = 'fabrixa_remote_id';

	private static $instance = null;

	public static function instance() {
		if ( null === self::$instance ) {
			self::$instance = new self();
		}
		return self::$instance;
	}

	private function __construct() {
		add_action( 'rest_api_init', array( $this, 'register_route' ) );
		add_filter( 'woocommerce_order_data_store_cpt_get_orders_query', array( $this, 'cpt_query_remote_id' ), 10, 2 );

		// Surface what Fabrixa reported where merchants already look for order problems.
		add_action( 'woocommerce_admin_order_data_after_order_details', array( $this, 'render_admin_status' ) );
	}

	/**
	 * WooCommerce statuses a fulfilled order may be completed from.
	 *
	 * Fabrixa reporting "shipped" for an order that is still pending payment or
	 * on hold would be odd, and completing it would hide that; only an order the
	 * shop itself considers paid is moved on.
	 *
	 * @return string[]
	 */
	private static function completable_statuses() {
		/**
		 * Filter the WooCommerce statuses from which a Fabrixa-fulfilled order is completed.
		 *
		 * @since 0.4.0
		 *
		 * @param string[] $statuses Default `processing`.
		 */
		return (array) apply_filters( 'fabrixa_completable_statuses', array( 'processing' ) );
	}

	/**
	 * Whether orders live in the High Performance Order Storage tables.
	 *
	 * @return bool
	 */
	private static function hpos_enabled() {
		return class_exists( \Automattic\WooCommerce\Utilities\OrderUtil::class )
			&& \Automattic\WooCommerce\Utilities\OrderUtil::custom_orders_table_usage_is_enabled();
	}

	/**
	 * Teach the legacy posts datastore to look an order up by its Fabrixa id.
	 *
	 * WooCommerce 9.2 made passing `meta_query` straight to wc_get_orders() a
	 * doing-it-wrong notice on that datastore, because the argument describes the
	 * posts tables rather than orders. A custom query var translated here is the
	 * supported replacement; HPOS needs none, it takes `meta_query` itself.
	 *
	 * @param array $query      WP_Query arguments being built.
	 * @param array $query_vars Arguments passed to wc_get_orders().
	 * @return array
	 */
	public function cpt_query_remote_id( $query, $query_vars ) {
		if ( ! empty( $query_vars[ self::QUERY_VAR_REMOTE_ID ] ) ) {
			$query['meta_query'][] = array( // phpcs:ignore WordPress.DB.SlowDBQuery.slow_db_query_meta_query
				'key'     => self::META_REMOTE_ID,
				'value'   => (string) $query_vars[ self::QUERY_VAR_REMOTE_ID ],
				'compare' => '=',
			);
		}

		return $query;
	}

	/**
	 * Full URL to paste into the Fabrixa dashboard.
	 *
	 * @return string
	 */
	public static function url() {
		return rest_url( self::REST_NAMESPACE . self::REST_ROUTE );
	}

	public function register_route() {
		register_rest_route(
			self::REST_NAMESPACE,
			self::REST_ROUTE,
			array(
				'methods'             => 'POST',
				'callback'            => array( $this, 'handle' ),
				'permission_callback' => array( $this, 'verify_signature' ),
			)
		);
	}

	/* ---------- Authentication ---------- */

	/**
	 * @param WP_REST_Request $request Incoming request.
	 * @return true|WP_Error
	 */
	public function verify_signature( $request ) {
		$secret = Fabrixa_Settings::webhook_secret();
		if ( empty( $secret ) ) {
			Fabrixa_API::log( 'Webhook rejected: no shared secret configured.', 'error' );
			return new WP_Error(
				'fabrixa_webhook_unconfigured',
				__( 'Fabrixa webhook secret is not configured.', 'fabrixa-studio' ),
				array( 'status' => 401 )
			);
		}

		$provided = $request->get_header( self::SIGNATURE_HEADER );
		if ( empty( $provided ) ) {
			Fabrixa_API::log( 'Webhook rejected: signature header missing.', 'warning' );
			return new WP_Error(
				'fabrixa_webhook_unsigned',
				__( 'Missing webhook signature.', 'fabrixa-studio' ),
				array( 'status' => 401 )
			);
		}

		// Sign the raw body: re-encoding the parsed JSON would change the bytes.
		$expected = base64_encode( hash_hmac( 'sha256', $request->get_body(), $secret, true ) );

		if ( ! hash_equals( $expected, trim( $provided ) ) ) {
			Fabrixa_API::log( 'Webhook rejected: signature mismatch.', 'warning' );
			return new WP_Error(
				'fabrixa_webhook_bad_signature',
				__( 'Invalid webhook signature.', 'fabrixa-studio' ),
				array( 'status' => 401 )
			);
		}

		return true;
	}

	/* ---------- Handling ---------- */

	/**
	 * @param WP_REST_Request $request Verified request.
	 * @return WP_REST_Response
	 */
	public function handle( $request ) {
		$payload = json_decode( $request->get_body(), true );
		if ( ! is_array( $payload ) ) {
			return new WP_REST_Response( array( 'success' => false, 'error' => 'invalid_json' ), 400 );
		}

		$topic = $request->get_header( 'x-webhook-topic' );
		if ( empty( $topic ) ) {
			$topic = isset( $payload['topic'] ) ? $payload['topic'] : ( isset( $payload['event'] ) ? $payload['event'] : '' );
		}

		// Some senders nest the entity; accept both shapes.
		$data  = isset( $payload['data'] ) && is_array( $payload['data'] ) ? $payload['data'] : $payload;
		$order = $this->find_order( $data );

		if ( ! $order ) {
			// 200 on purpose: this order is not ours, so retrying will never help.
			Fabrixa_API::log(
				sprintf(
					'Webhook (%s) had no matching local order. Fabrixa id: %s, number: %s.',
					$topic ? $topic : 'unknown topic',
					isset( $data['id'] ) ? $data['id'] : '—',
					isset( $data['number'] ) ? $data['number'] : '—'
				),
				'warning'
			);
			return new WP_REST_Response( array( 'success' => true, 'matched' => false ), 200 );
		}

		$this->apply_state( $order, $data, $topic );

		/**
		 * Fires after a verified Fabrixa webhook has been applied to an order.
		 *
		 * @since 0.2.0
		 *
		 * @param WC_Order $order Local order.
		 * @param array    $data  Remote order entity.
		 * @param string   $topic Event topic.
		 */
		do_action( 'fabrixa_webhook_received', $order, $data, $topic );

		return new WP_REST_Response( array( 'success' => true, 'matched' => true, 'order_id' => $order->get_id() ), 200 );
	}

	/**
	 * Resolve the local order: first by the Fabrixa id recorded from an earlier
	 * event, then by the order number, which the channel took from WooCommerce.
	 *
	 * @param array $data Remote order entity.
	 * @return WC_Order|null
	 */
	private function find_order( array $data ) {
		if ( ! empty( $data['id'] ) ) {
			$args = array(
				'limit'  => 1,
				'return' => 'ids',
				'status' => 'any',
			);

			if ( self::hpos_enabled() ) {
				$args['meta_query'] = array( // phpcs:ignore WordPress.DB.SlowDBQuery.slow_db_query_meta_query
					array(
						'key'     => self::META_REMOTE_ID,
						'value'   => (string) $data['id'],
						'compare' => '=',
					),
				);
			} else {
				$args[ self::QUERY_VAR_REMOTE_ID ] = (string) $data['id'];
			}

			$orders = wc_get_orders( $args );

			if ( ! empty( $orders ) ) {
				$order = wc_get_order( $orders[0] );

				/*
				 * Confirm the match rather than trusting the query. An argument a
				 * datastore does not understand is ignored rather than refused, and
				 * an ignored filter here would return the newest order instead of
				 * none — applying a webhook to somebody else's order.
				 */
				if ( $order && (string) $order->get_meta( self::META_REMOTE_ID ) === (string) $data['id'] ) {
					return $order;
				}
			}
		}

		if ( ! empty( $data['number'] ) ) {
			/**
			 * Resolve a Fabrixa order number to a local order id.
			 *
			 * Default WooCommerce order numbers are ids; a plugin that changes
			 * that scheme hooks this to resolve its own.
			 *
			 * @since 0.2.0
			 *
			 * @param int    $order_id Resolved order id, 0 when unresolved.
			 * @param string $number   Order number as Fabrixa sent it.
			 */
			$order_id = apply_filters( 'fabrixa_resolve_order_number', 0, (string) $data['number'] );
			if ( ! $order_id && is_numeric( $data['number'] ) ) {
				$order_id = (int) $data['number'];
			}

			$order = $order_id ? wc_get_order( $order_id ) : null;
			if ( $order && (string) $order->get_order_number() === (string) $data['number'] ) {
				return $order;
			}
		}

		return null;
	}

	/**
	 * Store the remote state, record tracking, and complete the order once
	 * Fabrixa reports it shipped.
	 *
	 * @param WC_Order $order Local order.
	 * @param array    $data  Remote order entity.
	 * @param string   $topic Event topic.
	 */
	private function apply_state( $order, array $data, $topic ) {
		$fulfillment = isset( $data['fulfillment_status'] ) ? (string) $data['fulfillment_status'] : '';
		$remote      = isset( $data['status'] ) ? (string) $data['status'] : '';
		$previous    = (string) $order->get_meta( self::META_FULFILLMENT );

		if ( '' !== $remote ) {
			$order->update_meta_data( self::META_REMOTE_STATE, $remote );
		}
		if ( '' !== $fulfillment ) {
			$order->update_meta_data( self::META_FULFILLMENT, $fulfillment );
		}

		// Record the Fabrixa ids the first time an event names them. Orders reach
		// Fabrixa through the channel connection, so this is normally the first
		// the shop hears of them; later events then match on the id directly.
		if ( ! empty( $data['id'] ) && ! $order->get_meta( self::META_REMOTE_ID ) ) {
			$order->update_meta_data( self::META_REMOTE_ID, (string) $data['id'] );
		}
		if ( ! empty( $data['number'] ) && ! $order->get_meta( self::META_REMOTE_NUM ) ) {
			$order->update_meta_data( self::META_REMOTE_NUM, (string) $data['number'] );
		}

		$tracking = $this->collect_tracking( $data );
		if ( $tracking ) {
			$order->update_meta_data( self::META_TRACKING, $tracking );
		}

		// Only note real changes, so repeated deliveries don't spam the order.
		if ( $fulfillment !== $previous || $tracking ) {
			$note = sprintf(
				/* translators: 1: event topic, 2: remote status, 3: fulfilment status. */
				__( 'Fabrixa update (%1$s): status %2$s, fulfilment %3$s.', 'fabrixa-studio' ),
				$topic ? $topic : 'order.updated',
				'' !== $remote ? $remote : '—',
				'' !== $fulfillment ? $fulfillment : '—'
			);

			foreach ( $tracking as $entry ) {
				$note .= "\n" . sprintf(
					/* translators: 1: carrier/method name, 2: tracking number. */
					__( 'Tracking — %1$s: %2$s', 'fabrixa-studio' ),
					$entry['method'] ? $entry['method'] : '—',
					$entry['number'] ? $entry['number'] : '—'
				);
				if ( $entry['url'] ) {
					$note .= ' ' . $entry['url'];
				}
			}

			$order->add_order_note( $note );
		}

		$order->save();

		if ( $this->is_fulfilled( $fulfillment ) && $order->has_status( self::completable_statuses() ) ) {
			/**
			 * Whether a Fabrixa-fulfilled order should be marked complete locally.
			 *
			 * @since 0.2.0
			 *
			 * @param bool     $complete Default true.
			 * @param WC_Order $order    Local order.
			 * @param array    $data     Remote order entity.
			 */
			if ( apply_filters( 'fabrixa_complete_order_on_fulfillment', true, $order, $data ) && ! $order->has_status( 'completed' ) ) {
				$order->update_status(
					'completed',
					__( 'Fabrixa reported the order as fulfilled.', 'fabrixa-studio' )
				);
			}
		}
	}

	/* ---------- Admin ---------- */

	/**
	 * Show what Fabrixa has reported about this order on the edit screen.
	 *
	 * @param WC_Order $order Order being edited.
	 */
	public function render_admin_status( $order ) {
		$remote_id   = $order->get_meta( self::META_REMOTE_ID );
		$remote      = $order->get_meta( self::META_REMOTE_STATE );
		$fulfillment = $order->get_meta( self::META_FULFILLMENT );
		if ( ! $remote_id && ! $remote && ! $fulfillment ) {
			return;
		}
		?>
		<p class="form-field form-field-wide">
			<strong><?php esc_html_e( 'Fabrixa', 'fabrixa-studio' ); ?>:</strong>
			<?php if ( $remote_id ) : ?>
				<?php esc_html_e( 'order id', 'fabrixa-studio' ); ?> <code><?php echo esc_html( $remote_id ); ?></code>
			<?php endif; ?>
			<?php if ( $remote ) : ?>
				<br /><span class="description"><?php esc_html_e( 'Status:', 'fabrixa-studio' ); ?> <code><?php echo esc_html( $remote ); ?></code></span>
			<?php endif; ?>
			<?php if ( $fulfillment ) : ?>
				<br /><span class="description"><?php esc_html_e( 'Fulfilment:', 'fabrixa-studio' ); ?> <code><?php echo esc_html( $fulfillment ); ?></code></span>
			<?php endif; ?>
		</p>
		<?php
	}

	/**
	 * Tracking details, which may arrive per row or once for the whole order.
	 *
	 * @param array $data Remote order entity.
	 * @return array[] Each entry: method, number, url.
	 */
	private function collect_tracking( array $data ) {
		$labels = array();

		if ( ! empty( $data['shipping_label'] ) && is_array( $data['shipping_label'] ) ) {
			$labels[] = $data['shipping_label'];
		}

		if ( ! empty( $data['rows'] ) && is_array( $data['rows'] ) ) {
			foreach ( $data['rows'] as $row ) {
				if ( ! empty( $row['shipping_label'] ) && is_array( $row['shipping_label'] ) ) {
					$labels[] = $row['shipping_label'];
				}
			}
		}

		$tracking = array();
		foreach ( $labels as $label ) {
			$number = isset( $label['tracking_number'] ) ? (string) $label['tracking_number'] : '';
			if ( '' === $number ) {
				continue;
			}
			$tracking[ $number ] = array(
				'method' => isset( $label['method_name'] ) ? (string) $label['method_name'] : '',
				'number' => $number,
				'url'    => isset( $label['tracking_url'] ) ? esc_url_raw( $label['tracking_url'] ) : '',
			);
		}

		return array_values( $tracking );
	}

	/**
	 * @param string $fulfillment Remote fulfilment status.
	 * @return bool
	 */
	private function is_fulfilled( $fulfillment ) {
		if ( '' === $fulfillment ) {
			return false;
		}

		/**
		 * Remote fulfilment statuses that count as "Fabrixa has shipped it".
		 *
		 * @since 0.2.0
		 *
		 * @param string[] $statuses Fulfilment statuses treated as complete.
		 */
		$done = (array) apply_filters(
			'fabrixa_fulfilled_statuses',
			array( 'shipped', 'delivered', 'fulfilled', 'complete', 'completed' )
		);

		return in_array( strtolower( $fulfillment ), array_map( 'strtolower', $done ), true );
	}
}