kiri-core/Annotation/Loader.php

<?php


namespace Annotation;


use Annotation\Model\Get;
use Annotation\Model\Relation;
use Annotation\Model\Set;
use Attribute;
use DirectoryIterator;
use Exception;
use ReflectionClass;
use ReflectionException;
use ReflectionMethod;
use Snowflake\Abstracts\BaseObject;
use Snowflake\Exception\NotFindClassException;
use Snowflake\Snowflake;
use Throwable;


/**
 * Class Loader
 * @package Annotation
 */
class Loader extends BaseObject
{


	private static array $_classes = [];


	private static array $_directory = [];


	private static array $_property = [];


	private static array $_methods = [];


	private array $_annotationMaps = [];


	/**
	 * @return array
	 */
	public function getDirectory(): array
	{
		return static::$_directory;
	}

	/**
	 * @param $path
	 * @param $namespace
	 * @throws Exception
	 */
	public function loader($path, $namespace)
	{
		$this->_scanDir(new DirectoryIterator($path), $namespace);
	}


	/**
	 * @return array
	 */
	public function getClasses(): array
	{
		return static::$_classes;
	}


	/**
	 * @param string $class
	 * @param string $property
	 * @return mixed
	 */
	public function getProperty(string $class, string $property = ''): mixed
	{
		if (!isset(static::$_property[$class])) {
			return null;
		}
		if (!empty($property)) {
			return static::$_property[$class][$property] ?? [];
		}
		return static::$_property[$class];
	}


	/**
	 * @param string $class
	 * @param mixed $handler
	 * @return Loader
	 */
	public function injectProperty(string $class, object $handler): static
	{
		$properties = $this->getProperty($class);
		if (empty($properties)) {
			return $this;
		}
		foreach ($properties as $property => $attributes) {
			foreach ($attributes as $attribute) {
				$attribute->execute($handler, $property);
			}
		}
		return $this;
	}


	/**
	 * @param string $class
	 * @param string $method
	 * @return mixed
	 */
	public function getMethod(string $class, string $method = ''): array
	{
		if (!isset(static::$_methods[$class])) {
			return [];
		}
		$properties = static::$_methods[$class];
		if (!empty($method) && isset($properties[$method])) {
			return $properties[$method];
		}
		return $properties;
	}


	/**
	 * @param string $class
	 * @return array
	 */
	public function getTarget(string $class): array
	{
		return static::$_classes[$class] ?? [];
	}


	/**
	 * @param DirectoryIterator $paths
	 * @param $namespace
	 * @throws Exception
	 */
	public function _scanDir(DirectoryIterator $paths, $namespace)
	{
		foreach ($paths as $path) {
			if ($path->isDot() || str_starts_with($path->getFilename(), '.')) {
				continue;
			}
			if ($path->isDir()) {
				$iterator = new DirectoryIterator($path->getRealPath());
				$directory = rtrim($path->getRealPath(), '/');
				if (!isset(static::$_directory[$directory])) {
					static::$_directory[$directory] = [];
				}
				$this->_scanDir($iterator, $namespace);
			} else {
				$this->readFile($path, $namespace);
			}
		}
	}


	/**
	 * @param DirectoryIterator $path
	 * @param $namespace
	 * @throws Exception
	 */
	private function readFile(DirectoryIterator $path, $namespace)
	{
		try {
			if ($path->getExtension() !== 'php') {
				return;
			}
			$replace = $this->getReflect($path, $namespace);
			if (empty($replace) || count($replace->getAttributes(Target::class)) < 1) {
				return;
			}
			$this->appendFileToDirectory($path->getRealPath(), $replace->getName());

			$_array['handler'] = $replace->newInstance();
			$_array['target'] = [];
			$_array['methods'] = [];
			$_array['property'] = [];

			$_array = $this->_targets($replace, $_array);
			$_array = $this->_methods($replace, $_array);
			$_array = $this->_properties($replace, $_array);

			static::$_classes[$replace->getName()] = $_array;
		} catch (Throwable $throwable) {
			$this->addError($throwable, 'throwable');
		}
	}


	/**
	 * @param DirectoryIterator $path
	 * @param string $namespace
	 * @return ReflectionClass|null
	 * @throws ReflectionException
	 * @throws NotFindClassException
	 */
	private function getReflect(DirectoryIterator $path, string $namespace): ?ReflectionClass
	{
		return Snowflake::getDi()->getReflect($this->explodeFileName($path, $namespace));
	}


