<?php

namespace GuzzleHttp;

use GuzzleHttp\Event\CompleteEvent;
use GuzzleHttp\Event\ErrorEvent;
use GuzzleHttp\Event\RequestEvents;
use GuzzleHttp\Message\ResponseInterface;
use GuzzleHttp\UriTemplate;

/**
 * Send a custom request
 *
 * @param string $method  HTTP request method
 * @param string $url     URL of the request
 * @param array  $options Options to use with the request.
 *
 * @return ResponseInterface
 */
function request($method, $url, array $options = [])
{
    static $client;
    if (!$client) {
        $client = new Client();
    }

    return $client->send($client->createRequest($method, $url, $options));
}

/**
 * Send a GET request
 *
 * @param string $url     URL of the request
 * @param array  $options Array of request options
 *
 * @return ResponseInterface
 */
function get($url, array $options = [])
{
    return request('GET', $url, $options);
}

/**
 * Send a HEAD request
 *
 * @param string $url     URL of the request
 * @param array  $options Array of request options
 *
 * @return ResponseInterface
 */
function head($url, array $options = [])
{
    return request('HEAD', $url, $options);
}

/**
 * Send a DELETE request
 *
 * @param string $url     URL of the request
 * @param array  $options Array of request options
 *
 * @return ResponseInterface
 */
function delete($url, array $options = [])
{
    return request('DELETE', $url, $options);
}

/**
 * Send a POST request
 *
 * @param string $url     URL of the request
 * @param array  $options Array of request options
 *
 * @return ResponseInterface
 */
function post($url, array $options = [])
{
    return request('POST', $url, $options);
}

/**
 * Send a PUT request
 *
 * @param string $url     URL of the request
 * @param array  $options Array of request options
 *
 * @return ResponseInterface
 */
function put($url, array $options = [])
{
    return request('PUT', $url, $options);
}

/**
 * Send a PATCH request
 *
 * @param string $url     URL of the request
 * @param array  $options Array of request options
 *
 * @return ResponseInterface
 */
function patch($url, array $options = [])
{
    return request('PATCH', $url, $options);
}

/**
 * Send an OPTIONS request
 *
 * @param string $url     URL of the request
 * @param array  $options Array of request options
 *
 * @return ResponseInterface
 */
function options($url, array $options = [])
{
    return request('OPTIONS', $url, $options);
}

/**
 * Convenience method for sending multiple requests in parallel and retrieving
 * a hash map of requests to response objects or RequestException objects.
 *
 * Note: This method keeps every request and response in memory, and as such is
 * NOT recommended when sending a large number or an indeterminable number of
 * requests in parallel.
 *
 * @param ClientInterface $client   Client used to send the requests
 * @param array|\Iterator $requests Requests to send in parallel
 * @param array           $options  Passes through the options available in
 *                                  {@see GuzzleHttp\ClientInterface::sendAll()}
 * @return \SplObjectStorage Requests are the key and each value is a
 *     {@see GuzzleHttp\Message\ResponseInterface} if the request succeeded or
 *     a {@see GuzzleHttp\Exception\RequestException} if it failed.
 * @throws \InvalidArgumentException if the event format is incorrect.
 */
function batch(ClientInterface $client, $requests, array $options = [])
{
    $hash = new \SplObjectStorage();
    foreach ($requests as $request) {
        $hash->attach($request);
    }

    // Merge the necessary complete and error events to the event listeners so
    // that as each request succeeds or fails, it is added to the result hash.
    $options = RequestEvents::convertEventArray(
        $options,
        ['complete', 'error'],
        [
            'priority' => RequestEvents::EARLY,
            'once' => true,
            'fn' => function ($e) use ($hash) { $hash[$e->getRequest()] = $e; }
        ]
    );

    // Send the requests in parallel and aggregate the results.
    $client->sendAll($requests, $options);

    // Update the received value for any of the intercepted requests.
    foreach ($hash as $request) {
        if ($hash[$request] instanceof CompleteEvent) {
            $hash[$request] = $hash[$request]->getResponse();
        } elseif ($hash[$request] instanceof ErrorEvent) {
            $hash[$request] = $hash[$request]->getException();
        }
    }

    return $hash;
}

/**
 * Gets a value from an array using a path syntax to retrieve nested data.
 *
 * This method does not allow for keys that contain "/". You must traverse
 * the array manually or using something more advanced like JMESPath to
 * work with keys that contain "/".
 *
 *     // Get the bar key of a set of nested arrays.
 *     // This is equivalent to $collection['foo']['baz']['bar'] but won't
 *     // throw warnings for missing keys.
 *     GuzzleHttp\get_path($data, 'foo/baz/bar');
 *
 * @param array  $data Data to retrieve values from
 * @param string $path Path to traverse and retrieve a value from
 *
 * @return mixed|null
 */
