<?php
/**
 * What the storefront may do: upload a photo, start a try-on, follow it, view and delete results.
 *
 * @package Fitzaro
 */

namespace Fitzaro\Api;

use Fitzaro\Database\Status;
use Fitzaro\Image\InvalidImage;
use Fitzaro\Image\Sanitizer;
use Fitzaro\Prompt\PromptBuilder;
use Fitzaro\Job\Requests;
use Fitzaro\Job\Scheduler;
use Fitzaro\Limits\Limits;
use Fitzaro\Storage\FileStore;
use Fitzaro\Storage\UrlSigner;

defined( 'ABSPATH' ) || exit;

// phpcs:disable WordPress.Security.EscapeOutput.ExceptionNotEscaped -- ApiError carries codes only.

/**
 * No WordPress here, so every access rule is unit-tested.
 *
 * Ownership: a request belongs to the visitor (cookie hash) that started it, and also to the
 * logged-in user who started it. Anything a caller does not own is reported as NOT_FOUND, so IDs
 * cannot be probed.
 *
 * A photo reference is "{uuid}.{expires}.{token}": the token binds the file to the visitor and the
 * expiry, so it cannot be reused by anyone else or after it lapses.
 */
final class TryOnService {

	/**
	 * Seconds a photo reference stays usable.
	 */
	public const PHOTO_LIFETIME = 7200;

	private const PHOTO_KIND  = 'photo';
	private const RESULT_KIND = 'result';
	private const PHOTO_REF   = '/\A([0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})\.(\d{10})\.([A-Za-z0-9_-]{43})\z/';

	/**
	 * Request storage.
	 *
	 * @var Requests
	 */
	private $requests;

	/**
	 * Private files.
	 *
	 * @var FileStore
	 */
	private $files;

	/**
	 * Photo sanitiser.
	 *
	 * @var Sanitizer
	 */
	private $sanitizer;

	/**
	 * Signs photo references and image links.
	 *
	 * @var UrlSigner
	 */
	private $signer;

	/**
	 * Background queue.
	 *
	 * @var Scheduler
	 */
	private $scheduler;

	/**
	 * Receives ( product ID, variation ID ), returns null when try-on is allowed or a reason code.
	 *
	 * @var callable
	 */
	private $product_check;

	/**
	 * Returns the active provider ID, or null.
	 *
	 * @var callable
	 */
	private $provider;

	/**
	 * Try-on, upload and spending limits.
	 *
	 * @var Limits
	 */
	private $limits;

	/**
	 * Returns the current Unix time.
	 *
	 * @var callable
	 */
	private $clock;

	/**
	 * Creates the service.
	 *
	 * @param Requests  $requests      Request storage.
	 * @param FileStore $files         Private files.
	 * @param Sanitizer $sanitizer     Photo sanitiser.
	 * @param UrlSigner $signer        Signs photo references and image links.
	 * @param Scheduler $scheduler     Background queue.
	 * @param callable  $product_check Receives ( product ID, variation ID ), returns null or a reason code.
	 * @param callable  $provider      Returns the active provider ID, or null.
	 * @param Limits    $limits        Try-on, upload and spending limits.
	 * @param callable  $clock         Returns the current Unix time.
	 */
	public function __construct( Requests $requests, FileStore $files, Sanitizer $sanitizer, UrlSigner $signer, Scheduler $scheduler, callable $product_check, callable $provider, Limits $limits, callable $clock ) {
		$this->requests      = $requests;
		$this->files         = $files;
		$this->sanitizer     = $sanitizer;
		$this->signer        = $signer;
		$this->scheduler     = $scheduler;
		$this->product_check = $product_check;
		$this->provider      = $provider;
		$this->limits        = $limits;
		$this->clock         = $clock;
	}

