/** Datei: library/ARUNOX/API/Filesystem/Filesystem.php **/
<?php
	
	/**
	 * ARUNOX\API\Filesystem\Filesystem
	 *
	 * Stellt eine API zum Filesystem zur Verfügung
	 *
	 * @author          Sparky
	 * @copyright       2025 ARUNOX
	 * @version         1.2.0
	 */
	
	namespace ARUNOX\API;
	
	use RuntimeException;
	use ARUNOX\API\Filesystem\File;
	use ARUNOX\API\Filesystem\Directory;
	
	class Filesystem  {
		/* ###  VARIABLES  ################################################	# */
		private static		null|string		$FILESYSTEM			= NULL;
		private static		null|Directory	$ROOT_DIR			= NULL;
		private static		null|string		$ROOT_URL			= NULL;
		
		/* ###  PUBLIC STATIC FILESYSTEM FUNCTIONS  #######################	# */
		public static function instance( null|string $filesystem = NULL ) : self {
			$filesystem = self::existsFilesystem( $filesystem ?? static::class );
			
			if( $filesystem == self::class ) $filesystem = static::getFilesystem();
			
			if( !is_a( $filesystem, self::class, TRUE ) ) throw new RuntimeException("Class `{$filesystem}` ist no Filesystem." );
			
			return new $filesystem();
		}
		
		public static function setFilesystem( string $filesystem ) : void {
			self::existsFilesystem( $filesystem );
			static::$FILESYSTEM = $filesystem;
		}
		
		public static function setAsDefault() : void {
			static::$FILESYSTEM = static::class;
		}
		
		public static function getFilesystem() : null|string {
			return static::$FILESYSTEM;
		}
		
		public static function existsFilesystem( null|string $filesystem = NULL ) : string {
			$filesystem ??= static::getFilesystem();
			
			if( !$filesystem ) throw new RuntimeException( "No Filesystem defined as default" );
			
			if( !class_exists( $filesystem ) ) throw new RuntimeException( "Filesystem `{$filesystem}` ist missing." );
			
			return $filesystem;
		}
		
		/* ###  PUBLIC STATIC ROOT FUNCTIONS  #############################	# */
		public static function setRootDir( string $directory ) : null|Directory {
			static::$ROOT_DIR = NULL;
			
			if( !static::existsDir( $directory ) ) static::createDir( $directory );
			
			static::$ROOT_DIR = static::getDir( $directory );
			
			return static::getRootDir();
		}
		
		public static function getRootDir() : null|Directory {
			return static::$ROOT_DIR;
		}
		
		public static function setRootUrl( string $url ) : string {
			static::$ROOT_URL = $url;
			
			return static::getRootUrl();
		}
		
		public static function getRootUrl() : null|string {
			return static::$ROOT_URL;
		}
		
		/* ###  PROTECTED STATIC FUNCTIONS  ###############################	# */
		protected static function call( $method, ...$args ) : mixed {
			$filesystem = static::getFilesystem();
			
			if( !$filesystem ) throw new RuntimeException( "Method `{$method}`not supported." );
			
			self::existsFilesystem();
			
			if( !method_exists( $filesystem, $method ) ) throw new RuntimeException( "Method `{$method}`not supported in Filesystem '{$filesystem}'." );
			
			return $filesystem::{$method}( ...$args );
		}
		
		/* ###  PUBLIC STATIC UNIVERSAL FUNCTIONS  ########################	# */
		public static function exists( string $path_or_filename ) : bool {
			if( static::isFile( $path_or_filename ) ) return static::existsFile( $path_or_filename );
			if( static::isDir( $path_or_filename ) ) return static::existsDir( $path_or_filename );
			
			return FALSE;
		}
		public static function get( string $path_or_filename ) : bool|File|Directory {
			if( static::isFile( $path_or_filename ) ) return static::getFile( $path_or_filename );
			if( static::isDir( $path_or_filename ) ) return static::getDir( $path_or_filename );
			
			return FALSE;
		}
		public static function put( string $path_or_filename ) : bool|File|Directory {
			if( static::isFile( $path_or_filename ) ) return static::putFile( $path_or_filename );
			if( static::isDir( $path_or_filename ) ) return static::putDir( $path_or_filename );
			
			return FALSE;
		}
		public static function delete( string $path_or_filename ) : bool {
			if( static::isFile( $path_or_filename ) ) return static::deleteFile( $path_or_filename );
			if( static::isDir( $path_or_filename ) ) return static::removeDir( $path_or_filename );
			
			return FALSE;
		}
		public static function move( string $path_or_filename, string $destination ) : bool {
			if( static::isFile( $path_or_filename ) ) return static::moveFile( $path_or_filename, $destination );
			if( static::isDir( $path_or_filename ) ) return static::moveDir( $path_or_filename, $destination );
			
			return FALSE;
		}
		public static function copy( string $path_or_filename, string $destination ) : bool {
			if( static::isFile( $path_or_filename ) ) return static::copyFile( $path_or_filename, $destination );
			if( static::isDir( $path_or_filename ) ) return static::copyDir( $path_or_filename, $destination );
			
			return FALSE;
		}
		
		/* ###  PUBLIC STATIC FILE FUNCTIONS  #############################	# */
		public static function isFile( string $filename ) : bool {
			return static::call( __FUNCTION__, $filename );
		}
		
		public static function existsFile( string $filename ) : bool {
			return static::call( __FUNCTION__, $filename );
		}
		public static function readFile( string $filename ) : mixed {
			return static::call( __FUNCTION__, $filename );
		}
		public static function writeFile( string $filename, mixed $content ) : bool {
			return static::call( __FUNCTION__, $filename, $content );
		}
		public static function deleteFile( string $filename ) : bool {
			return static::call( __FUNCTION__, $filename );
		}
		public static function moveFile( string $filename, string $destination ) : bool {
			return static::call( __FUNCTION__, $filename, $destination );
		}
		public static function copyFile( string $filename, string $destination ) : bool {
			return static::call( __FUNCTION__, $filename, $destination );
		}
		
		public static function getFile( string $filename ) : null|File {
			return static::call( __FUNCTION__, $filename );
		}
		public static function putFile( string $filename, mixed $content ) : bool|File {
			return static::call( __FUNCTION__, $filename, $content );
		}
		
		public static function mimetype( string $filename ) : bool|string {
			return static::call( __FUNCTION__, $filename );
		}
		public static function filename( string $filename ) : bool|string {
			return static::call( __FUNCTION__, $filename );
		}
		public static function fileurl( string $filename ) : bool|string {
			return static::call( __FUNCTION__, $filename );
		}
		public static function basename( string $filename ) : bool|string {
			return static::call( __FUNCTION__, $filename );
		}
		public static function extension( string $filename ) : bool|string {
			return static::call( __FUNCTION__, $filename );
		}
		public static function filesize( string $filename ) : bool|string {
			return static::call( __FUNCTION__, $filename );
		}
		public static function filesizes( string $filename ) : array {
			return static::call( __FUNCTION__, $filename );
		}
		public static function filehash( string $filename ) : bool|string {
			return static::call( __FUNCTION__, $filename );
		}
		public static function created( string $filename ) : int {
			return static::call( __FUNCTION__, $filename );
		}
		public static function modified( string $filename ) : int {
			return static::call( __FUNCTION__, $filename );
		}
		public static function permissions( string $filename ) : int {
			return static::call( __FUNCTION__, $filename );
		}
		
		public static function upload( array $file, string $destination, null|string $filename = NULL ) : null|File {
			return static::call( __FUNCTION__, $file, $destination, $filename );
		}
		
		/* ###  PUBLIC STATIC DIRECTORY FUNCTIONS  ########################	# */
		public static function isDir( string $directory ) : bool {
			return static::call( __FUNCTION__, $directory );
		}
		
		public static function existsDir( string $directory ) : bool {
			return static::call( __FUNCTION__, $directory );
		}
		public static function createDir( string $directory, int $mode = 0777, bool $recursive = FALSE ) : bool {
			return static::call( __FUNCTION__, $directory, $mode, $recursive );
		}
		public static function readDir( string $directory ) : array {
			return static::call( __FUNCTION__, $directory );
		}
		public static function listDirs( string $directory, bool $recursive = FALSE ) : array {
			return static::call( __FUNCTION__, $directory, $recursive );
		}
		public static function listFiles( string $directory, bool $recursive = FALSE ) : array {
			return static::call( __FUNCTION__, $directory, $recursive );
		}
		public static function removeDir( string $directory ) : bool {
			return static::call( __FUNCTION__, $directory );
		}
		public static function moveDir( string $directory, string $destination ) : bool {
			return static::call( __FUNCTION__, $directory, $destination );
		}
		public static function copyDir( string $directory, string $destination ) : bool {
			return static::call( __FUNCTION__, $directory, $destination );
		}
		
		public static function getDir( string $directory ) : null|Directory {
			return static::call( __FUNCTION__, $directory );
		}
		
		public static function putDir( string $directory, int $mode = 0777, bool $recursive = TRUE ) : bool|Directory {
			return static::call( __FUNCTION__, $directory, $mode, $recursive );
		}
	}

