<?php

namespace ClikIT\InfiniteUploads;

use ClikIT\Infinite_Uploads\Aws\S3\S3ClientInterface;
use ClikIT\Infinite_Uploads\Aws\CacheInterface;
use ClikIT\Infinite_Uploads\Aws\LruArrayCache;
use ClikIT\Infinite_Uploads\Aws\Result;
use ClikIT\Infinite_Uploads\Aws\S3\Exception\S3Exception;
use ClikIT\Infinite_Uploads\GuzzleHttp\Psr7;
use ClikIT\Infinite_Uploads\GuzzleHttp\Psr7\Stream;
use ClikIT\Infinite_Uploads\GuzzleHttp\Psr7\CachingStream;
use ClikIT\Infinite_Uploads\Psr\Http\Message\StreamInterface;
use ClikIT\Infinite_Uploads\Aws;

/**
 * Amazon S3 stream wrapper to use "iu://<bucket>/<key>" files with PHP
 * streams, supporting "r", "w", "a", "x".
 *
 * # Opening "r" (read only) streams:
 *
 * Read only streams are truly streaming by default and will not allow you to
 * seek. This is because data read from the stream is not kept in memory or on
 * the local filesystem. You can force a "r" stream to be seekable by setting
 * the "seekable" stream context option true. This will allow true streaming of
 * data from Amazon S3, but will maintain a buffer of previously read bytes in
 * a 'php://temp' stream to allow seeking to previously read bytes from the
 * stream.
 *
 * You may pass any GetObject parameters as 's3' stream context options. These
 * options will affect how the data is downloaded from Amazon S3.
 *
 * # Opening "w" and "x" (write only) streams:
 *
 * Because Amazon S3 requires a Content-Length header, write only streams will
 * maintain a 'php://temp' stream to buffer data written to the stream until
 * the stream is flushed (usually by closing the stream with fclose).
 *
 * You may pass any PutObject parameters as 's3' stream context options. These
 * options will affect how the data is uploaded to Amazon S3.
 *
 * When opening an "x" stream, the file must exist on Amazon S3 for the stream
 * to open successfully.
 *
 * # Opening "a" (write only append) streams:
 *
 * Similar to "w" streams, opening append streams requires that the data be
 * buffered in a "php://temp" stream. Append streams will attempt to download
 * the contents of an object in Amazon S3, seek to the end of the object, then
 * allow you to append to the contents of the object. The data will then be
 * uploaded using a PutObject operation when the stream is flushed (usually
 * with fclose).
 *
 * You may pass any GetObject and/or PutObject parameters as 's3' stream
 * context options. These options will affect how the data is downloaded and
 * uploaded from Amazon S3.
 *
 * Stream context options:
 *
 * - "seekable": Set to true to create a seekable "r" (read only) stream by
 *   using a php://temp stream buffer
 * - For "unlink" only: Any option that can be passed to the DeleteObject
 *   operation
 */
class InfiniteUploadsStreamWrapper {
	/** @var resource|null Stream context (this is set by PHP) */
	public $context;

	/** @var StreamInterface Underlying stream resource */
	private $body;

	/** @var int Size of the body that is opened */
	private $size;

	/** @var array Hash of opened stream parameters */
	private $params = [];

	/** @var string Mode in which the stream was opened */
	private $mode;

	/** @var \Iterator Iterator used with opendir() related calls */
	private $objectIterator;

	/** @var string The bucket that was opened when opendir() was called */
	private $openedBucket;

	/** @var string The prefix of the bucket that was opened with opendir() */
	private $openedBucketPrefix;

	/** @var string Opened bucket path */
	private $openedPath;

	/** @var CacheInterface Cache for object and dir lookups */
	private $cache;

	/** @var string The opened protocol (e.g., "s3") */
	private $protocol = 'iu';

	/** @var cache for last file, so it doesn't need to be fetched again for immediate edits */
	private $last_file = [];

	/**
	 * Register the 'iu://' stream wrapper
	 *
	 * @param  S3ClientInterface  $client    Client to use with the stream wrapper
	 * @param  string             $protocol  Protocol to register as.
	 * @param  CacheInterface     $cache     Default cache for the protocol.
	 */
	public static function register(
		S3ClientInterface $client,
		$protocol = 'iu',
		CacheInterface $cache = null
	) {
		if ( in_array( $protocol, stream_get_wrappers() ) ) {
			stream_wrapper_unregister( $protocol );
		}

		// Set the client passed in as the default stream context client
		stream_wrapper_register( $protocol, get_called_class(), STREAM_IS_URL );
		$default                        = stream_context_get_options( stream_context_get_default() );
		$default[ $protocol ]['client'] = $client;

		if ( $cache ) {
			$default[ $protocol ]['cache'] = $cache;
		} elseif ( ! isset( $default[ $protocol ]['cache'] ) ) {
			// Set a default cache adapter.
			$default[ $protocol ]['cache'] = new LruArrayCache();
		}

		stream_context_set_default( $default );
	}

	public function stream_close() {
		$this->body = $this->cache = null;
	}

	/**
	 * Replace your existing stream_open method with this version
	 */
	public function stream_open( $path, $mode, $options, &$opened_path ) {
		$path = $this->normalizeSmushPath( $path );

		$validation_result = $this->validateStreamPath( $path, $options );
		if ( $validation_result !== true ) {
			return false;
		}

		$this->initProtocol( $path );
		$this->params = $this->getBucketKey( $path );
		$this->mode   = rtrim( $mode, 'bt' );

		if ( $errors = $this->validate( $path, $this->mode ) ) {
			return $this->triggerError( $errors );
		}

		return $this->boolCall( function () use ( $path ) {
			switch ( $this->mode ) {
				case 'r':
					return $this->openReadStream( $path );
				case 'a':
					return $this->openAppendStream( $path );
				default:
					return $this->openWriteStream( $path );
			}
		} );
	}

