router.default.php

<?php
namespace GT\WebEngine;

use Gt\Http\Request;
use GT\WebEngine\AmbiguousPathException;
use GT\Routing\BaseRouter;
use GT\Routing\Method\Any;
use GT\Routing\Path\FileMatch\BasicFileMatch;
use GT\Routing\Path\FileMatch\MagicFileMatch;
use GT\Routing\Path\PathMatcher;
use GT\WebEngine\View\HTMLView;
use GT\WebEngine\View\JSONView;

class DefaultRouter extends BaseRouter {
	#[Any(name: "page-route", accept: "text/html,application/xhtml+xml")]
	public function page(Request $request):void {
		$pathMatcher = new PathMatcher("page");
		$this->setViewClass(HTMLView::class);
		$this->pathMatcherFilter($pathMatcher);

// This sort function allow multiple headers and footers to be in nested
// directories, so the highest level header is at the start of the list,
// with the reverse logic applied to footers.
// TODO: Extract into own function. Should this be maintained within PHP.Gt/Routing ?
		$headerFooterSort = function(string $a, string $b):int {
			$fileNameA = pathinfo($a, PATHINFO_FILENAME);
			$fileNameB = pathinfo($b, PATHINFO_FILENAME);

			if($fileNameA === "_header") {
				if($fileNameB === "_header") {
					$aDepth = substr_count($a, "/");
					$bDepth = substr_count($b, "/");
					if($aDepth > $bDepth) {
						return 1;
					}
					elseif($aDepth < $bDepth) {
						return -1;
					}
					else {
						return 0;
					}
				}


				return -1;
			}

			if($fileNameA === "_footer") {
				if($fileNameB === "_footer") {
					$aDepth = substr_count($a, "/");
					$bDepth = substr_count($b, "/");
					if($aDepth < $bDepth) {
						return 1;
					}
					elseif($aDepth > $bDepth) {
						return -1;
					}
					else {
						return 0;
					}
				}

				return 1;
			}

			if($fileNameB === "_header") {
				return 1;
			}

			if($fileNameB === "_footer") {
				return -1;
			}

			return 0;
		};

		$sortNestLevelCallback = fn(string $a, string $b) =>
		substr_count($a, "/") > substr_count($b, "/")
			? 1
			: (substr_count($a, "/") < substr_count($b, "/")
			? -1
			: 0);

		if($this->errorStatus) {
			$uriPath = "_error/$this->errorStatus";
		}
		else {
			$uriPath = $request->getUri()->getPath();
		}

		$matchingLogics = $pathMatcher->findForUriPath(
			$uriPath,
			"page",
			"php"
		);
		$this->assertNoAmbiguousPath($matchingLogics, $uriPath, "page", "php");
		usort($matchingLogics, $sortNestLevelCallback);
		foreach($matchingLogics as $path) {
			$this->addToLogicAssembly($path);
		}

		$matchingViews = $pathMatcher->findForUriPath(
			$uriPath,
			"page",
			"html"
		);
		$this->assertNoAmbiguousPath($matchingViews, $uriPath, "page", "html");
		usort($matchingViews, $headerFooterSort);
		foreach($matchingViews as $path) {
			$this->addToViewAssembly($path);
		}
	}

	#[Any(name: "api-route", accept: "application/xml,application/json")]
	public function api(
		Request $request
	):void {
		$pathMatcher = new PathMatcher("api");
		$this->pathMatcherFilter($pathMatcher);
		$this->setViewClass(JSONView::class);
		$sortNestLevelCallback = fn(string $a, string $b) =>
		substr_count($a, "/") > substr_count($b, "/")
			? 1
			: (substr_count($a, "/") < substr_count($b, "/")
			? -1
			: 0);

		$matchingLogics = $pathMatcher->findForUriPath(
			$request->getUri()->getPath(),
			"api",
			"php"
		);
		$this->assertNoAmbiguousPath(
			$matchingLogics,
			$request->getUri()->getPath(),
			"api",
			"php",
		);
		usort($matchingLogics, $sortNestLevelCallback);
		foreach($matchingLogics as $path) {
			$this->addToLogicAssembly($path);
		}

		$matchingViews = $pathMatcher->findForUriPath(
			$request->getUri()->getPath(),
			"api",
			"xml"
		);
		$this->assertNoAmbiguousPath(
			$matchingViews,
			$request->getUri()->getPath(),
			"api",
			"xml",
		);
		foreach($matchingViews as $path) {
			$this->addToViewAssembly($path);
		}
	}

	/** @param array<int, string> $matchingPaths */
	private function assertNoAmbiguousPath(
		array $matchingPaths,
		string $uriPath,
		string $baseDir,
		string $extension,
	):void {
		$trimmedUriPath = trim($uriPath, "/");
		if($trimmedUriPath === "") {
			return;
		}

		$directPath = "$baseDir/$trimmedUriPath.$extension";
		$indexPath = "$baseDir/$trimmedUriPath/index.$extension";

		if(in_array($directPath, $matchingPaths, true)
		&& in_array($indexPath, $matchingPaths, true)) {
			throw new AmbiguousPathException(
				"Ambiguous route for '$uriPath': both '$directPath' and "
				. "'$indexPath' match."
			);
		}
	}

	public function pathMatcherFilter(PathMatcher $pathMatcher):void {
		$pathMatcher->addFilter(function(string $filePath, string $uriPath, string $baseDir):bool {
			$staticUriPath = rtrim($uriPath, "/");
			foreach(glob($baseDir . $staticUriPath . ".*") as $globMatch) {
				$URI_CONTAINER = pathinfo($uriPath, PATHINFO_DIRNAME);
				$TRIM_THIS = $baseDir . $URI_CONTAINER;
				if(str_starts_with($globMatch, $TRIM_THIS)) {
					$trimmed = substr($filePath, strlen($TRIM_THIS));
					if(str_contains($trimmed, "@")) {
						return false;
					}
				}
			}

// There are three types of matching files: Basic, Magic and Dynamic.
// Basic is where a URI matches directly to a file on disk.
// Magic is where a URI matches a PHP.Gt-specific file, like _common or _header.
// Dynamic is where a URI matches a file/directory marked as dynamic with "@".
			$basicFileMatch = new BasicFileMatch($filePath, $baseDir);
			if($basicFileMatch->matches($uriPath)) {
				return true;
			}

			$magicFileMatch = new MagicFileMatch($filePath, $baseDir);
			if($magicFileMatch->matches($uriPath)) {
				return true;
			}

			return false;
		});
	}
}