<?php

declare(strict_types=1);

namespace Kiri\Di;

use DirectoryIterator;
use Kiri\Abstracts\Component;
use Kiri\Di\Inject\Container;
use Kiri\Di\Inject\Skip;
use Psr\Container\ContainerInterface;
use ReflectionClass;
use ReflectionMethod;
use Throwable;

class Scanner extends Component
{
	#[Container(ContainerInterface::class)]
	public ContainerInterface $container;

	public array $files = [];

	private array $fileMtimes = [];

	private ?bool $hasOpcache = null;

	private string $basePath;

	private ScanManifest $manifest;

	private ?ChangeSet $changeSet = null;

	private array $visitedFiles = [];

	private array $config = [
		'skip_patterns' => ['/vendor/', '/tests/', '/cache/', '/node_modules/'],
		'skip_directories' => [],
		'extensions' => ['php'],
		'max_depth' => 20,
		'follow_links' => false,
		'cache_enabled' => false,
		'cache_ttl' => 3600,
		'debug' => false,
		'class_name_strategy' => 'auto',
	];

	public function __construct()
	{
		$this->basePath = $this->normalizePath($_SERVER['PWD'] ?? APP_PATH ?? getcwd());
		$this->manifest = new ScanManifest();
	}

	public function setConfig(array $config): void
	{
		$this->config = array_merge($this->config, $config);
	}

	public function scan(string $path, ?string $cacheFile = null): ChangeSet
	{
		$path = $this->normalizePath($path);
		$this->changeSet = new ChangeSet();
		$this->visitedFiles = [];
		$cacheLoaded = false;

		if ($this->config['cache_enabled']) {
			$cacheFile = $cacheFile ?? $this->getDefaultCacheFile();
			if ($this->loadFromCache($cacheFile, $path)) {
				$this->replayManifest($path);
				return $this->changeSet;
			}
			$cacheLoaded = $this->manifest->all() !== [];
		}

		$this->scanDirectory($path);
		$this->detectRemovedFiles($path);

		if ($cacheLoaded) {
			$this->replayManifest($path, $this->changeSet->getChangedFiles());
		}

		$this->syncLegacyState();

		if ($this->config['cache_enabled']) {
			$this->saveToCache($cacheFile);
		}

		return $this->changeSet;
	}

	public function scanFiles(array $files, ?string $scopePath = null, ?string $cacheFile = null): ChangeSet
	{
		$this->changeSet = new ChangeSet();
		$this->visitedFiles = [];
		$cacheLoaded = false;

		if ($scopePath !== null) {
			$scopePath = $this->normalizePath($scopePath);
		}

		if ($this->config['cache_enabled'] && $scopePath !== null) {
			$cacheFile = $cacheFile ?? $this->getDefaultCacheFile();
			$this->loadFromCache($cacheFile, $scopePath);
			$cacheLoaded = $this->manifest->all() !== [];
		}

		foreach (array_values(array_unique($files)) as $file) {
			$path = $this->normalizePath($file);
			if (file_exists($path)) {
				$this->processFile($path);
				continue;
			}

			$this->markRemovedFile($path);
		}

		if ($cacheLoaded && $scopePath !== null) {
			$this->replayManifest($scopePath, $this->changeSet->getChangedFiles());
		}

		$this->syncLegacyState();
		return $this->changeSet;
	}

	private function scanDirectory(string $path, int $depth = 0): void
	{
		if ($depth > $this->config['max_depth']) {
			return;
		}

		try {
			$dir = new DirectoryIterator($path);
		} catch (Throwable $e) {
			$this->logError($e, ['path' => $path, 'action' => 'open_directory']);
			return;
		}

		foreach ($dir as $item) {
			if ($this->shouldSkipItem($item)) {
				continue;
			}

			$realPath = $this->normalizePath($item->getRealPath() ?: $item->getPathname());
			if ($item->isDir()) {
				if ($this->shouldSkipDirectory($realPath)) {
					continue;
				}

				if ($item->isLink() && !$this->config['follow_links']) {
					continue;
				}

				$this->scanDirectory($realPath, $depth + 1);
				continue;
			}

			if ($item->isFile()) {
				$this->processFile($realPath);
			}
		}
	}

	private function shouldSkipItem(DirectoryIterator $item): bool
	{
		return $item->isDot() || str_starts_with($item->getFilename(), '.');
	}