	private function validateStreamPath( $path, $options ) {
		$parsed = parse_url( $path );
		$key    = isset( $parsed['path'] ) ? ltrim( $parsed['path'], '/' ) : '';

		// Block directory paths (ending with /)
		if ( substr( $key, - 1 ) === '/' ) {
			if ( $options & STREAM_REPORT_ERRORS ) {
				trigger_error( "Cannot open directory as file: {$path}", E_USER_WARNING );
			}

			return "Directory path detected: {$key}";
		}

		// Block invalid filenames
		$basename = basename( $key );
		if ( empty( $basename ) || $basename === '.' || $basename === '..' ) {
			if ( $options & STREAM_REPORT_ERRORS ) {
				trigger_error( "Invalid file path: {$path}", E_USER_WARNING );
			}

			return "No valid filename: {$key}";
		}

		return true;
	}

	/**
	 * Normalize WP Smush WebP/AVIF paths that are at the wrong bucket level.
	 *
	 * Smush uses dirname(basedir) . '/smush-webp' which strips our site_id.
	 * This method detects such paths and corrects them for ALL file operations.
	 *
	 * @param  string  $path  The iu:// path being accessed
	 *
	 * @return string Corrected path with proper prefix
	 */
	private function normalizeSmushPath( $path ) {
		// Only process iu:// paths
		if ( strpos( $path, 'iu://' ) !== 0 ) {
			return $path;
		}

		// Check if this is a smush-webp or smush-avif path
		$smush_dirs    = [ 'smush-webp', 'smush-avif' ];
		$is_smush_path = false;

		foreach ( $smush_dirs as $dir ) {
			if ( strpos( $path, '/' . $dir . '/' ) !== false ||
			     strpos( $path, '/' . $dir . '-test' ) !== false ) {
				$is_smush_path = true;
				break;
			}
		}

		if ( ! $is_smush_path ) {
			return $path;
		}

		// Parse the path: iu://bucket/user_id/smush-webp/...
		// Should be: iu://bucket/user_id/site_id/smush-webp/...
		$without_protocol = str_replace( 'iu://', '', $path );
		$parts            = explode( '/', $without_protocol );

		// parts[0] = bucket, parts[1] = user_id, parts[2] = smush-webp (wrong) or site_id (correct)
		if ( count( $parts ) >= 3 ) {
			$bucket              = $parts[0];
			$potential_smush_dir = $parts[2];

			// Check if site_id is missing (smush dir is in position 2 instead of 3)
			foreach ( $smush_dirs as $dir ) {
				if ( $potential_smush_dir === $dir || strpos( $potential_smush_dir, $dir ) === 0 ) {
					// Get the correct site_id from our configuration
					$iup_instance = $this->getOption( 'iup_instance' );
					if ( $iup_instance && method_exists( $iup_instance, 'get_s3_prefix' ) ) {
						$prefix       = $iup_instance->get_s3_prefix(); // Returns "user_id/site_id"
						$prefix_parts = explode( '/', $prefix );

						if ( count( $prefix_parts ) >= 2 ) {
							$site_id = $prefix_parts[1];

							// Rebuild path with site_id inserted
							// From: bucket/user_id/smush-webp/file.webp
							// To:   bucket/user_id/site_id/smush-webp/file.webp
							$user_id      = $parts[1];
							$rest_of_path = array_slice( $parts, 2 ); // smush-webp/file.webp

							$corrected = 'iu://' . $bucket . '/' . $user_id . '/' . $site_id . '/' . implode( '/', $rest_of_path );

							$this->debug( 'Smush path normalized', $path . ' -> ' . $corrected );

							return $corrected;
						}
					}
					break;
				}
			}
		}

		return $path;
	}

	/**
	 * Parse the protocol out of the given path.
	 *
	 * @param $path
	 */
	private function initProtocol( $path ) {
		$parts          = explode( '://', $path, 2 );
		$this->protocol = $parts[0] ?: 'iu';
	}

	private function getBucketKey( $path ) {
		// Remove the protocol
		$parts = explode( '://', $path );
		// Get the bucket, key
		$parts = explode( '/', $parts[1], 2 );

		return [
			'Bucket' => $parts[0],
			'Key'    => isset( $parts[1] ) ? $parts[1] : null,
		];
	}

	/**
	 * Validates the provided stream arguments for fopen and returns an array
	 * of errors.
	 */
	private function validate( $path, $mode ) {
		$errors = [];
		if ( ! $this->getOption( 'Key' ) ) {
			$errors[] = 'Cannot open a bucket. You must specify a path in the '
			            . 'form of iu://bucket/key';
		}

		if ( ! in_array( $mode, [ 'r', 'w', 'a', 'x' ] ) ) {
			$errors[] = "Mode not supported: {$mode}. "
			            . "Use one 'r', 'w', 'a', or 'x'.";
		}

		// When using mode "x" validate if the file exists before attempting
		// to read
		if ( $mode == 'x' ) {
			$this->debug( 'doesObjectExist', $this->getOption( 'Key' ) );
		}
		if ( $mode == 'x' &&
		     $this->getClient()->doesObjectExist(
			     $this->getOption( 'Bucket' ),
			     $this->getOption( 'Key' ),
			     $this->getOptions( true )
		     )
		) {
			$errors[] = "{$path} already exists on Infinite Uploads";
		}

		return $errors;
	}

	/**
	 * Get a specific stream context option
	 *
	 * @param  string  $name  Name of the option to retrieve
	 *
	 * @return mixed|null
	 */
	private function getOption( $name ) {
		$options = $this->getOptions();

		return isset( $options[ $name ] ) ? $options[ $name ] : null;
	}

