<?php namespace Clockwork\Helpers;

// Prepares various types of data for serialization
class Serializer
{
	// Serialized objects cache by object hash
	protected $cache = [];

	// Options for the current instance
	protected $options = [];

	// Default options for new instances
	protected static $defaults = [
		'blackbox' => [
			\Illuminate\Container\Container::class,
			\Illuminate\Foundation\Application::class,
			\Laravel\Lumen\Application::class
		],
		'limit' => 10,
		'toArray' => false,
		'toString' => false,
		'debugInfo' => true,
		'jsonSerialize' => false,
		'traces' => true,
		'tracesFilter' => null,
		'tracesSkip' => null,
		'tracesLimit' => null
	];

	// Create a new instance optionally with options overriding defaults
	public function __construct(array $options = [])
	{
		$this->options = $options + static::$defaults;
	}

	// Set default options for all new instances
	public static function defaults(array $defaults)
	{
		static::$defaults = $defaults + static::$defaults;
	}

	// Prepares the passed data to be ready for serialization, takes any kind of data to normalize as the first
	// argument, other arguments are used internally in recursion
	public function normalize($data, $context = null, $limit = null)
	{
		if ($context === null) $context = [ 'references' => [] ];
		if ($limit === null) $limit = $this->options['limit'];

		if (is_array($data)) {
			if ($limit === 0) return [ '__type__' => 'array', '__omitted__' => 'limit' ];

			return [ '__type__' => 'array' ] + $this->normalizeEach($data, $context, $limit - 1);
		} elseif (is_object($data)) {
			if ($data instanceof \Closure) return [ '__type__' => 'anonymous function' ];

			$className = get_class($data);
			$objectHash = spl_object_hash($data);

			if ($limit === 0) return [ '__class__' => $className, '__omitted__' => 'limit' ];

			if (isset($context['references'][$objectHash])) return [ '__type__' => 'recursion' ];

			$context['references'][$objectHash] = true;

			if (isset($this->cache[$objectHash])) return $this->cache[$objectHash];

			if ($this->options['blackbox'] && in_array($className, $this->options['blackbox'])) {
				return $this->cache[$objectHash] = [ '__class__' => $className, '__omitted__' => 'blackbox' ];
			} elseif ($this->options['toString'] && method_exists($data, '__toString')) {
				return $this->cache[$objectHash] = (string) $data;
			}

			if ($this->options['debugInfo'] && method_exists($data, '__debugInfo')) {
				$data = (array) $data->__debugInfo();
			} elseif ($this->options['jsonSerialize'] && method_exists($data, 'jsonSerialize')) {
				$data = (array) $data->jsonSerialize();
			} elseif ($this->options['toArray'] && method_exists($data, 'toArray')) {
				$data = (array) $data->toArray();
			} else {
				$data = (array) $data;
			}

			$data = array_combine(
				array_map(function ($key) {
					// replace null-byte prefixes of protected and private properties used by php with * (protected)
					// and ~ (private)
					return preg_replace('/^\0.+?\0/', '~', str_replace("\0*\0", '*', $key));
				}, array_keys($data)),
				$this->normalizeEach($data, $context, $limit - 1)
			);

			return $this->cache[$objectHash] = [ '__class__' => $className ] + $data;
		} elseif (is_resource($data)) {
			return [ '__type__' => 'resource' ];
		}

		return $data;
	}

	// Normalize each member of an array (doesn't add metadata for top level)
	public function normalizeEach($data, $context = null, $limit = null) {
		return array_map(function ($item) use ($context, $limit) {
			return $this->normalize($item, $context, $limit);
		}, $data);
	}

	// Normalize a stack trace instance
	public function trace(StackTrace $trace)
	{
		if (! $this->options['traces']) return null;

		if ($this->options['tracesFilter']) $trace = $trace->filter($this->options['tracesFilter']);
		if ($this->options['tracesSkip']) $trace = $trace->skip($this->options['tracesSkip']);
		if ($this->options['tracesLimit']) $trace = $trace->limit($this->options['tracesLimit']);

		return array_map(function ($frame) {
			return [
				'call' => $frame->call,
				'file' => $frame->file,
				'line' => $frame->line,
				'isVendor' => (bool) $frame->vendor
			];
		}, $trace->frames());
	}

	// Normalize an exception instance
	public function exception(/* Throwable */ $exception)
	{
		return [
			'type'     => get_class($exception),
			'message'  => $exception->getMessage(),
			'code'     => $exception->getCode(),
			'file'     => $exception->getFile(),
			'line'     => $exception->getLine(),
			'trace'    => (new Serializer([ 'tracesLimit' => false ]))->trace(StackTrace::from($exception->getTrace())),
			'previous' => $exception->getPrevious() ? $this->exception($exception->getPrevious()) : null
		];
	}
}