{

public const MOVE_CHUNK_SIZE = 1024;

public const ERROR_PHRASE = [

UPLOAD_ERR_OK => "There is no error, the file uploaded with success",

UPLOAD_ERR_INI_SIZE => "The uploaded file exceeds the upload_max_filesize directive in php.ini",

UPLOAD_ERR_FORM_SIZE => "The uploaded file exceeds the MAX_FILE_SIZE directive that was specified " .

"in the HTML form",

UPLOAD_ERR_PARTIAL => "The uploaded file was only partially uploaded",

UPLOAD_ERR_NO_FILE => "No file was uploaded",

UPLOAD_ERR_NO_TMP_DIR => "No temporary directory. This is a server error, please try again later",

UPLOAD_ERR_CANT_WRITE => "Failed to write file to disk",

UPLOAD_ERR_EXTENSION => "A PHP extension stopped the file upload"

];

private $stream;

private $size;

private $name;

private $type;

private $tmp;

private $error;

private $moved;

//private $target;

/**

public function __construct(StreamInterface|array|string $stream, mixed ...$vars)

{

if (count($vars) > 0 && is_string($stream)) {

array_unshift($vars, $stream);

$stream = array_combine(['name', 'type', 'tmp_name', 'error', 'size'], $vars);

}

if ($stream instanceof StreamInterface) {

$this->stream = $stream;

} elseif (isset($stream['tmp_name'])) {

$this->name = $stream['name'];

$this->type = $stream['type'];

$this->tmp = $stream['tmp_name'];

$this->error = $stream['error'];

$this->size = $stream['size'];

} elseif (is_string($stream)) {

$this->stream = $this->withStream($stream);

} else {

throw new RuntimeException("Could not validate arguments for the upload stream", 1);

}

}

/**

public function getStream(): StreamInterface

{

if ($this->stream === null) {

throw new RuntimeException("The no stream exists. You need to construct a new stream", 1);

}

if (is_string($this->stream)) {

$this->stream = $this->withStream($this->stream);

}

return $this->stream;

}

/**

public function moveTo($targetPath): void

{

if ($this->moved) {

throw new RuntimeException('File has already been moved');

}

if (!is_writable(dirname($targetPath))) {

throw new RuntimeException('Target directory is not writable');

}

if ($this->stream !== null) {

$this->streamFile($targetPath);

} elseif ($this->tmp !== null) {

$this->moveUploadedFile($targetPath);

}

if (!$this->moved) {

throw new RuntimeException('Failed to move file to target path');

}

}

/**

public function streamFile(string $targetPath): void

{

$stream = $this->getStream();

$stream->seek(0);

$targetStream = new Stream($targetPath, 'w');

while (!$stream->eof()) {

$targetStream->write($stream->read($this::MOVE_CHUNK_SIZE));

}

// Add file to stream so it is changeable after upload

$this->stream = $targetStream;

$this->moved = true;

}

/**

public function moveUploadedFile(string $targetPath)

{

if (!is_uploaded_file($this->tmp)) {

throw new RuntimeException("Could not upload the file \"{$this->name}\" becouse of a conflict.");

}

$this->moved = move_uploaded_file($this->tmp, $targetPath);

// Add file to stream as a String, that way it will be prepared and

// without loading resource unless you call/follow up with the @getStream method

if ($this->moved) {

$this->stream = $targetPath;

}

return $this->moved;

}

/**

public function getSize(): ?int

{

return ($this->size === null) ? (($this->stream instanceof StreamInterface) ? $this->stream->getSize() : null) : $this->size;

}

/**

public function getError()

{

return (int)$this->error;

}

/**

public function getErrorPhrase(): ?string

{

return ($this::ERROR_PHRASE[$this->error] ?? null);

}

/**

public function getClientFilename(): ?string

{

return $this->name;

}

/**

public function getClientMediaType(): ?string

{

return $this->type;

}

public function withStream(string $stream): StreamInterface

{

$inst = new Stream($stream, 'r+');

return $inst;

}