	/**
	 * Get the stream context options available to the current stream
	 *
	 * @param  bool  $removeContextData  Set to true to remove contextual kvp's
	 *                                   like 'client' from the result.
	 *
	 * @return array
	 */
	private function getOptions( $removeContextData = false ) {
		// Context is not set when doing things like stat
		if ( $this->context === null ) {
			$options = [];
		} else {
			$options = stream_context_get_options( $this->context );
			$options = isset( $options[ $this->protocol ] )
				? $options[ $this->protocol ]
				: [];
		}

		$default = stream_context_get_options( stream_context_get_default() );
		$default = isset( $default[ $this->protocol ] )
			? $default[ $this->protocol ]
			: [];
		$result  = $this->params + $options + $default;

		if ( $removeContextData ) {
			unset( $result['client'], $result['seekable'], $result['cache'] );
		}

		return $result;
	}

	/**
	 * Writes info to debug log if feature is defined.
	 *
	 * @param  string  $action  What cloud API call is being performed.
	 * @param  string  $key     S3 path or prefix (key).
	 */
	private function debug( $action, $key ) {
		if ( defined( 'INFINITE_UPLOADS_SW_DEBUG' ) && INFINITE_UPLOADS_SW_DEBUG ) {
			$instance = $this->getOption( 'iup_instance' );
			$instance->stream_api_call_count['total'] ++;
			if ( isset( $instance->stream_api_call_count['commands'][ $action ] ) ) {
				$instance->stream_api_call_count['commands'][ $action ] ++;
			} else {
				$instance->stream_api_call_count['commands'][ $action ] = 1;
			}

			$error   = new Error;
			$trace   = $error->getTraceAsString();
			$pattern = '/' . preg_quote( WP_PLUGIN_DIR, '/' ) . '\/(?:(?!infinite\-uploads)([^\/]+))\//';
			preg_match( $pattern, $trace, $matches );
			if ( isset( $matches[1] ) ) {
				if ( isset( $instance->stream_plugin_api_call_count[ $matches[1] ] ) ) {
					$instance->stream_plugin_api_call_count[ $matches[1] ]['total'] ++;
					if ( isset( $instance->stream_plugin_api_call_count[ $matches[1] ]['commands'][ $action ] ) ) {
						$instance->stream_plugin_api_call_count[ $matches[1] ]['commands'][ $action ] ++;
					} else {
						$instance->stream_plugin_api_call_count[ $matches[1] ]['commands'][ $action ] = 1;
					}
				} else {
					$instance->stream_plugin_api_call_count[ $matches[1] ] = [
						'total'    => 1,
						'commands' => [ $action => 1 ],
					];
				}
			}

			$log = "[INFINITE_UPLOADS Stream Debug] $action $key";
			if ( defined( 'INFINITE_UPLOADS_SW_DEBUG_BACKTRACE' ) && INFINITE_UPLOADS_SW_DEBUG_BACKTRACE ) {
				// Remove first item from backtrace as it's this function which is redundant.
				$trace = preg_replace( "/^#0\s+[^\n]*\n/", '', $trace, 1 );

				// Renumber backtrace items.
				$trace = preg_replace_callback( '/^#(\d+)(.*)$/', function ( $matches ) {
					return "#" . max( absint( $matches[1] ) - 1, 1 ) . $matches[2] . PHP_EOL;
				}, $trace );

				$log .= PHP_EOL . $trace;
			}
			error_log( $log );
		}
	}

	/**
	 * Gets the client from the stream context
	 *
	 * @return S3ClientInterface
	 * @throws \RuntimeException if no client has been configured
	 */
	private function getClient() {
		if ( ! $client = $this->getOption( 'client' ) ) {
			throw new \RuntimeException( 'No client in stream context' );
		}

		return $client;
	}

	/**
	 * Trigger one or more errors
	 *
	 * @param  string|array  $errors  Errors to trigger
	 * @param  mixed         $flags   If set to STREAM_URL_STAT_QUIET, then no
	 *                                error or exception occurs
	 *
	 * @return bool Returns false
	 * @throws \RuntimeException if throw_errors is true
	 */
	private function triggerError( $errors, $flags = null ) {
		// This is triggered with things like file_exists()
		if ( $flags & STREAM_URL_STAT_QUIET ) {
			return $flags & STREAM_URL_STAT_LINK
				// This is triggered for things like is_link()
				? $this->formatUrlStat( false )
				: false;
		}

		// This is triggered when doing things like lstat() or stat()
		trigger_error( implode( "\n", (array) $errors ), E_USER_WARNING );

		return false;
	}

	/**
	 * Prepare a url_stat result array
	 *
	 * @param  string|array  $result  Data to add
	 *
	 * @return array Returns the modified url_stat result
	 */
	private function formatUrlStat( $result = null ) {
		$stat = $this->getStatTemplate();
		switch ( gettype( $result ) ) {
			case 'NULL':
			case 'string':
				// Directory with 0777 access - see "man 2 stat".
				$stat['mode'] = $stat[2] = 0040777;
				break;
			case 'array':
				// Regular file with 0777 access - see "man 2 stat".
				$stat['mode'] = $stat[2] = 0100777;
				// Pluck the content-length if available.
				if ( isset( $result['ContentLength'] ) ) {
					$stat['size'] = $stat[7] = $result['ContentLength'];
				} elseif ( isset( $result['Size'] ) ) {
					$stat['size'] = $stat[7] = $result['Size'];
				}
				if ( isset( $result['LastModified'] ) ) {
					// ListObjects or HeadObject result
					$stat['mtime'] = $stat[9] = $stat['ctime'] = $stat[10]
						= strtotime( $result['LastModified'] );
				}
		}

		return $stat;
	}

	/**
	 * Gets a URL stat template with default values
	 *
	 * @return array
	 */
	private function getStatTemplate() {
		return [
			0         => 0,
			'dev'     => 0,
			1         => 0,
			'ino'     => 0,
			2         => 0,
			'mode'    => 0,
			3         => 0,
			'nlink'   => 0,
			4         => 0,
			'uid'     => 0,
			5         => 0,
			'gid'     => 0,
			6         => - 1,
			'rdev'    => - 1,
			7         => 0,
			'size'    => 0,
			8         => 0,
			'atime'   => 0,
			9         => 0,
			'mtime'   => 0,
			10        => 0,
			'ctime'   => 0,
			11        => - 1,
			'blksize' => - 1,
			12        => - 1,
			'blocks'  => - 1,
		];
	}