	private function shouldSkipDirectory(string $path): bool
	{
		$path = rtrim($this->normalizePath($path), '/') . '/';
		$skipDirs = array_merge(
			$this->config['skip_directories'],
			config('site.scanner.skip', [])
		);

		if (in_array($path, $skipDirs, true)) {
			return true;
		}

		foreach ($this->config['skip_patterns'] as $pattern) {
			if (strpos($path, $pattern) !== false) {
				return true;
			}
		}

		return false;
	}

	private function processFile(string $path): void
	{
		$path = $this->normalizePath($path);
		if (!in_array(pathinfo($path, PATHINFO_EXTENSION), $this->config['extensions'], true)) {
			return;
		}

		$this->visitedFiles[$path] = true;
		if (!$this->shouldProcessFile($path)) {
			return;
		}

		try {
			$oldClasses = $this->manifest->getClasses($path);
			$this->invalidateClasses($oldClasses);
			$newClasses = $this->loadAndParseFile($path);

			$this->manifest->set($path, (int)filemtime($path), $newClasses);
			$this->changeSet?->addChangedFile($path);

			foreach (array_diff($oldClasses, $newClasses) as $class) {
				$this->changeSet?->addRemovedClass($class);
			}

			foreach ($newClasses as $class) {
				$this->changeSet?->addChangedClass($class);
			}
		} catch (Throwable $e) {
			$this->logError($e, [
				'file' => $path,
				'action' => 'process_file',
			]);

			if ($e instanceof \ParseError) {
				throw $e;
			}
		}
	}

	private function shouldProcessFile(string $path): bool
	{
		if (!file_exists($path)) {
			return false;
		}

		$mtime = (int)filemtime($path);
		$cachedMtime = $this->manifest->getMtime($path);

		return $cachedMtime === null || $cachedMtime < $mtime;
	}

	private function loadAndParseFile(string $path): array
	{
		$this->optimizeWithOpcache($path);
		require_once $path;

		$classes = $this->getClassNamesForFile($path);
		foreach ($classes as $class) {
			if (class_exists($class)) {
				$this->analyzeClass($class);
			}
		}

		return $classes;
	}

	private function getClassNamesForFile(string $path): array
	{
		$strategy = $this->config['class_name_strategy'];
		$classes = [];

		if (in_array($strategy, ['auto', 'extract', 'both'], true)) {
			$class = $this->extractClassNameFromFile($path);
			if ($class !== null) {
				$classes[] = $class;
			}
		}

		if ($classes === [] || in_array($strategy, ['rename', 'both'], true)) {
			$classes[] = $this->renamePathToClassName($path);
		}

		return array_values(array_unique(array_filter($classes)));
	}

	private function canExtractClassName(): bool
	{
		return function_exists('token_get_all');
	}

	private function extractClassNameFromFile(string $path): ?string
	{
		if (!$this->canExtractClassName()) {
			return null;
		}

		$content = @file_get_contents($path);
		if ($content === false || $content === '') {
			return null;
		}

		$tokens = @token_get_all($content);
		if (!$tokens) {
			return null;
		}

		$namespace = '';
		$class = '';
		$collectingNamespace = false;
		$collectingClass = false;
		$previousToken = null;

		foreach ($tokens as $token) {
			if (is_array($token)) {
				$text = $token[1];

				if ($token[0] === T_NAMESPACE) {
					$namespace = '';
					$collectingNamespace = true;
				} elseif ($collectingNamespace && in_array($token[0], [T_STRING, T_NAME_QUALIFIED, T_NS_SEPARATOR], true)) {
					$namespace .= $text;
				} elseif ($collectingNamespace && $token[0] === T_WHITESPACE) {
				} elseif (in_array($token[0], [T_CLASS, T_INTERFACE, T_TRAIT, T_ENUM], true) && $previousToken !== T_DOUBLE_COLON && $previousToken !== T_NEW) {
					$collectingClass = true;
				} elseif ($collectingClass && $token[0] === T_STRING) {
					$class = $text;
					break;
				} elseif ($collectingNamespace) {
					$collectingNamespace = false;
				}

				if ($token[0] !== T_WHITESPACE) {
					$previousToken = $token[0];
				}
				continue;
			}

			if ($collectingNamespace && ($token === ';' || $token === '{')) {
				$collectingNamespace = false;
			}
			if ($token === '{') {
				$collectingClass = false;
			}
			$previousToken = $token;
		}

		if ($class === '') {
			return null;
		}

		return $namespace !== '' ? $namespace . '\\' . $class : $class;
	}

	private function renamePathToClassName(string $path): string
	{
		$relativePath = str_replace($this->basePath, '', $this->normalizePath($path));
		$relativePath = str_replace('.php', '', $relativePath);
		$parts = explode('/', trim($relativePath, '/\\'));
		$parts = array_values(array_filter($parts, fn(string $part) => $part !== ''));
		$parts = array_map('ucfirst', $parts);

		return implode('\\', $parts);
	}