	/**
	 * Sanitises and stores a shopper photo.
	 *
	 * @param string $bytes   Uploaded file content.
	 * @param string $visitor Visitor hash.
	 * @param string $ip      IP hash, '' when unknown.
	 * @return array{photo: string, expires: int}
	 * @throws ApiError When the photo is rejected or cannot be stored.
	 */
	public function upload_photo( string $bytes, string $visitor, string $ip ): array {
		if ( ! $this->limits->allow_upload( $ip ) ) {
			throw new ApiError( ApiError::LIMIT_REACHED, Limits::UPLOADS );
		}

		try {
			$jpeg = $this->sanitizer->sanitize( $bytes );
		} catch ( InvalidImage $e ) {
			throw new ApiError( ApiError::INVALID_PHOTO, $e->reason() );
		}

		try {
			$path = $this->files->put( FileStore::UPLOADS, $jpeg );
		} catch ( \Throwable $e ) {
			throw new ApiError( ApiError::STORAGE_FAILED );
		}

		$uuid    = substr( $path, strlen( FileStore::UPLOADS ) + 1, 36 );
		$expires = $this->now() + self::PHOTO_LIFETIME;

		return array(
			'photo'   => $uuid . '.' . $expires . '.' . $this->signer->token( $uuid, self::PHOTO_KIND, $visitor, $expires ),
			'expires' => $expires,
		);
	}

	/**
	 * Deletes a photo of the visitor.
	 *
	 * @param string $photo   Photo reference.
	 * @param string $visitor Visitor hash.
	 * @throws ApiError NOT_FOUND when the reference is not the visitor's.
	 */
	public function delete_photo( string $photo, string $visitor ): void {
		$path = $this->photo_path( $photo, $visitor );
		if ( null === $path ) {
			throw new ApiError( ApiError::NOT_FOUND );
		}

		$this->files->delete( $path );
	}

	/**
	 * Starts a try-on.
	 *
	 * @param string $visitor      Visitor hash.
	 * @param string $ip           IP hash, '' when unknown.
	 * @param int    $user_id      Logged-in user, 0 for guests.
	 * @param string $photo        Photo reference.
	 * @param int    $product_id   Product.
	 * @param int    $variation_id Variation, 0 for none.
	 * @return array{id: string, status: string}
	 * @throws ApiError When the try-on cannot start.
	 */
	public function start( string $visitor, string $ip, int $user_id, string $photo, int $product_id, int $variation_id ): array {
		$provider = ( $this->provider )();
		if ( ! is_string( $provider ) || '' === $provider ) {
			throw new ApiError( ApiError::UNAVAILABLE );
		}

		$path = $this->photo_path( $photo, $visitor );
		if ( null === $path || null === $this->files->file( $path ) ) {
			throw new ApiError( ApiError::PHOTO_EXPIRED );
		}

		$problem = ( $this->product_check )( $product_id, $variation_id );
		if ( null !== $problem ) {
			throw new ApiError( ApiError::PRODUCT_UNAVAILABLE, (string) $problem );
		}

		if ( $this->requests->active_for_visitor( $visitor ) > 0 ) {
			throw new ApiError( ApiError::BUSY );
		}

		$limit = $this->limits->tryon_problem( $visitor, $ip );
		if ( null !== $limit ) {
			throw new ApiError( ApiError::LIMIT_REACHED, $limit );
		}

		$id = $this->requests->create(
			array(
				'visitor_hash'   => $visitor,
				'ip_hash'        => $ip,
				'user_id'        => max( 0, $user_id ),
				'product_id'     => $product_id,
				'variation_id'   => max( 0, $variation_id ),
				'upload_path'    => $path,
				'provider'       => $provider,
				'prompt_version' => PromptBuilder::VERSION,
			)
		);
		$this->scheduler->run_now( $id );

		return array(
			'id'     => $id,
			'status' => Status::QUEUED,
		);
	}