	/**
	 * Invokes a callable and triggers an error if an exception occurs while
	 * calling the function.
	 *
	 * @param  callable  $fn
	 * @param  int       $flags
	 *
	 * @return bool
	 */
	private function boolCall( callable $fn, $flags = null ) {
		try {
			return $fn();
		} catch ( \Exception $e ) {
			$this->debug( 'Error Message', $e->getMessage() );

			return $this->triggerError( $e->getMessage(), $flags );
		}
	}

	private function openReadStream( $path ) {
		//check cache
		if ( null !== ( $object = $this->cacheObjectGet( $path ) ) ) {
			$this->body = Psr7\Utils::streamFor( $object ); //make it a stream
			$this->size = $this->body->getSize();
		} else {
			$this->debug( 'GetObject (stream)', $this->getOption( 'Key' ) );
			$client                     = $this->getClient();
			$command                    = $client->getCommand( 'GetObject', $this->getOptions( true ) );
			$command['@http']['stream'] = true;
			$result                     = $client->execute( $command );
			$this->size                 = $result['ContentLength'];
			$this->body                 = $result['Body'];
			//$this->cacheObjectSet( $path, $this->body ); //need to figure out how to wait for this to finish downloading
		}

		// Wrap the body in a caching entity body if seeking is allowed
		if ( $this->getOption( 'seekable' ) && ! $this->body->isSeekable() ) {
			$this->body = new CachingStream( $this->body );
		}

		return true;
	}

	/**
	 * Get cached put/get object
	 *
	 * @param  string  $key  Cache key
	 *
	 * @return mixed|null
	 */
	private function cacheObjectGet( $key ) {
		$instance = $this->getOption( 'iup_instance' );
		if ( isset( $instance->stream_file_cache[ $key ] ) ) {
			$this->debug_cache( 'Object HIT', $key );

			return $instance->stream_file_cache[ $key ];
		}

		$this->debug_cache( 'Object MISS', $key );

		return null;
	}

	/**
	 * Writes info to debug log if feature is defined.
	 *
	 * @param  string  $action  Hit, Miss, Set, Delete.
	 * @param  string  $key     S3 path or prefix (key).
	 */
	private function debug_cache( $action, $key ) {
		if ( defined( 'INFINITE_UPLOADS_SW_DEBUG_CACHE' ) && INFINITE_UPLOADS_SW_DEBUG_CACHE ) {
			$log = "[INFINITE_UPLOADS Stream Cache] $action $key";
			error_log( $log );
		}
	}

	private function openAppendStream( $path ) {
		try {
			//check cache
			if ( null !== ( $object = $this->cacheObjectGet( $path ) ) ) {
				$this->body = Psr7\Utils::streamFor( $object ); //make it a stream
			} else {
				// Get the body of the object and seek to the end of the stream
				$this->debug( 'GetObject (append stream)', $this->getOption( 'Key' ) );
				$client     = $this->getClient();
				$this->body = $client->getObject( $this->getOptions( true ) )['Body'];
				$this->cacheObjectSet( $path, Psr7\Utils::copyToString( $this->body, $this->calculate_chunk_size() ) );
			}
			$this->body->seek( 0, SEEK_END );

			return true;
		} catch ( S3Exception $e ) {
			// The object does not exist, so use a simple write stream
			return $this->openWriteStream( $path );
		}
	}

	/**
	 * Cache last put/get object till the end of the request. This prevents multiple GetObject requests for the same object.
	 *
	 * @param  string  $key   Cache key
	 * @param  string  $body  Convert any streams to string before caching
	 */
	private function cacheObjectSet( $key, $body ) {
		//don't cache files that are too big in memory
		if ( strlen( $body ) > INFINITE_UPLOADS_STREAM_CACHE_MAX_BYTES ) {
			unset( $body );

			return;
		}

		$instance                            = $this->getOption( 'iup_instance' );
		$instance->stream_file_cache         = []; //only keep most recent file for now
		$instance->stream_file_cache[ $key ] = $body;
		$this->debug_cache( 'Object SET', $key );
	}

	private function openWriteStream( $path ) {
		$this->body = new Stream( fopen( 'php://temp', 'r+' ) );

		return true;
	}

	public function stream_eof() {
		return $this->body->eof();
	}