	private function optimizeWithOpcache(string $path): void
	{
		if ($this->hasOpcache === null) {
			$this->hasOpcache = function_exists('opcache_invalidate') && function_exists('opcache_compile_file');
		}

		if (!$this->hasOpcache) {
			return;
		}

		try {
			opcache_invalidate($path, true);
			opcache_compile_file($path);
		} catch (Throwable $e) {
			if ($this->config['debug']) {
				$this->logError($e, [
					'file' => $path,
					'action' => 'opcache_optimize',
				]);
			}
		}
	}

	private function analyzeClass(string $class): void
	{
		try {
			$reflect = $this->container->getReflectionClass($class);
			if (!$reflect->isInstantiable() || $reflect->isTrait() || $reflect->isEnum() || $reflect->isInterface()) {
				return;
			}

			if ($this->shouldSkipClass($reflect)) {
				return;
			}

			$this->analyzeClassMethods($reflect, $class);
		} catch (Throwable $e) {
			$this->logError($e, [
				'class' => $class,
				'action' => 'analyze_class',
			]);
		}
	}

	private function shouldSkipClass(ReflectionClass $reflect): bool
	{
		$attributes = array_map(fn($attr) => $attr->getName(), $reflect->getAttributes());

		return in_array(Skip::class, $attributes, true)
			|| in_array(\Attribute::class, $attributes, true);
	}

	private function analyzeClassMethods(ReflectionClass $reflect, string $class): void
	{
		foreach ($reflect->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
			if ($method->isStatic() || $method->getDeclaringClass()->getName() !== $class) {
				continue;
			}

			$this->processMethodAttributes($method, $class);
		}
	}

	private function processMethodAttributes(ReflectionMethod $method, string $class): void
	{
		foreach ($method->getAttributes() as $attribute) {
			$attributeName = $attribute->getName();
			if (!class_exists($attributeName)) {
				continue;
			}

			try {
				$instance = $attribute->newInstance();
				if (method_exists($instance, 'dispatch')) {
					$instance->dispatch($class, $method->getName());
				}
			} catch (Throwable $e) {
				$this->logError($e, [
					'class' => $class,
					'method' => $method->getName(),
					'attribute' => $attributeName,
					'action' => 'process_attribute',
				]);
			}
		}
	}

	private function getDefaultCacheFile(): string
	{
		$cacheDir = defined('APP_PATH')
			? rtrim(str_replace('\\', '/', APP_PATH), '/') . '/storage/.kiri-scanner-cache/'
			: sys_get_temp_dir() . '/kiri-scanner-cache/';
		if (!is_dir($cacheDir)) {
			mkdir($cacheDir, 0755, true);
		}

		$projectHash = md5(__DIR__);
		return $cacheDir . 'scanner_' . $projectHash . '.json';
	}

	private function loadFromCache(string $cacheFile, string $path): bool
	{
		if (!file_exists($cacheFile)) {
			return false;
		}

		if (filemtime($cacheFile) + $this->config['cache_ttl'] < time()) {
			return false;
		}

		$data = json_decode(file_get_contents($cacheFile), true);
		if (!is_array($data) || !isset($data['manifest'])) {
			return false;
		}

		$this->manifest->fromArray($data['manifest']);
		$this->syncLegacyState();

		return !$this->hasDirectoryChanged($path);
	}

	private function hasDirectoryChanged(string $path): bool
	{
		$currentFiles = $this->collectFiles($path);
		$cachedFiles = $this->manifest->paths(rtrim($path, '/\\') . '/');

		sort($currentFiles);
		sort($cachedFiles);
		if ($currentFiles !== $cachedFiles) {
			return true;
		}

		foreach ($currentFiles as $file) {
			if (!file_exists($file)) {
				return true;
			}

			if ($this->manifest->getMtime($file) !== (int)filemtime($file)) {
				return true;
			}
		}

		return false;
	}

	private function saveToCache(string $cacheFile): void
	{
		$data = [
			'manifest' => $this->manifest->all(),
			'timestamp' => time(),
			'version' => '2.0',
		];

		file_put_contents($cacheFile, json_encode($data, JSON_PRETTY_PRINT));
		$this->cleanupOldCacheFiles(dirname($cacheFile));
	}

	private function cleanupOldCacheFiles(string $cacheDir): void
	{
		$files = glob($cacheDir . '/scanner_*.json');
		$now = time();

		foreach ($files as $file) {
			if (filemtime($file) + (7 * 24 * 3600) < $now) {
				unlink($file);
			}
		}
	}