function get_path($data, $path)
{
    $path = explode('/', $path);

    while (null !== ($part = array_shift($path))) {
        if (!is_array($data) || !isset($data[$part])) {
            return null;
        }
        $data = $data[$part];
    }

    return $data;
}

/**
 * Set a value in a nested array key. Keys will be created as needed to set the
 * value.
 *
 * This function does not support keys that contain "/" or "[]" characters
 * because these are special tokens used when traversing the data structure.
 * A value may be prepended to an existing array by using "[]" as the final
 * key of a path.
 *
 *     GuzzleHttp\get_path($data, 'foo/baz'); // null
 *     GuzzleHttp\set_path($data, 'foo/baz/[]', 'a');
 *     GuzzleHttp\set_path($data, 'foo/baz/[]', 'b');
 *     GuzzleHttp\get_path($data, 'foo/baz');
 *     // Returns ['a', 'b']
 *
 * @param array  $data  Data to modify by reference
 * @param string $path  Path to set
 * @param mixed  $value Value to set at the key
 * @throws \RuntimeException when trying to setPath using a nested path that
 *     travels through a scalar value.
 */
function set_path(&$data, $path, $value)
{
    $current =& $data;
    $queue = explode('/', $path);
    while (null !== ($key = array_shift($queue))) {
        if (!is_array($current)) {
            throw new \RuntimeException("Trying to setPath {$path}, but "
                . "{$key} is set and is not an array");
        } elseif (!$queue) {
            if ($key == '[]') {
                $current[] = $value;
            } else {
                $current[$key] = $value;
            }
        } elseif (isset($current[$key])) {
            $current =& $current[$key];
        } else {
            $current[$key] = [];
            $current =& $current[$key];
        }
    }
}

/**
 * Expands a URI template
 *
 * @param string $template  URI template
 * @param array  $variables Template variables
 *
 * @return string
 */
function uri_template($template, array $variables)
{
    if (function_exists('\\uri_template')) {
        return \uri_template($template, $variables);
    }

    static $uriTemplate;
    if (!$uriTemplate) {
        $uriTemplate = new UriTemplate();
    }

    return $uriTemplate->expand($template, $variables);
}

/**
 * Wrapper for JSON decode that implements error detection with helpful error
 * messages.
 *
 * @param string $json    JSON data to parse
 * @param bool   $assoc   When true, returned objects will be converted into
 *                        associative arrays.
 * @param int    $depth   User specified recursion depth.
 * @param int    $options Bitmask of JSON decode options.
 *
 * @return mixed
 * @throws \InvalidArgumentException if the JSON cannot be parsed.
 * @link http://www.php.net/manual/en/function.json-decode.php
 */
function json_decode($json, $assoc = false, $depth = 512, $options = 0)
{
    static $jsonErrors = [
        JSON_ERROR_DEPTH => 'JSON_ERROR_DEPTH - Maximum stack depth exceeded',
        JSON_ERROR_STATE_MISMATCH => 'JSON_ERROR_STATE_MISMATCH - Underflow or the modes mismatch',
        JSON_ERROR_CTRL_CHAR => 'JSON_ERROR_CTRL_CHAR - Unexpected control character found',
        JSON_ERROR_SYNTAX => 'JSON_ERROR_SYNTAX - Syntax error, malformed JSON',
        JSON_ERROR_UTF8 => 'JSON_ERROR_UTF8 - Malformed UTF-8 characters, possibly incorrectly encoded'
    ];

    $data = \json_decode($json, $assoc, $depth, $options);

    if (JSON_ERROR_NONE !== json_last_error()) {
        $last = json_last_error();
        throw new \InvalidArgumentException(
            'Unable to parse JSON data: '
            . (isset($jsonErrors[$last]) ? $jsonErrors[$last] : 'Unknown error')
        );
    }

    return $data;
}

/**
 * @internal
 */
function deprecation_proxy($object, $name, $arguments, $map)
{
    if (!isset($map[$name])) {
        throw new \BadMethodCallException('Unknown method, ' . $name);
    }

    $message = sprintf('%s is deprecated and will be removed in a future '
        . 'version. Update your code to use the equivalent %s method '
        . 'instead to avoid breaking changes when this shim is removed.',
        get_class($object) . '::' . $name . '()',
        get_class($object) . '::' . $map[$name] . '()'
    );

    trigger_error($message, E_USER_DEPRECATED);

    return call_user_func_array([$object, $map[$name]], $arguments);
}