	public function stream_flush() {
		if ( $this->mode == 'r' ) {
			return false;
		}

		if ( $this->body->isSeekable() ) {
			$this->body->seek( 0 );
		}
		$params         = $this->getOptions( true );
		$params['Body'] = $this->body;

		// Attempt to guess the ContentType of the upload based on the
		// file extension of the key. Added by Joe Hoyle
		if ( ! isset( $params['ContentType'] ) &&
		     ( $type = Psr7\MimeType::fromFilename( $params['Key'] ) )
		) {
			$params['ContentType'] = $type;
		}

		/// Expires:
		if ( defined( 'INFINITE_UPLOADS_HTTP_EXPIRES' ) ) {
			$params['Expires'] = INFINITE_UPLOADS_HTTP_EXPIRES;
		}
		// Cache-Control:
		if ( defined( 'INFINITE_UPLOADS_HTTP_CACHE_CONTROL' ) ) {
			if ( is_numeric( INFINITE_UPLOADS_HTTP_CACHE_CONTROL ) ) {
				$params['CacheControl'] = 'max-age=' . INFINITE_UPLOADS_HTTP_CACHE_CONTROL;
			} else {
				$params['CacheControl'] = INFINITE_UPLOADS_HTTP_CACHE_CONTROL;
			}
		}

		/**
		 * Filter the parameters passed to object storage via AWS PHP SDK
		 * Theses are the parameters passed to S3Client::putObject()
		 * See; https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putobject
		 *
		 * @param  {array} $params S3Client::putObject parameters.
		 *
		 * @return {array} $params S3Client::putObject parameters.
		 * @since  1.0
		 * @hook   infinite_uploads_putObject_params
		 *
		 */
		$params = apply_filters( 'infinite_uploads_putObject_params', $params );

		return $this->boolCall( function () use ( $params ) {
			$this->debug( 'PutObject', $params['Key'] );
			$file = Psr7\Utils::copyToString( $params['Body'], $this->calculate_chunk_size() );
			$bool = (bool) $this->getClient()->putObject( $params );

			//Cache the stat for this file so we don't have to do another HeadObject in the same request
			$cache_key = "iu://{$params['Bucket']}/{$params['Key']}";
			if ( $bool ) {
				$this->getCacheStorage()->set( $cache_key, $this->formatUrlStat( [
					'ContentLength' => $params['Body']->getSize(),
					'LastModified'  => time(),
				] ) );
				$this->debug_cache( 'SET', $cache_key );
				$this->cacheObjectSet( $cache_key, $file );

				// For file-excluded paths, mirror the write to local disk so the local URL works.
				if ( InfiniteUploadsHelper::is_file_exclusion_enabled() ) {
					$local_path = InfiniteUploadsHelper::get_local_file_path( $cache_key );
					if ( $local_path !== $cache_key && InfiniteUploadsHelper::is_path_excluded( $local_path ) ) {
						if ( ! is_dir( dirname( $local_path ) ) ) {
							wp_mkdir_p( dirname( $local_path ) );
						}
						file_put_contents( $local_path, $file );
					}
				}
			}
			unset( $file );

			/**
			 * Action when a new object has been uploaded to cloud storage.
			 *
			 * @param {array} $params S3Client::putObject parameters used to upload the object.
			 * @param {boolean} $result Whether the putObject request succeeded or failed.
			 *
			 * @since 1.0
			 * @hook  infinite_uploads_putObject
			 *
			 */
			do_action( 'infinite_uploads_putObject', $params, $bool );

			return $bool;
		} );
	}

	/**
	 * @return LruArrayCache
	 */
	private function getCacheStorage() {
		if ( ! $this->cache ) {
			$this->cache = $this->getOption( 'cache' ) ?: new LruArrayCache();
		}

		return $this->cache;
	}

	public function stream_read( $count ) {
		return $this->body->read( $count );
	}

	public function stream_seek( $offset, $whence = SEEK_SET ) {
		return ! $this->body->isSeekable()
			? false
			: $this->boolCall( function () use ( $offset, $whence ) {
				$this->body->seek( $offset, $whence );

				return true;
			} );
	}

	public function stream_metadata( $path, $option, $value ) {
		// Support image optimization plugins that use touch()/chmod() on cloud files
		if ( is_plugin_active( 'imagify/imagify.php' ) ||
		     is_plugin_active( 'wp-smushit/wp-smush.php' ) ||
		     is_plugin_active( 'wp-smush-pro/wp-smush.php' )
		) {
			return true;
		} else {
			return false;
		}
	}

	public function stream_tell() {
		return $this->boolCall( function () {
			return $this->body->tell();
		} );
	}

	public function stream_write( $data ) {
		return $this->body->write( $data );
	}

	public function stream_stat() {
		$stat    = $this->getStatTemplate();
		$stat[7] = $stat['size'] = $this->getSize();
		$stat[2] = $stat['mode'] = $this->mode;

		return $stat;
	}

	/**
	 * Returns the size of the opened object body.
	 *
	 * @return int|null
	 */
	private function getSize() {
		$size = $this->body->getSize();

		return $size !== null ? $size : $this->size;
	}

	/**
	 * Provides information for is_dir, is_file, filesize, etc. Works on
	 * buckets, keys, and prefixes.
	 *
	 * @link http://www.php.net/manual/en/streamwrapper.url-stat.php
	 */
	public function url_stat( $path, $flags ) {
		$path = $this->normalizeSmushPath( $path );
		$this->initProtocol( $path );

		$extension = pathinfo( $path, PATHINFO_EXTENSION );
		/**
		 * If the file is actually just a path to a directory
		 * then return it as always existing. This is to work
		 * around wp_upload_dir doing file_exists checks on
		 * the uploads directory on every page load.
		 *
		 * Added by Joe Hoyle
		 */
		if ( ! $extension ) {
			return [
				0         => 0,
				'dev'     => 0,
				1         => 0,
				'ino'     => 0,
				2         => 16895,
				'mode'    => 16895,
				3         => 0,
				'nlink'   => 0,
				4         => 0,
				'uid'     => 0,
				5         => 0,
				'gid'     => 0,
				6         => - 1,
				'rdev'    => - 1,
				7         => 0,
				'size'    => 0,
				8         => 0,
				'atime'   => 0,
				9         => 0,
				'mtime'   => 0,
				10        => 0,
				'ctime'   => 0,
				11        => - 1,
				'blksize' => - 1,
				12        => - 1,
				'blocks'  => - 1,
			];
		}

		// Some paths come through as IU:// for some reason.
		$split = explode( '://', $path );
		$path  = strtolower( $split[0] ) . '://' . $split[1];

		// Check if this path is in the url_stat cache
		if ( null !== ( $value = $this->getCacheStorage()->get( $path ) ) ) {
			$this->debug_cache( 'HIT', $path );

			return $value;
		}

		$this->debug_cache( 'MISS', $path );
		$stat = $this->createStat( $path, $flags );

		//cache missing objects as well
		$this->getCacheStorage()->set( $path, $stat );
		$this->debug_cache( 'SET', $path );

		return $stat;
	}

