<?php

namespace seekat\API\Future;

use Amp\Deferred as AmpDeferred;
use Amp\Promise as AmpPromise;
use React\Promise\Deferred as ReactDeferred;
use React\Promise\PromiseInterface as ReactPromise;
use seekat\API\Future;

/**
 * @param Future $future
 * @param mixed $value
 * @return mixed promise
 */
function resolve(Future $future, $value) {
	$promisor = $future->createContext();
	$future->resolve($promisor, $value);
	return $future->getPromise($promisor);
}

/**
 * @param Future $future
 * @param mixed $reason
 * @return mixed promise
 */
function reject(Future $future, $reason) {
	$promisor = $future->createContext();
	$future->reject($promisor, $reason);
	return $future->getPromise($promisor);
}

/**
 * @param Future $future
 * @param mixed $context Promisor
 * @return \Closure
 */
function resolver(Future $future, $context) {
	return function($value) use($future, $context) {
		$future->resolve($context, $value);
	};
}

/**
 * @param Future $future
 * @param mixed $context Promisor
 * @return \Closure
 */
function rejecter(Future $future, $context) {
	return function($reason) use($future, $context) {
		$future->reject($context, $reason);
	};
}

/**
 * @param Future $future
 * @param mixed $context Promisor
 * @return \Closure
 */
function reducer(Future $future, $context) {
	return function(array $promises) use($future, $context) {
		return $future->all($context, $promises);
	};
}

/**
 * @return Future
 */
function react() {
	return new class implements Future {
		/**
		 * @param callable|null $onCancel
		 * @return ReactDeferred
		 */
		function createContext(callable $onCancel = null) {
			return new ReactDeferred($onCancel);
		}

		function getPromise($context) {
			/* @var $context ReactDeferred */
			return $context->promise();
		}

		function isPromise($promise) : bool {
			return $promise instanceof ReactPromise;
		}

		function handlePromise($promise, callable $onResult = null, callable $onError = null) {
			return $promise->then($onResult, $onError);
		}

		function cancelPromise($promise) {
			/* @var $promise \React\Promise\Promise */
			$promise->cancel();
		}

		function resolve($context, $value) {
			/* @var $context ReactDeferred */
			$context->resolve($value);
		}

		function reject($context, $reason) {
			/* @var $context ReactDeferred */
			$context->reject($reason);
		}

		function all($context, array $promises) {
			return \React\Promise\all($promises);
		}
	};
}

/**
 * @return Future
 */
function amp() {
	return new class implements Future {
		/**
		 * @return AmpDeferred
		 */
		function createContext(callable $onCancel = null) {
			$context = new AmpDeferred();
			/** @noinspection PhpUndefinedFieldInspection */
			$context->promise()->cancel = function() use($onCancel, $context) {
				$onCancel();
			};
			return $context;
		}

		function getPromise($context) {
			/* @var $context AmpDeferred */
			return $context->promise();
		}

		function isPromise($promise) : bool {
			return $promise instanceof AmpPromise;
		}

		function handlePromise($promise, callable $onResult = null, callable $onError = null) {
			$promise->onResolve(function($error = null, $result = null) use($onResult, $onError) {
				if ($error) {
					if ($onError) {
						$onError($error);
					}
				} else {
					if ($onResult) {
						$onResult($result);
					}
				}
			});
			return $promise;
		}

		function cancelPromise($promise) {
			/** @var $promise AmpPromise */
			/** @noinspection PhpUndefinedFieldInspection */
			($promise->cancel)();
		}

		function resolve($context, $value) {
			/* @var $context AmpDeferred */
			$context->resolve($value);
		}

		function reject($context, $reason) {
			/* @var $context AmpDeferred */
			$context->fail(\seekat\Exception\exception($reason));
		}

		function all($context, array $promises) {
			return \Amp\Promise\all($promises);
		}
	};
}