/** Datei: library/ARUNOX/API/Filesystem/Local.php **/
<?php
	
	/**
	 * ARUNOX\API\Local
	 *
	 * Stellt eine API zum Filesystem zur Verfügung
	 *
	 * @author          Sparky
	 * @copyright       2025 ARUNOX
	 * @version         1.2.0
	 */
	
	namespace ARUNOX\API\Filesystem;
	
	use DirectoryIterator;
	use ARUNOX\API\Filesystem;
	
	class Local extends Filesystem {
		/* ###  VARIABLES  ################################################	# */
		/* ###  PUBLIC STATIC FUNCTIONS  ##################################	# */
		/* ###  PUBLIC STATIC FILE FUNCTIONS  #############################	# */
		public static function isFile( string $filename ) : bool {
			return is_file( $filename );
		}
		
		public static function existsFile( string $filename ) : bool {
			return file_exists( $filename );
		}
		
		public static function readFile( string $filename ) : mixed {
			return is_readable( $filename ) ? file_get_contents( $filename ) : NULL;
		}
		
		public static function writeFile( string $filename, mixed $content ) : bool {
			if( is_array( $content ) || is_object( $content ) ) {
				$content = json_encode( $content, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES );
			}
			
			static::createDir( static::dirname( $filename ) );
			
			return file_put_contents( $filename, $content ) !== false;
		}
		
		public static function deleteFile( string $filename ) : bool {
			return unlink( $filename );
		}
		
		public static function moveFile( string $filename, string $destination ) : bool {
			return rename( $filename, $destination );
		}
		
		public static function copyFile( string $filename, string $destination ) : bool {
			return copy( $filename, $destination );
		}
		
		public static function getFile( string $filename ) : null|File {
			return file_exists( $filename ) ? new File( realpath( $filename ), static::class ) : NULL;
		}
		
		public static function putFile( string $filename, mixed $content ) : bool|File {
			if( static::writeFile( $filename, $content ) !== FALSE ) {
				return static::getFile( $filename );
			}
			
			return FALSE;
		}
	
		public static function mimetype( string $filename ) : bool|string {
			return mime_content_type( $filename );
		}
		
		public static function filename( string $filename ) : bool|string {
			return pathinfo( $filename, PATHINFO_FILENAME );
		}
		
		public static function fileurl( string $filename ) : bool|string {
			$rootDir = static::getRootDir();
			$rootUrl = static::getRootUrl();
			
			return str_replace( $rootDir->path, $rootUrl, $filename );
		}
		
		public static function basename( string $filename ) : bool|string {
			return pathinfo( $filename, PATHINFO_BASENAME );
		}
		
		public static function extension( string $filename ) : bool|string {
			return pathinfo( $filename, PATHINFO_EXTENSION );
		}
		
		public static function filesize( string $filename ) : bool|string {
			return filesize( $filename );
		}
		
		public static function filesizes( string $filename ) : array {
			$info = getimagesize( $filename );
			return [ "w" => $info[0], "h" => $info[1] ];
		}
		
		public static function filehash( string $filename ) : bool|string {
			return hash_file("sha256", $filename );
		}
		
		public static function created( string $filename ) : int {
			$stat = stat( $filename );
			return $stat['ctime'] ?? 0;
		}
		
		public static function modified( string $filename ) : int {
			$stat = stat( $filename );
			return $stat['mtime'] ?? 0;
		}
		
		public static function permissions( string $filename ) : int {
			$stat = stat( $filename );
			return $stat['mode'] ?? 0;
		}
		
		public static function upload( array $file, string $destination, null|string $filename = NULL ) : null|File {
			if( !isset( $file["tmp_name"], $file["name"]) || !is_uploaded_file( $file["tmp_name"] ) ) {
				return NULL;
			}
			
			$extension	 = static::extension( $file["name"] );
			$filename	 = static::filename( $filename ?? $file["name"] );
			$destination = rtrim( $destination, DIRECTORY_SEPARATOR );
			$target		 = $destination . DIRECTORY_SEPARATOR . $filename . "." . $extension;
			
			if( !static::existsDir( $destination ) ) static::createDir( $destination );
			
//			show( $filename, $extension, $destination, $target, "STOP ");
			
			if( move_uploaded_file( $file["tmp_name"], $target ) ) {
				return static::getFile( $target );
			}
			
			return NULL;
		}
		
		/* ###  PUBLIC STATIC DIRECTORY FUNCTIONS  ########################	# */
		public static function isDir( string $directory ) : bool {
			return is_dir( $directory );
		}
		
		public static function existsDir( string $directory ) : bool {
			return file_exists( $directory );
		}
		
		public static function createDir( string $directory, int $mode = 0777, bool $recursive = TRUE ) : bool {
			return @mkdir( $directory, $mode, $recursive ) !== FALSE;
		}
		
		public static function readDir( string $directory ) : array {
			$list = [];
			
			foreach( new DirectoryIterator( $directory ) as $item ) {
				if( !$item->isDot() ) {
					$list[] = $directory . DIRECTORY_SEPARATOR . $item->getFilename();
				}
			}
			
			return $list;
		}
		
		public static function listDirs( string $directory, bool $recursive = FALSE ) : array {
			$list = [];
			
			foreach( new DirectoryIterator( $directory ) as $item ) {
				if( !$item->isDot() && $item->isDir()) {
					$list[] = $directory . DIRECTORY_SEPARATOR . $item->getFilename();
				}
			}
			
			return $list;
		}
		
		public static function listFiles( string $directory, bool $recursive = FALSE ) : array {
			$list = [];
			
			foreach( new DirectoryIterator( $directory ) as $item ) {
				if( !$item->isDot() && $item->isFile() ) {
					$list[] = $directory . DIRECTORY_SEPARATOR . $item->getFilename();
				}
				
				if( $recursive && !$item->isDot() && $item->isDir() ) {
					$files = static::listFiles( $directory . DIRECTORY_SEPARATOR . $item->getFilename(), TRUE );
					array_push( $list, ...$files );
				}
			}
			
			return $list;
		}
		
		public static function removeDir( string $directory ) : bool {
			return rmdir( $directory );
		}
		
		public static function moveDir( string $directory, string $destination ) : bool {
			return rename( $directory, $destination );
		}
		
		public static function copyDir( string $directory, string $destination ) : bool {
			return copy( $directory, $destination );
		}
		
		public static function getDir( string $directory ) : null|Directory {
			return file_exists( $directory ) ? new Directory( realpath( $directory ), static::class ) : NULL;
		}
		
		public static function putDir( string $directory, int $mode = 0777, bool $recursive = TRUE ) : bool|Directory {
			if( static::createDir( $directory, $mode, $recursive ) !== FALSE ) {
				return static::getDir( $directory );
			}
			
			return FALSE;
		}
		
		public static function dirname( string $directory ) : bool|string {
			return pathinfo( $directory, PATHINFO_DIRNAME );
		}
	}