	private function createStat( $path, $flags ) {
		$this->initProtocol( $path );
		$parts = $this->withPath( $path );

		if ( ! $parts['Key'] ) {
			return $this->statDirectory( $parts, $path, $flags );
		}

		return $this->boolCall( function () use ( $parts, $path ) {
			try {
				$this->debug( 'HeadObjects', $parts['Key'] );

				$result = $this->getClient()->headObject( $parts );

				if ( substr( $parts['Key'], - 1, 1 ) == '/' &&
				     $result['ContentLength'] == 0
				) {
					// Return as if it is a bucket to account for console
					// bucket objects (e.g., zero-byte object "foo/")
					return $this->formatUrlStat( $path );
				} else {
					// Attempt to stat and cache regular object
					return $this->formatUrlStat( $result->toArray() );
				}
			} catch ( S3Exception $e ) {
				//only check if it's a prefix if no file extension for performance reasons.
				$extension = pathinfo( $path, PATHINFO_EXTENSION );
				if ( ! $extension ) {
					// Maybe this isn't an actual key, but a prefix. Do a prefix
					// listing of objects to determine.
					$prefix = rtrim( $parts['Key'], '/' ) . '/';
					$this->debug( 'ListObjects', $prefix );
					$result = $this->getClient()->listObjects( [
						'Bucket'  => $parts['Bucket'],
						'Prefix'  => $prefix,
						'MaxKeys' => 1,
					] );
					if ( ! $result['Contents'] && ! $result['CommonPrefixes'] ) {
						throw new \Exception( "File or directory not found: $path" );
					}
				} else {
					throw new \Exception( "File or directory not found: $path" );
				}

				return $this->formatUrlStat( $path );
			}
		}, $flags );
	}

	/**
	 * Get the bucket and key from the passed path (e.g. iu://bucket/key)
	 *
	 * @param  string  $path  Path passed to the stream wrapper
	 *
	 * @return array Hash of 'Bucket', 'Key', and custom params from the context
	 */
	private function withPath( $path ) {
		$params = $this->getOptions( true );

		return $this->getBucketKey( $path ) + $params;
	}

	private function statDirectory( $parts, $path, $flags ) {
		// Stat "directories": buckets, or "iu://"
		if ( ! $parts['Bucket'] ) {
			$this->debug( 'doesBucketExist', $parts['Bucket'] );
		}
		if ( ! $parts['Bucket'] ||
		     $this->getClient()->doesBucketExist( $parts['Bucket'] )
		) {
			return $this->formatUrlStat( $path );
		}

		return $this->triggerError( "File or directory not found: $path", $flags );
	}

	/**
	 * Support for mkdir().
	 *
	 * @param  string  $path     Directory which should be created.
	 * @param  int     $mode     Permissions. 700-range permissions map to
	 *                           ACL_PUBLIC. 600-range permissions map to
	 *                           ACL_AUTH_READ. All other permissions map to
	 *                           ACL_PRIVATE. Expects octal form.
	 * @param  int     $options  A bitwise mask of values, such as
	 *                           STREAM_MKDIR_RECURSIVE.
	 *
	 * @return bool
	 * @link http://www.php.net/manual/en/streamwrapper.mkdir.php
	 */
	public function mkdir( $path, $mode, $options ) {
		$path = $this->normalizeSmushPath( $path );
		$this->initProtocol( $path );
		$params = $this->withPath( $path );
		$this->clearCacheKey( $path );
		if ( ! $params['Bucket'] ) {
			return false;
		}

		if ( ! isset( $params['ACL'] ) ) {
			$params['ACL'] = $this->determineAcl( $mode );
		}

		return empty( $params['Key'] )
			? $this->createBucket( $path, $params )
			: $this->createSubfolder( $path, $params );
	}

	/**
	 * Clears a specific stat cache value from the stat cache and LRU cache.
	 *
	 * @param  string  $key  S3 path (iu://bucket/key).
	 */
	private function clearCacheKey( $key ) {
		clearstatcache( true, $key );
		$this->getCacheStorage()->remove( $key );
		$this->debug_cache( 'DELETE', $key );
	}

	/**
	 * Determine the most appropriate ACL based on a file mode.
	 *
	 * @param  int  $mode  File mode
	 *
	 * @return string
	 */
	private function determineAcl( $mode ) {
		switch ( substr( decoct( $mode ), 0, 1 ) ) {
			case '7':
				return 'public-read';
			case '6':
				return 'authenticated-read';
			default:
				return 'private';
		}
	}

	/**
	 * Creates a bucket for the given parameters.
	 *
	 * @param  string  $path    Stream wrapper path
	 * @param  array   $params  A result of StreamWrapper::withPath()
	 *
	 * @return bool Returns true on success or false on failure
	 */
	private function createBucket( $path, array $params ) {
		$this->debug( 'doesBucketExist', $params['Bucket'] );
		if ( $this->getClient()->doesBucketExist( $params['Bucket'] ) ) {
			return $this->triggerError( "Bucket already exists: {$path}" );
		}

		return $this->boolCall( function () use ( $params, $path ) {
			$this->debug( 'CreateBucket', $params['Bucket'] );
			$this->getClient()->createBucket( $params );
			$this->clearCacheKey( $path );

			return true;
		} );
	}

	/**
	 * Creates a pseudo-folder by creating an empty "/" suffixed key
	 *
	 * @param  string  $path    Stream wrapper path
	 * @param  array   $params  A result of StreamWrapper::withPath()
	 *
	 * @return bool
	 */
	private function createSubfolder( $path, array $params ) {
		// Ensure the path ends in "/" and the body is empty.
		$params['Key']  = rtrim( $params['Key'], '/' ) . '/';
		$params['Body'] = '';

		// Fail if this pseudo directory key already exists
		$this->debug( 'doesObjectExist', $params['Key'] );
		if ( $this->getClient()->doesObjectExist(
			$params['Bucket'],
			$params['Key'] )
		) {
			return $this->triggerError( "Subfolder already exists: {$path}" );
		}

		return $this->boolCall( function () use ( $params, $path ) {
			$this->debug( 'PutObject', $params['Key'] );
			$bool = (bool) $this->getClient()->putObject( $params );

			//Cache the stat for this file so we don't have to do another HeadObject in the same request
			$cache_key = "iu://{$params['Bucket']}/{$params['Key']}";
			if ( $bool ) {
				$this->getCacheStorage()->set( $cache_key, $this->formatUrlStat( [
					'ContentLength' => 0,
					'LastModified'  => time(),
				] ) );
				$this->debug_cache( 'SET', $cache_key );
				//purposely don't cache this 0-length fake file
			}

			return true;
		} );
	}