	/**
	 * @param ReflectionClass $replace
	 * @param array $_array
	 * @return array
	 */
	private function _targets(ReflectionClass $replace, array $_array): array
	{
		foreach ($replace->getAttributes() as $attribute) {
			if ($attribute->getName() == Attribute::class) {
				continue;
			}
			if ($attribute->getName() == Target::class) {
				continue;
			}
			$_array['target'][] = $attribute->newInstance();
		}
		return $_array;
	}


	/**
	 * @param ReflectionClass $replace
	 * @param array $_array
	 * @return array
	 */
	private function _methods(ReflectionClass $replace, array $_array): array
	{
		$methods = $replace->getMethods(ReflectionMethod::IS_PUBLIC);
		foreach ($methods as $method) {
			$_method = [];
			foreach ($method->getAttributes() as $attribute) {
				if (!class_exists($attribute->getName())) {
					continue;
				}
				$_method[] = $attribute->newInstance();
			}

			static::$_methods[$replace->getName()][$method->getName()] = $_method;

			$_array['methods'][$method->getName()] = $_method;
		}
		return $_array;
	}


	/**
	 * @param ReflectionClass $replace
	 * @param array $_array
	 * @return array
	 */
	private function _properties(ReflectionClass $replace, array $_array): array
	{
		$methods = $replace->getProperties();
		foreach ($methods as $method) {
			$_property = [];
			if ($method->isStatic()) continue;
			foreach ($method->getAttributes() as $attribute) {
				if (!class_exists($attribute->getName())) {
					continue;
				}
				$_property[] = $attribute->newInstance();
			}

			static::$_property[$replace->getName()][$method->getName()] = $_property;

			$_array['property'][$method->getName()] = $_property;
		}
		return $_array;
	}


	/**
	 * @param string $path
	 * @param string|array $outPath
	 * @throws Exception
	 */
	public function loadByDirectory(string $path, string|array $outPath = '')
	{
		try {
			$path = '/' . trim($path, '/');
			foreach (static::$_directory as $key => $_path) {
				$key = '/' . trim($key, '/');
				if (!str_starts_with($key, $path) || in_array($key, $outPath)) {
					continue;
				}
				$this->execute($_path);
			}
		} catch (Throwable $exception) {
			$this->addError($exception, 'throwable');
		}
	}


	/**
	 * @param DirectoryIterator $path
	 * @param string $namespace
	 * @return string
	 */
	private function explodeFileName(DirectoryIterator $path, string $namespace): string
	{
		$replace = str_replace(APP_PATH . 'app', '', $path->getRealPath());

		$replace = str_replace('.php', '', $replace);
		$replace = str_replace(DIRECTORY_SEPARATOR, '\\', $replace);
		$explode = explode('\\', $replace);
		array_shift($explode);

		return $namespace . '\\' . implode('\\', $explode);
	}


	/**
	 * @param string $filePath
	 * @param string $className
	 */
	public function appendFileToDirectory(string $filePath, string $className)
	{
		$array = explode('/', $filePath);
		unset($array[count($array) - 1]);

		$array = '/' . trim(implode('/', $array), '/');

		static::$_directory[$array][] = $className;
	}


	/**
	 * @param array $classes
	 * @throws Exception
	 */
	private function execute(array $classes)
	{
		if (empty($classes)) {
			return;
		}
		$annotation = Snowflake::getAnnotation();

		foreach ($classes as $className) {
			$annotations = static::$_classes[$className] ?? null;
			if ($annotations === null) {
				continue;
			}
			foreach ($annotations['methods'] as $name => $attribute) {
				$this->methods($annotations, $attribute, $annotation, $className, $name);
			}
		}
	}


	/**
	 * @param $annotations
	 * @param $attribute
	 * @param $annotation
	 * @param $className
	 * @param $name
	 */
	private function methods($annotations, $attribute, $annotation, $className, $name)
	{
		foreach ($attribute as $value) {
			if ($value instanceof Relation) {
				$annotation->addRelate($className, $value->name, $name);
			} else if ($value instanceof Get) {
				$annotation->addGets($className, $value->name, $name);
			} else if ($value instanceof Set) {
				$annotation->addSets($className, $value->name, $name);
			} else {
				$value->execute($annotations['handler'], $name);
			}
		}
	}

}