/** Datei: library/ARUNOX/API/Filesystem/Directory.php **/
<?php
	
	/**
	 * ARUNOX\API\Filesystem\Directory
	 *
	 * Stellt eine API zum Filesystem zur Verfügung
	 *
	 * @author          Sparky
	 * @copyright       2025 ARUNOX
	 * @version         1.2.0
	 */
	
	namespace ARUNOX\API\Filesystem;
	
	use Traversable;
	use ArrayIterator;
	use IteratorAggregate;
	use ARUNOX\API\Filesystem;
	
	class Directory implements IteratorAggregate {
		/* ###  VARIABLES  ################################################	# */
		public readonly		string			$path;
		public readonly		string			$name;
		private				string			$filesystem;
		private				null|array		$files				= NULL;
		private				null|array		$directories		= NULL;
		private				bool			$fileRecursive		= FALSE;
		private				bool			$dirsRecursive		= FALSE;
		
		/* ###  PUBLIC FUNCTIONS  #########################################	# */
		public function getIterator() : Traversable {
			return new ArrayIterator( array_merge( $this->files(), $this->directories() ) );
		}
		
		public function files( bool $recursive = FALSE ) : array {
			if( $this->files === NULL || $this->fileRecursive != $recursive ) {
				$this->fileRecursive = $recursive;
				$this->loadFiles( $recursive );
			}
			
			return $this->files;
		}
		
		public function directories( bool $recursive = FALSE ) : array {
			if( $this->directories === NULL || $this->dirsRecursive != $recursive ) {
				$this->dirsRecursive = $recursive;
				$this->loadDirs( $recursive );
			}
			
			return $this->directories;
		}
		
		/* ###  PROTECTED FUNCTIONS  ######################################	# */
		protected function loadFiles( bool $recursive = FALSE ) : void {
			$this->files = $this->filesystem::listFiles( $this->path, $recursive );
			
			foreach( $this->files as &$file ) {
				$file = $this->filesystem::getFile( $file );
			}
		}
		
		protected function loadDirs( bool $recursive = FALSE ) : void {
			$this->directories = $this->filesystem::listDirs( $this->path, $recursive );
			
			foreach( $this->directories as &$dir ) {
				$dir = $this->filesystem::getDir( $dir );
			}
		}
		
		/* ###  PUBLIC MAGIC FUNCTIONS  ###################################	# */
		public function __construct( string $directory, string $filesystem ) {
			if( !class_exists( $filesystem ) ) throw new RuntimeException( "Filesystem `{$filesystem}` ist missing." );
			if( !$filesystem::isDir( $directory ) ) throw new RuntimeException( "Directory `{$directory}` not found." );
			
			$this->path			= $directory;
			$this->filesystem	= $filesystem;
			$this->name			= $filesystem::basename( $directory );
		}
		
		public function __get( string $name ) {
			if( method_exists( $this, $name ) ) {
				return $this->{$name}();
			}
		}
		
		public function __toString() : string {
			return $this->path;
		}
		
		public static function __callStatic( string $name, array $args ) {
			if( method_exists( Filesystem::class, "{$name}Dir" ) ) {
				return Filesystem::{"{$name}Dir"}( ...$args );
			}
		}
	}