	public function rmdir( $path, $options ) {
		$path = $this->normalizeSmushPath( $path );
		$this->initProtocol( $path );
		$this->clearCacheKey( $path );
		$params = $this->withPath( $path );
		$client = $this->getClient();

		if ( ! $params['Bucket'] ) {
			return $this->triggerError( 'You must specify a bucket' );
		}

		return $this->boolCall( function () use ( $params, $path, $client ) {
			if ( ! $params['Key'] ) {
				$this->debug( 'deleteBucket', $params['Bucket'] );
				$client->deleteBucket( [ 'Bucket' => $params['Bucket'] ] );

				return true;
			}

			return $this->deleteSubfolder( $path, $params );
		} );
	}

	/**
	 * Deletes a nested subfolder if it is empty.
	 *
	 * @param  string  $path    Path that is being deleted (e.g., 'iu://a/b/c')
	 * @param  array   $params  A result of StreamWrapper::withPath()
	 *
	 * @return bool
	 */
	private function deleteSubfolder( $path, $params ) {
		// Use a key that adds a trailing slash if needed.
		$prefix = rtrim( $params['Key'], '/' ) . '/';
		$this->debug( 'ListObjects', $prefix );

		$result = $this->getClient()->listObjects( [
			'Bucket'  => $params['Bucket'],
			'Prefix'  => $prefix,
			'MaxKeys' => 1,
		] );

		// Check if the bucket contains keys other than the placeholder
		if ( $contents = $result['Contents'] ) {
			return ( count( $contents ) > 1 || $contents[0]['Key'] != $prefix )
				? $this->triggerError( 'Subfolder is not empty' )
				: $this->unlink( rtrim( $path, '/' ) . '/' );
		}

		return $result['CommonPrefixes']
			? $this->triggerError( 'Subfolder contains nested folders' )
			: true;
	}

	public function unlink( $path ) {
		$path = $this->normalizeSmushPath( $path );
		$this->initProtocol( $path );

		return $this->boolCall( function () use ( $path ) {
			$this->clearCacheKey( $path );
			$this->debug( 'DeleteObject', $path );

			$this->getClient()->deleteObject( $this->withPath( $path ) );
			$this->getCacheStorage()->set( $path, false );
			$this->debug_cache( 'SET', $path );
			$this->cacheObjectDelete( $path );

			return true;
		} );
	}

	/**
	 * Cache last put/get object
	 *
	 * @param $key
	 */
	private function cacheObjectDelete( $key ) {
		$instance = $this->getOption( 'iup_instance' );
		unset( $instance->stream_file_cache[ $key ] );
		$this->debug_cache( 'Object DELETE', $key );
	}

	/**
	 * Close the directory listing handles
	 *
	 * @return bool true on success
	 */
	public function dir_closedir() {
		$this->objectIterator = null;
		gc_collect_cycles();

		return true;
	}

	/**
	 * This method is called in response to rewinddir()
	 *
	 * @return boolean true on success
	 */
	public function dir_rewinddir() {
		$this->boolCall( function () {
			$this->objectIterator = null;
			$this->dir_opendir( $this->openedPath, null );

			return true;
		} );
	}

	/**
	 * Support for opendir().
	 *
	 * The opendir() method of the Amazon S3 stream wrapper supports a stream
	 * context option of "listFilter". listFilter must be a callable that
	 * accepts an associative array of object data and returns true if the
	 * object should be yielded when iterating the keys in a bucket.
	 *
	 * @see http://www.php.net/manual/en/function.opendir.php
	 *
	 * @param  string  $options  Unused option variable
	 *
	 * @param  string  $path     The path to the directory
	 *                           (e.g. "iu://dir[</prefix>]")
	 *
	 * @return bool true on success
	 */
	public function dir_opendir( $path, $options ) {
		$path = $this->normalizeSmushPath( $path );
		$this->initProtocol( $path );
		$this->openedPath = $path;
		$params           = $this->withPath( $path );
		$delimiter        = $this->getOption( 'delimiter' );
		/** @var callable $filterFn */
		$filterFn           = $this->getOption( 'listFilter' );
		$op                 = [ 'Bucket' => $params['Bucket'] ];
		$this->openedBucket = $params['Bucket'];

		if ( $delimiter === null ) {
			$delimiter = '/';
		}

		if ( $delimiter ) {
			$op['Delimiter'] = $delimiter;
		}

		if ( $params['Key'] ) {
			$params['Key'] = rtrim( $params['Key'], $delimiter ) . $delimiter;
			// Support paths ending in "*" to allow listing of arbitrary prefixes.
			if ( substr( $params['Key'], - 1, 1 ) === '*' ) {
				$params['Key'] = rtrim( $params['Key'], '*' );
				// Set the opened bucket prefix to be the directory. This is because $this->openedBucketPrefix
				// will be removed from the resulting keys, and we want to return all files in the directory
				// of the wildcard.
				$this->openedBucketPrefix = substr( $params['Key'], 0, ( strrpos( $params['Key'], '/' ) ?: 0 ) + 1 );
			} else {
				$params['Key']            = rtrim( $params['Key'], $delimiter ) . $delimiter;
				$this->openedBucketPrefix = $params['Key'];
			}
			$op['Prefix'] = $params['Key'];
		}

		$this->openedBucketPrefix = $params['Key'];

		$this->debug( 'ListObjects', $op['Prefix'] );
		// Filter our "/" keys added by the console as directories, and ensure
		// that if a filter function is provided that it passes the filter.
		$this->objectIterator = \ClikIT\Infinite_Uploads\Aws\flatmap(
			$this->getClient()->getPaginator( 'ListObjects', $op ),
			function ( Result $result ) use ( $filterFn ) {
				$contentsAndPrefixes = $result->search( '[Contents[], CommonPrefixes[]][]' );

				// Filter out dir place holder keys and use the filter fn.
				return array_filter(
					$contentsAndPrefixes,
					function ( $key ) use ( $filterFn ) {
						return ( ! $filterFn || call_user_func( $filterFn, $key ) )
						       && ( ! isset( $key['Key'] ) || substr( $key['Key'], - 1, 1 ) !== '/' );
					}
				);
			}
		);

		return true;
	}