	/**
	 * Public state of a request.
	 *
	 * @param string $id      Request UUID.
	 * @param string $visitor Visitor hash.
	 * @param int    $user_id Logged-in user, 0 for guests.
	 * @return array{id: string, status: string, error: string|null, image: array{expires: int, token: string}|null}
	 * @throws ApiError NOT_FOUND when the caller does not own it.
	 */
	public function status( string $id, string $visitor, int $user_id ): array {
		$row    = $this->owned( $id, $visitor, $user_id );
		$status = (string) $row['status'];
		$image  = null;

		if ( Status::DONE === $status && '' !== (string) ( $row['result_path'] ?? '' ) ) {
			$expires = $this->signer->expires_at();
			$image   = array(
				'expires' => $expires,
				'token'   => $this->signer->token( $id, self::RESULT_KIND, $visitor, $expires ),
			);
		}

		$error = $row['error'] ?? null;

		return array(
			'id'     => $id,
			'status' => $status,
			'error'  => Status::FAILED === $status && is_string( $error ) && '' !== $error ? $error : null,
			'image'  => $image,
		);
	}

	/**
	 * Absolute path of a result image, for a valid signed link.
	 *
	 * @param string $id      Request UUID.
	 * @param string $visitor Visitor hash.
	 * @param int    $user_id Logged-in user, 0 for guests.
	 * @param int    $expires Expiry from the link.
	 * @param string $token   Token from the link.
	 * @throws ApiError NOT_FOUND for anything but a valid link to an existing result.
	 */
	public function image( string $id, string $visitor, int $user_id, int $expires, string $token ): string {
		$row = $this->owned( $id, $visitor, $user_id );

		if ( ! $this->signer->verify( $id, self::RESULT_KIND, $visitor, $expires, $token ) ) {
			throw new ApiError( ApiError::NOT_FOUND );
		}

		$file = Status::DONE === $row['status'] ? $this->files->file( (string) ( $row['result_path'] ?? '' ) ) : null;
		if ( null === $file ) {
			throw new ApiError( ApiError::NOT_FOUND );
		}

		return $file;
	}

	/**
	 * Cancels a request and deletes its result.
	 *
	 * @param string $id      Request UUID.
	 * @param string $visitor Visitor hash.
	 * @param int    $user_id Logged-in user, 0 for guests.
	 * @throws ApiError NOT_FOUND when the caller does not own it.
	 */
	public function discard( string $id, string $visitor, int $user_id ): void {
		$row = $this->owned( $id, $visitor, $user_id );

		$this->requests->discard( $id, gmdate( 'Y-m-d H:i:s', $this->now() ) );
		$this->files->delete( (string) ( $row['result_path'] ?? '' ) );
	}

	/**
	 * The row, when the caller owns it.
	 *
	 * @param string $id      Request UUID.
	 * @param string $visitor Visitor hash.
	 * @param int    $user_id Logged-in user, 0 for guests.
	 * @return array<string, mixed>
	 * @throws ApiError NOT_FOUND otherwise.
	 */
	private function owned( string $id, string $visitor, int $user_id ): array {
		$row = $this->requests->find( $id );

		if ( null !== $row ) {
			$by_visitor = '' !== $visitor && hash_equals( (string) $row['visitor_hash'], $visitor );
			$by_user    = $user_id > 0 && (int) $row['user_id'] === $user_id;

			if ( $by_visitor || $by_user ) {
				return $row;
			}
		}

		throw new ApiError( ApiError::NOT_FOUND );
	}

	/**
	 * Stored path of a valid, unexpired photo reference of this visitor, or null.
	 *
	 * @param string $photo   Photo reference.
	 * @param string $visitor Visitor hash.
	 */
	private function photo_path( string $photo, string $visitor ): ?string {
		if ( '' === $visitor || 1 !== preg_match( self::PHOTO_REF, $photo, $parts ) ) {
			return null;
		}

		if ( ! $this->signer->verify( $parts[1], self::PHOTO_KIND, $visitor, (int) $parts[2], $parts[3] ) ) {
			return null;
		}

		return FileStore::UPLOADS . '/' . $parts[1] . '.jpg';
	}

	/**
	 * Current Unix time.
	 */
	private function now(): int {
		return (int) ( $this->clock )();
	}
}