<?php

namespace PentagonalProject\SlimService;

use ArrayAccess;

use Countable;

use Exception;

use InvalidArgumentException;

use PentagonalProject\SlimService\Abstracts\ModularAbstract;

use PentagonalProject\SlimService\Exceptions\InvalidModularException;

use PentagonalProject\SlimService\Exceptions\ModularNotFoundException;

use RecursiveDirectoryIterator;

use RuntimeException;

use Slim\Collection;

use SplFileInfo;

/**

* Class ModularCollection

* @package PentagonalProject\SlimService

*/

class ModularCollection implements Countable, ArrayAccess

{

const TYPE_DIR = 'dir';

const TYPE_SYMLINK = 'link';

const TYPE_FILE = 'file';

const CLASS_NAME_KEY = 'className';

const FILE_PATH_KEY = 'filePath';

/**

* @var RecursiveDirectoryIterator

*/

protected $splFileInfo;

/**

* @var string

*/

protected $modularDirectory;

/**

* @var string[]

*/

protected $unwantedPath = [];

/**

* @var ModularAbstract[]|string[]

* String if Has not Loaded and Instanceof @uses ModularAbstract if loaded

*/

protected $validModular = [];

/**

* @var Exception[]

*/

protected $invalidModular = [];

/**

* @var string[]

*/

protected $loadedModular = [];

/**

* @var bool

*/

protected $hasScanned = false;

/**

* @var array

*/

protected $modularDefaultInfo = [

ModularAbstract::NAME,

ModularAbstract::VERSION,

ModularAbstract::URI,

ModularAbstract::AUTHOR,

ModularAbstract::AUTHOR_URI,

ModularAbstract::DESCRIPTION,

ModularAbstract::CLASS_NAME,

ModularAbstract::FILE_PATH

];

/**

* @var ModularParser

*/

protected $modularParser;

/**

* ModularCollection constructor.

* @param string $modularDirectory

* @param ModularParser $modularParser

*/

public function __construct(string $modularDirectory, ModularParser $modularParser)

{

$this->modularParser = $modularParser;

if (!is_dir($modularDirectory) || ! is_readable($modularDirectory)) {

throw new RuntimeException(

sprintf(

'Invalid %s Directory. %s directory not exists or has not readable by system!',

$this->modularParser->getName()

),

E_COMPILE_ERROR

);

}

$this->splFileInfo = new \SplFileInfo($modularDirectory);

if ($this->splFileInfo->isLink()) {

throw new RuntimeException(

sprintf(

'Invalid %s Directory. %s directory could not as a symlink!',

$this->modularParser->getName()

),

E_COMPILE_ERROR

);

}

$this->modularDirectory = $this->splFileInfo->getRealPath();

}

/**

* Get Path Modular Directory

*

* @return string

*/

public function getModularDirectory(): string

{

return $this->modularDirectory;

}

/**

* @return ModularAbstract[]

*/

public function getAllValidModular() : array

{

return $this->validModular;

}

/**

* Scan ModularAbstract Directory

*

* @return ModularCollection

*/

public function scan() : ModularCollection

{

if ($this->hasScanned) {

return $this;

}

/**

* @var SplFileInfo $path

*/

foreach (new RecursiveDirectoryIterator($this->getModularDirectory()) as $path) {

$baseName = $path->getBaseName();

// skip dotted

if ($baseName == '.' || $baseName == '..') {

continue;

}

$directory = $this->getModularDirectory() . DIRECTORY_SEPARATOR . $baseName;

// don't allow symlink to be execute & skip if contains file

if ($path->isLink() || ! $path->isDir()) {

$this->unwantedPath[$baseName] = $path->getType();

continue;

}

$file = $directory . DIRECTORY_SEPARATOR . $baseName .'.php';

if (! file_exists($file)) {

$this->invalidModular[$baseName] = new ModularNotFoundException(

$file,

sprintf(

'%1$s file for %2$s has not found',

$this->modularParser->getName(),

$baseName

)

);

continue;

}

try {

$modular = $this

->modularParser

->create($file)

->process();

if (! $modular->isValid()) {

throw new InvalidModularException(

sprintf(

'%1$s Is not valid.',

$this->modularParser->getName()

)

);

}

$this->validModular[$this->sanitizeModularName($baseName)] = [

static::CLASS_NAME_KEY => $modular->getClassName(),

static::FILE_PATH_KEY => $modular->getFile(),

];

} catch (\Exception $e) {

$this->invalidModular[$this->sanitizeModularName($baseName)] = $e;

}

}

return $this;

}

/**

* Get Invalid Modular

*

* @return Exception[]

*/

public function getInvalidModular() : array

{

return $this->invalidModular;

}

/**

* Get Unwanted Path

* contain [file|dir|link]

*

* @see ModularCollection::TYPE_SYMLINK

* @see ModularCollection::TYPE_DIR

* @see ModularCollection::TYPE_FILE

*

* @return string[]

*/

public function getUnwantedPath() : array

{

return $this->unwantedPath;

}

/**

* @see getUnwantedPath()

*

* @return string[]

*/

public function getUnwantedPaths() : array

{

return $this->unwantedPath;

}

/**

* Get Loaded Modular List base on Name

*

* @return string[]

*/

public function getLoadedModularName() : array

{

return $this->loadedModular;

}

/**

* @return ModularAbstract[]

*/

public function getLoadedModular() : array

{

$modularCollections = [];

foreach ($this->getLoadedModularName() as $value) {

if (isset($this->validModular[$value])) {

$modularCollections[$value] = $this->validModular[$value];

}

}

return $modularCollections;

}

/**

* Sanitize Modular Name

*

* @param string $name

* @return string

*/

public function sanitizeModularName(string $name) : string

{

return trim(strtolower($name));

}

/**

* Get Modular Given By Name

*

* @access protected

*

* @param string $name

* @return ModularAbstract

* @throws InvalidModularException

* @throws Exception

*/

protected function &internalGetModular(string $name) : ModularAbstract

{

$modularName = $this->sanitizeModularName($name);

if (!$modularName) {

throw new InvalidArgumentException(

"Please insert not an empty arguments",

E_USER_ERROR

);

}

if (!$this->exist($modularName)) {

throw new InvalidModularException(

sprintf(

'%1$s %2$s has not found',

$this->modularParser->getName(),

$name

)

);

}

if (is_array($this->validModular[$modularName])) {

$className = empty($this->validModular[$modularName][static::CLASS_NAME_KEY])

? null

: (string) $this->validModular[$modularName][static::CLASS_NAME_KEY];

if (! $className

|| ! class_exists($this->validModular[$modularName][static::CLASS_NAME_KEY])

) {

throw new InvalidModularException(

sprintf(

'%1$s %2$s has not found',

$this->modularParser->getName(),

$name

)

);

}

$modular = new $className(

$this->modularParser->getContainer(),

$modularName

);

$this->validModular[$modularName] = $modular;

}

if (! $this->validModular[$modularName] instanceof ModularAbstract) {

unset($this->validModular[$modularName]);

$e = new InvalidModularException(

sprintf(

'%1$s %2$s Is not valid.',

$this->modularParser->getName(),

$name

)

);

$this->invalidModular[$modularName] = $e;

throw $e;

}

return $this->validModular[$modularName];

}

/**

* Get ModularAbstract's Info

*

* @param string $modularName

* @return Collection

*/

public function getModularInformation(string $modularName)

{

return new Collection($this->internalGetModular($modularName)->getModularInfo());

}

/**

* Get All ModularAbstract Info

*

* @return Collection|Collection[]

*/

public function getAllModularInfo()

{

$modularInfo = new Collection();

foreach ($this->getAllValidModular() as $modularName => $modular) {

$modularInfo[$modularName] = $this->getModularInformation($modularName);

}

return $modularInfo;

}

/**

* Load Modular

*

* @param string $name

* @return ModularAbstract

* @throws InvalidModularException

* @throws ModularNotFoundException

*/

public function &load(string $name) : ModularAbstract

{

$modular =& $this->internalGetModular($name);

if (!$this->hasLoaded($name)) {

$modular->init();

$this->loadedModular[$this->sanitizeModularName($name)] = true;

}

return $modular;

}

/**

* Check if Modular Exists

*

* @param string $name

* @return bool

*/

public function exist(string $name)

{

return isset($this->validModular[$this->sanitizeModularName($name)]);

}

/**

* Check If Modular Has Loaded

*

* @param string $name

* @return bool

*/

public function hasLoaded(string $name)

{

$modularName = $this->sanitizeModularName($name);

return $modularName && !empty($this->loadedModular[$modularName]);

}

/**

* {@inheritdoc}

*/

public function count()

{

return count($this->validModular);

}

/**

* @param string $offset

* @return ModularAbstract

*/

public function offsetGet($offset)

{

return $this->load($offset);

}

/**

* @param string $offset

* @return bool

*/

public function offsetExists($offset)

{

return $this->exist($offset);

}

/**

* {@inheritdoc}

* no affected here

*/

public function offsetSet($offset, $value)

{

return;

}

/**

* {@inheritdoc}

*/

public function offsetUnset($offset)

{

return;

}

/**

* @param string $name

* @return ModularAbstract

*/

public function __get($name)

{

return $this->load($name);

}

}