<?php
  
  use Illuminate\Contracts\Support\DeferringDisplayableValue;
  use Illuminate\Contracts\Support\Htmlable;
  use Illuminate\Support\Arr;
  use Illuminate\Support\Collection;
  use Illuminate\Support\Env;
  use Illuminate\Support\HigherOrderTapProxy;
  use Illuminate\Support\Optional;
  
  if (! function_exists('append_config')) {
      /**
       * Assign high numeric IDs to a config item to force appending.
       *
       * @param  array  $array
       * @return array
       */
      function append_config(array $array)
      {
          $start = 9999;
  
          foreach ($array as $key => $value) {
              if (is_numeric($key)) {
                  $start++;
  
                  $array[$start] = Arr::pull($array, $key);
              }
          }
  
          return $array;
      }
  }
  
  if (! function_exists('blank')) {
      /**
       * Determine if the given value is "blank".
       *
       * @param  mixed  $value
       * @return bool
       */
      function blank($value)
      {
          if (is_null($value)) {
              return true;
          }
  
          if (is_string($value)) {
              return trim($value) === '';
          }
  
          if (is_numeric($value) || is_bool($value)) {
              return false;
          }
  
          if ($value instanceof Countable) {
              return count($value) === 0;
          }
  
          return empty($value);
      }
  }
  
  if (! function_exists('class_basename')) {
      /**
       * Get the class "basename" of the given object / class.
       *
       * @param  string|object  $class
       * @return string
       */
      function class_basename($class)
      {
          $class = is_object($class) ? get_class($class) : $class;
  
          return basename(str_replace('\\', '/', $class));
      }
  }
  
  if (! function_exists('class_uses_recursive')) {
      /**
       * Returns all traits used by a class, its parent classes and trait of their traits.
       *
       * @param  object|string  $class
       * @return array
       */
      function class_uses_recursive($class)
      {
          if (is_object($class)) {
              $class = get_class($class);
          }
  
          $results = [];
  
          foreach (array_reverse(class_parents($class)) + [$class => $class] as $class) {
              $results += trait_uses_recursive($class);
          }
  
          return array_unique($results);
      }
  }
  
  if (! function_exists('collect')) {
      /**
       * Create a collection from the given value.
       *
       * @param  mixed  $value
       * @return \Illuminate\Support\Collection
       */
      function collect($value = null)
      {
          return new Collection($value);
      }
  }
  
  if (! function_exists('data_fill')) {
      /**
       * Fill in data where it's missing.
       *
       * @param  mixed  $target
       * @param  string|array  $key
       * @param  mixed  $value
       * @return mixed
       */
      function data_fill(&$target, $key, $value)
      {
          return data_set($target, $key, $value, false);
      }
  }
  
  if (! function_exists('data_get')) {
      /**
       * Get an item from an array or object using "dot" notation.
       *
       * @param  mixed  $target
       * @param  string|array|int|null  $key
       * @param  mixed  $default
       * @return mixed
       */
      function data_get($target, $key, $default = null)
      {
          if (is_null($key)) {
              return $target;
          }
  
          $key = is_array($key) ? $key : explode('.', $key);
  
          foreach ($key as $i => $segment) {
              unset($key[$i]);
  
              if (is_null($segment)) {
                  return $target;
              }
  
              if ($segment === '*') {
                  if ($target instanceof Collection) {
                      $target = $target->all();
                  } elseif (! is_array($target)) {
                      return value($default);
                  }
  
                  $result = [];
  
                  foreach ($target as $item) {
                      $result[] = data_get($item, $key);
                  }
  
                  return in_array('*', $key) ? Arr::collapse($result) : $result;
              }
  
              if (Arr::accessible($target) && Arr::exists($target, $segment)) {
                  $target = $target[$segment];
              } elseif (is_object($target) && isset($target->{$segment})) {
                  $target = $target->{$segment};
              } else {
                  return value($default);
              }
          }
  
          return $target;
      }
  }
  
  if (! function_exists('data_set')) {
      /**
       * Set an item on an array or object using dot notation.
       *
       * @param  mixed  $target
       * @param  string|array  $key
       * @param  mixed  $value
       * @param  bool  $overwrite
       * @return mixed
       */
      function data_set(&$target, $key, $value, $overwrite = true)
      {
          $segments = is_array($key) ? $key : explode('.', $key);
  
          if (($segment = array_shift($segments)) === '*') {
              if (! Arr::accessible($target)) {
                  $target = [];
              }
  
              if ($segments) {
                  foreach ($target as &$inner) {
                      data_set($inner, $segments, $value, $overwrite);
                  }
              } elseif ($overwrite) {
                  foreach ($target as &$inner) {
                      $inner = $value;
                  }
              }
          } elseif (Arr::accessible($target)) {
              if ($segments) {
                  if (! Arr::exists($target, $segment)) {
                      $target[$segment] = [];
                  }
  
                  data_set($target[$segment], $segments, $value, $overwrite);
              } elseif ($overwrite || ! Arr::exists($target, $segment)) {
                  $target[$segment] = $value;
              }
          } elseif (is_object($target)) {
              if ($segments) {
                  if (! isset($target->{$segment})) {
                      $target->{$segment} = [];
                  }
  
                  data_set($target->{$segment}, $segments, $value, $overwrite);
              } elseif ($overwrite || ! isset($target->{$segment})) {
                  $target->{$segment} = $value;
              }
          } else {
              $target = [];
  
              if ($segments) {
                  data_set($target[$segment], $segments, $value, $overwrite);
              } elseif ($overwrite) {
                  $target[$segment] = $value;
              }
          }
  
          return $target;
      }
  }
  
  if (! function_exists('e')) {
      /**
       * Encode HTML special characters in a string.
       *
       * @param  \Illuminate\Contracts\Support\DeferringDisplayableValue|\Illuminate\Contracts\Support\Htmlable|string  $value
       * @param  bool  $doubleEncode
       * @return string
       */
      function e($value, $doubleEncode = true)
      {
          if ($value instanceof DeferringDisplayableValue) {
              $value = $value->resolveDisplayableValue();
          }
  
          if ($value instanceof Htmlable) {
              return $value->toHtml();
          }
  
          return htmlspecialchars($value, ENT_QUOTES, 'UTF-8', $doubleEncode);
      }
  }
  
  if (! function_exists('env')) {
      /**
       * Gets the value of an environment variable.
       *
       * @param  string  $key
       * @param  mixed  $default
       * @return mixed
       */
      function env($key, $default = null)
      {
          return Env::get($key, $default);
      }
  }
  
  if (! function_exists('filled')) {
      /**
       * Determine if a value is "filled".
       *
       * @param  mixed  $value
       * @return bool
       */
      function filled($value)
      {
          return ! blank($value);
      }
  }
  
  if (! function_exists('head')) {
      /**
       * Get the first element of an array. Useful for method chaining.
       *
       * @param  array  $array
       * @return mixed
       */
      function head($array)
      {
          return reset($array);
      }
  }
  
  if (! function_exists('last')) {
      /**
       * Get the last element from an array.
       *
       * @param  array  $array
       * @return mixed
       */
      function last($array)
      {
          return end($array);
      }
  }
  
  if (! function_exists('object_get')) {
      /**
       * Get an item from an object using "dot" notation.
       *
       * @param  object  $object
       * @param  string|null  $key
       * @param  mixed  $default
       * @return mixed
       */
      function object_get($object, $key, $default = null)
      {
          if (is_null($key) || trim($key) == '') {
              return $object;
          }
  
          foreach (explode('.', $key) as $segment) {
              if (! is_object($object) || ! isset($object->{$segment})) {
                  return value($default);
              }
  
              $object = $object->{$segment};
          }
  
          return $object;
      }
  }
  
  if (! function_exists('optional')) {
      /**
       * Provide access to optional objects.
       *
       * @param  mixed  $value
       * @param  callable|null  $callback
       * @return mixed
       */
      function optional($value = null, callable $callback = null)
      {
          if (is_null($callback)) {
              return new Optional($value);
          } elseif (! is_null($value)) {
              return $callback($value);
          }
      }
  }
  
  if (! function_exists('preg_replace_array')) {
      /**
       * Replace a given pattern with each value in the array in sequentially.
       *
       * @param  string  $pattern
       * @param  array  $replacements
       * @param  string  $subject
       * @return string
       */
      function preg_replace_array($pattern, array $replacements, $subject)
      {
          return preg_replace_callback($pattern, function () use (&$replacements) {
              foreach ($replacements as $key => $value) {
                  return array_shift($replacements);
              }
          }, $subject);
      }
  }
  
  if (! function_exists('retry')) {
      /**
       * Retry an operation a given number of times.
       *
       * @param  int  $times
       * @param  callable  $callback
       * @param  int  $sleep
       * @param  callable|null  $when
       * @return mixed
       *
       * @throws \Exception
       */
      function retry($times, callable $callback, $sleep = 0, $when = null)
      {
          $attempts = 0;
  
          beginning:
          $attempts++;
          $times--;
  
          try {
              return $callback($attempts);
          } catch (Exception $e) {
              if ($times < 1 || ($when && ! $when($e))) {
                  throw $e;
              }
  
              if ($sleep) {
                  usleep($sleep * 1000);
              }
  
              goto beginning;
          }
      }
  }
  
  if (! function_exists('tap')) {
      /**
       * Call the given Closure with the given value then return the value.
       *
       * @param  mixed  $value
       * @param  callable|null  $callback
       * @return mixed
       */
      function tap($value, $callback = null)
      {
          if (is_null($callback)) {
              return new HigherOrderTapProxy($value);
          }
  
          $callback($value);
  
          return $value;
      }
  }
  
  if (! function_exists('throw_if')) {
      /**
       * Throw the given exception if the given condition is true.
       *
       * @param  mixed  $condition
       * @param  \Throwable|string  $exception
       * @param  array  ...$parameters
       * @return mixed
       *
       * @throws \Throwable
       */
      function throw_if($condition, $exception, ...$parameters)
      {
          if ($condition) {
              throw (is_string($exception) ? new $exception(...$parameters) : $exception);
          }
  
          return $condition;
      }
  }
  
  if (! function_exists('throw_unless')) {
      /**
       * Throw the given exception unless the given condition is true.
       *
       * @param  mixed  $condition
       * @param  \Throwable|string  $exception
       * @param  array  ...$parameters
       * @return mixed
       *
       * @throws \Throwable
       */
      function throw_unless($condition, $exception, ...$parameters)
      {
          if (! $condition) {
              throw (is_string($exception) ? new $exception(...$parameters) : $exception);
          }
  
          return $condition;
      }
  }
  
  if (! function_exists('trait_uses_recursive')) {
      /**
       * Returns all traits used by a trait and its traits.
       *
       * @param  string  $trait
       * @return array
       */
      function trait_uses_recursive($trait)
      {
          $traits = class_uses($trait);
  
          foreach ($traits as $trait) {
              $traits += trait_uses_recursive($trait);
          }
  
          return $traits;
      }
  }
  
  if (! function_exists('transform')) {
      /**
       * Transform the given value if it is present.
       *
       * @param  mixed  $value
       * @param  callable  $callback
       * @param  mixed  $default
       * @return mixed|null
       */
      function transform($value, callable $callback, $default = null)
      {
          if (filled($value)) {
              return $callback($value);
          }
  
          if (is_callable($default)) {
              return $default($value);
          }
  
          return $default;
      }
  }
  
  if (! function_exists('value')) {
      /**
       * Return the default value of the given value.
       *
       * @param  mixed  $value
       * @return mixed
       */
      function value($value)
      {
          return $value instanceof Closure ? $value() : $value;
      }
  }
  
  if (! function_exists('windows_os')) {
      /**
       * Determine whether the current environment is Windows based.
       *
       * @return bool
       */
      function windows_os()
      {
          return PHP_OS_FAMILY === 'Windows';
      }
  }
  
  if (! function_exists('with')) {
      /**
       * Return the given value, optionally passed through the given callback.
       *
       * @param  mixed  $value
       * @param  callable|null  $callback
       * @return mixed
       */
      function with($value, callable $callback = null)
      {
          return is_null($callback) ? $value : $callback($value);
      }
  }