	private function logError(Throwable $e, array $context = []): void
	{
		$fullContext = array_merge($context, [
			'message' => $e->getMessage(),
			'code' => $e->getCode(),
			'file' => $e->getFile(),
			'line' => $e->getLine(),
			'trace' => $e->getTraceAsString(),
			'time' => date('Y-m-d H:i:s'),
		]);

		if (function_exists('error')) {
			error($e, $fullContext);
		} else {
			error_log(json_encode($fullContext));
		}

		if ($this->config['debug'] && php_sapi_name() === 'cli') {
			echo "Scanner Error: {$e->getMessage()} in {$e->getFile()}:{$e->getLine()}\n";
			if ($context !== []) {
				echo 'Context: ' . json_encode($context) . "\n";
			}
		}
	}

	public function load_directory(string $path): void
	{
		$this->scan($path);
	}

	protected function parseFile($file): void
	{
		$absolutePath = $this->normalizePath($this->basePath . '/' . ltrim((string)$file, '/')) . '.php';
		if (file_exists($absolutePath)) {
			$this->processFile($absolutePath);
		}
	}

	protected function skipNames(ReflectionClass $reflect): array
	{
		return array_map(fn($attr) => $attr->getName(), $reflect->getAttributes());
	}

	public function getStats(): array
	{
		return [
			'total_files' => count($this->files),
			'cached_mtimes' => count($this->fileMtimes),
			'base_path' => $this->basePath,
			'config' => $this->config,
			'manifest_entries' => count($this->manifest->all()),
		];
	}

	public function reset(): void
	{
		$this->files = [];
		$this->fileMtimes = [];
		$this->hasOpcache = null;
		$this->manifest = new ScanManifest();
		$this->changeSet = null;
		$this->visitedFiles = [];
	}

	private function detectRemovedFiles(string $path): void
	{
		$prefix = rtrim($path, '/\\') . '/';
		foreach ($this->manifest->paths($prefix) as $file) {
			if (!isset($this->visitedFiles[$file])) {
				$this->markRemovedFile($file);
			}
		}
	}

	private function markRemovedFile(string $path): void
	{
		if (!$this->manifest->has($path)) {
			return;
		}

		$classes = $this->manifest->remove($path);
		$this->invalidateClasses($classes);
		foreach ($classes as $class) {
			$this->changeSet?->addRemovedClass($class);
		}

		$this->changeSet?->addRemovedFile($path);
	}

	private function syncLegacyState(): void
	{
		$this->files = array_keys($this->manifest->all());
		$this->fileMtimes = [];
		foreach ($this->manifest->all() as $path => $entry) {
			$this->fileMtimes[$path] = (int)$entry['mtime'];
		}
	}

	private function collectFiles(string $path, int $depth = 0): array
	{
		if ($depth > $this->config['max_depth']) {
			return [];
		}

		$files = [];
		try {
			$dir = new DirectoryIterator($path);
		} catch (Throwable) {
			return [];
		}

		foreach ($dir as $item) {
			if ($this->shouldSkipItem($item)) {
				continue;
			}

			$realPath = $this->normalizePath($item->getRealPath() ?: $item->getPathname());
			if ($item->isDir()) {
				if ($this->shouldSkipDirectory($realPath)) {
					continue;
				}
				if ($item->isLink() && !$this->config['follow_links']) {
					continue;
				}
				$files = array_merge($files, $this->collectFiles($realPath, $depth + 1));
				continue;
			}

			if ($item->isFile() && in_array(pathinfo($realPath, PATHINFO_EXTENSION), $this->config['extensions'], true)) {
				$files[] = $realPath;
			}
		}

		return $files;
	}

	private function normalizePath(string $path): string
	{
		$resolved = realpath($path) ?: $path;
		return str_replace('\\', '/', $resolved);
	}

	private function replayManifest(string $path, array $skipPaths = []): void
	{
		$skip = array_fill_keys(array_map([$this, 'normalizePath'], $skipPaths), true);
		$prefix = rtrim($path, '/\\') . '/';

		foreach ($this->manifest->paths($prefix) as $file) {
			if (isset($skip[$file])) {
				continue;
			}

			foreach ($this->manifest->getClasses($file) as $class) {
				if (class_exists($class)) {
					$this->analyzeClass($class);
				}
			}
		}
	}

	private function invalidateClasses(array $classes): void
	{
		foreach ($classes as $class) {
			if (method_exists($this->container, 'forgetClass')) {
				$this->container->forgetClass($class);
			}
		}
	}
}