	/**
	 * This method is called in response to readdir()
	 *
	 * @return string Should return a string representing the next filename, or
	 *                false if there is no next file.
	 * @link http://www.php.net/manual/en/function.readdir.php
	 */
	public function dir_readdir() {
		// Skip empty result keys
		if ( ! $this->objectIterator->valid() ) {
			return false;
		}

		// First we need to create a cache key. This key is the full path to
		// then object in s3: protocol://bucket/key.
		// Next we need to create a result value. The result value is the
		// current value of the iterator without the opened bucket prefix to
		// emulate how readdir() works on directories.
		// The cache key and result value will depend on if this is a prefix
		// or a key.
		$cur = $this->objectIterator->current();
		if ( isset( $cur['Prefix'] ) ) {
			// Include "directories". Be sure to strip a trailing "/"
			// on prefixes.
			$result = rtrim( $cur['Prefix'], '/' );
			$key    = $this->formatKey( $result );
			$stat   = $this->formatUrlStat( $key );
		} else {
			$result = $cur['Key'];
			$key    = $this->formatKey( $cur['Key'] );
			$stat   = $this->formatUrlStat( $cur );
		}

		// Cache the object data for quick url_stat lookups used with
		// RecursiveDirectoryIterator.
		$this->getCacheStorage()->set( $key, $stat );
		$this->debug_cache( 'SET', $key );
		$this->objectIterator->next();

		// Remove the prefix from the result to emulate other stream wrappers.
		return $this->openedBucketPrefix
			? substr( $result, strlen( $this->openedBucketPrefix ) )
			: $result;
	}

	private function formatKey( $key ) {
		$protocol = explode( '://', $this->openedPath )[0];

		return "{$protocol}://{$this->openedBucket}/{$key}";
	}

	/**
	 * Called in response to rename() to rename a file or directory. Currently
	 * only supports renaming objects.
	 *
	 * @param  string  $path_from  the path to the file to rename
	 * @param  string  $path_to    the new path to the file
	 *
	 * @return bool true if file was successfully renamed
	 * @link http://www.php.net/manual/en/function.rename.php
	 */
	public function rename( $path_from, $path_to ) {
		$path_from = $this->normalizeSmushPath( $path_from );
		$path_to   = $this->normalizeSmushPath( $path_to );
		// PHP will not allow rename across wrapper types, so we can safely
		// assume $path_from and $path_to have the same protocol
		$this->initProtocol( $path_from );
		$partsFrom = $this->withPath( $path_from );
		$partsTo   = $this->withPath( $path_to );
		//$this->clearCacheKey( $path_from );
		//$this->clearCacheKey( $path_to );

		if ( ! $partsFrom['Key'] || ! $partsTo['Key'] ) {
			return $this->triggerError( 'The Infinite Uploads stream wrapper only '
			                            . 'supports copying objects' );
		}

		return $this->boolCall( function () use ( $partsFrom, $partsTo ) {
			$options = $this->getOptions( true );
			// Copy the object and allow overriding default parameters if
			// desired, but by default copy metadata
			$this->debug( 'CopyObject', $partsFrom['Key'] . ' to ' . $partsTo['Key'] );
			$this->getClient()->copy(
				$partsFrom['Bucket'],
				$partsFrom['Key'],
				$partsTo['Bucket'],
				$partsTo['Key'],
				isset( $options['acl'] ) ? $options['acl'] : 'private',
				$options
			);

			//Copy the stat cache for this file so we don't have to do another HeadObject in the same request
			$from_key  = "iu://{$partsFrom['Bucket']}/{$partsFrom['Key']}";
			$from_stat = $this->getCacheStorage()->get( $from_key );
			if ( ! is_null( $from_stat ) ) {
				$to_key = "iu://{$partsTo['Bucket']}/{$partsTo['Key']}";
				$this->getCacheStorage()->set( $to_key, $from_stat );
				$this->debug_cache( 'SET', $to_key );
			}

			// Delete the original object
			$this->debug( 'DeleteObject', $partsFrom['Key'] );
			$this->getClient()->deleteObject( [
				                                  'Bucket' => $partsFrom['Bucket'],
				                                  'Key'    => $partsFrom['Key'],
			                                  ] + $options );
			//cache source file as deleted so file_exists will not trigger a HeadObject later
			$this->getCacheStorage()->set( $from_key, false );
			$this->debug_cache( 'SET', $from_key );
			$this->cacheObjectDelete( $from_key );

			return true;
		} );
	}

	public function stream_cast( $cast_as ) {
		return false;
	}

	/**
	 * Calculate a chunk size for reading and writing streams.
	 *
	 * @return float|int
	 */
	public function calculate_chunk_size() {
		$max_upload_size = wp_max_upload_size();
		if ( defined( 'BIG_FILE_UPLOADS_CHUNK_SIZE_KB' ) ) {
			$chunk_size = BIG_FILE_UPLOADS_CHUNK_SIZE_KB * 1024; // Convert to bytes.
		} else {
			$max_chunk = ( MB_IN_BYTES * 20 );
			if ( $max_chunk > $max_upload_size ) {
				$chunk_size = ( $max_upload_size * 0.8 );  // 80% of max upload size in bytes.
			} else {
				$chunk_size = $max_chunk;
			}
		}

		return $chunk_size;
	}

}