/** Datei: library/ARUNOX/API/Filesystem/File.php **/
<?php
	
	/**
	 * ARUNOX\API\Filesystem\File
	 *
	 * Stellt eine API zum File Objekt zur Verfügung
	 *
	 * @author          Sparky
	 * @copyright       2025 ARUNOX
	 * @version         1.2.0
	 */
	
	namespace ARUNOX\API\Filesystem;
	
	class File {
		/* ###  VARIABLES  ################################################	# */
		public readonly		string			$path;
		public readonly		string			$filename;
		public readonly		string			$basename;
		public readonly		string			$extension;
		public readonly		string			$dirname;
		public readonly		string			$url;
		private				null|string		$versioned			= NULL;
		private				null|string		$mime				= NULL;
		private				null|int		$size				= NULL;
		private				null|array		$sizes				= NULL;
		private				null|int		$created			= NULL;
		private				null|int		$modified			= NULL;
		private				null|int		$permissions		= NULL;
		private				null|string		$hash				= NULL;
		private				null|string		$content			= NULL;
		private				string			$filesystem;
		
		/* ###  PUBLIC FUNCTIONS  #########################################	# */
		public function content() : string {
			if( $this->content === NULL ) {
				$this->content = $this->filesystem::readFile( $this->path );
			}
			
			return $this->content;
		}
		
		public function versioned() : string {
			return "{$this->url}?_={$this->modified()}";
		}
		
		public function size() : int {
			if( $this->size === NULL ) {
				$this->size = $this->filesystem::filesize( $this->path );
			}
			
			return $this->size;
		}
		
		public function sizes() : array {
			if( $this->sizes === NULL ) {
				$this->sizes = $this->filesystem::filesizes( $this->path );
			}
			
			return $this->sizes;
		}
		
		public function mime() : string {
			if( $this->mime === NULL ) {
				$this->mime = $this->filesystem::mimetype( $this->path );
			}
			
			return $this->mime;
		}
		
		public function hash() : string {
			if( $this->hash === NULL ) {
				$this->hash = $this->filesystem::filehash( $this->path );
			}
			
			return $this->hash;
		}
		
		public function created() : int {
			if( $this->created === NULL ) {
				$this->created = $this->filesystem::created( $this->path );
			}
			
			return $this->created;
		}
		
		public function modified() : int {
			if( $this->modified === NULL ) {
				$this->modified = $this->filesystem::modified( $this->path );
			}
			
			return $this->modified;
		}
		
		public function permissions() : int {
			if( $this->permissions === NULL ) {
				$this->permissions = $this->filesystem::permissions( $this->path );
			}
			
			return $this->permissions;
		}
		
		/* ###  PROTECTED FUNCTIONS  ######################################	# */
		/* ###  PUBLIC MAGIC FUNCTIONS  ###################################	# */
		public function __construct( string $filename, string $filesystem ) {
			if( !class_exists( $filesystem ) ) throw new RuntimeException( "Filesystem `{$filesystem}` ist missing." );
			if( !$filesystem::isFile( $filename ) ) throw new RuntimeException( "File `{$filename}` not found." );
			
			$this->path			= $filename;
			$this->filesystem	= $filesystem;
			$this->basename		= $filesystem::basename( $filename );
			$this->extension 	= $filesystem::extension( $filename );
			$this->filename		= $filesystem::filename( $filename );
			$this->dirname		= $filesystem::dirname( $filename );
			$this->url			= $filesystem::fileurl( $filename );
		}
		
		public function __get( string $name ) {
			if( method_exists( $this, $name ) ) {
				return $this->{$name}();
			}
		}
	}