class AbstractNode

abstract class AbstractNode implements Countable {
    private readonly string $name;
    private string $pathAsString;
    private array $pathAsArray;
    private readonly ?AbstractNode $parent;
    private string $id;
    public function __construct(string $name, ?self $parent = null) {
        if (str_ends_with($name, DIRECTORY_SEPARATOR)) {
            $name = substr($name, 0, -1);
        }
        $this->name = $name;
        $this->parent = $parent;
        $this->processId();
        $this->processPath();
    }
    public function name() : string {
        return $this->name;
    }
    public function id() : string {
        return $this->id;
    }
    public function pathAsString() : string {
        return $this->pathAsString;
    }
    public function pathAsArray() : array {
        return $this->pathAsArray;
    }
    public function parent() : ?self {
        return $this->parent;
    }
    public function percentageOfTestedClasses() : Percentage {
        return Percentage::fromFractionAndTotal($this->numberOfTestedClasses(), $this->numberOfClasses());
    }
    public function percentageOfTestedTraits() : Percentage {
        return Percentage::fromFractionAndTotal($this->numberOfTestedTraits(), $this->numberOfTraits());
    }
    public function percentageOfTestedClassesAndTraits() : Percentage {
        return Percentage::fromFractionAndTotal($this->numberOfTestedClassesAndTraits(), $this->numberOfClassesAndTraits());
    }
    public function percentageOfTestedFunctions() : Percentage {
        return Percentage::fromFractionAndTotal($this->numberOfTestedFunctions(), $this->numberOfFunctions());
    }
    public function percentageOfTestedMethods() : Percentage {
        return Percentage::fromFractionAndTotal($this->numberOfTestedMethods(), $this->numberOfMethods());
    }
    public function percentageOfTestedFunctionsAndMethods() : Percentage {
        return Percentage::fromFractionAndTotal($this->numberOfTestedFunctionsAndMethods(), $this->numberOfFunctionsAndMethods());
    }
    public function percentageOfExecutedLines() : Percentage {
        return Percentage::fromFractionAndTotal($this->numberOfExecutedLines(), $this->numberOfExecutableLines());
    }
    public function percentageOfExecutedBranches() : Percentage {
        return Percentage::fromFractionAndTotal($this->numberOfExecutedBranches(), $this->numberOfExecutableBranches());
    }
    public function percentageOfExecutedPaths() : Percentage {
        return Percentage::fromFractionAndTotal($this->numberOfExecutedPaths(), $this->numberOfExecutablePaths());
    }
    public function numberOfClassesAndTraits() : int {
        return $this->numberOfClasses() + $this->numberOfTraits();
    }
    public function numberOfTestedClassesAndTraits() : int {
        return $this->numberOfTestedClasses() + $this->numberOfTestedTraits();
    }
    public function classesAndTraits() : array {
        return array_merge($this->classes(), $this->traits());
    }
    public function numberOfFunctionsAndMethods() : int {
        return $this->numberOfFunctions() + $this->numberOfMethods();
    }
    public function numberOfTestedFunctionsAndMethods() : int {
        return $this->numberOfTestedFunctions() + $this->numberOfTestedMethods();
    }
    
    /**
     * @psalm-return array<string, ProcessedClassType>
     */
    public abstract function classes() : array;
    
    /**
     * @psalm-return array<string, ProcessedTraitType>
     */
    public abstract function traits() : array;
    
    /**
     * @psalm-return array<string, ProcessedFunctionType>
     */
    public abstract function functions() : array;
    
    /**
     * @psalm-return LinesOfCodeType
     */
    public abstract function linesOfCode() : array;
    public abstract function numberOfExecutableLines() : int;
    public abstract function numberOfExecutedLines() : int;
    public abstract function numberOfExecutableBranches() : int;
    public abstract function numberOfExecutedBranches() : int;
    public abstract function numberOfExecutablePaths() : int;
    public abstract function numberOfExecutedPaths() : int;
    public abstract function numberOfClasses() : int;
    public abstract function numberOfTestedClasses() : int;
    public abstract function numberOfTraits() : int;
    public abstract function numberOfTestedTraits() : int;
    public abstract function numberOfMethods() : int;
    public abstract function numberOfTestedMethods() : int;
    public abstract function numberOfFunctions() : int;
    public abstract function numberOfTestedFunctions() : int;
    private function processId() : void {
        if ($this->parent === null) {
            $this->id = 'index';
            return;
        }
        $parentId = $this->parent
            ->id();
        if ($parentId === 'index') {
            $this->id = str_replace(':', '_', $this->name);
        }
        else {
            $this->id = $parentId . '/' . $this->name;
        }
    }
    private function processPath() : void {
        if ($this->parent === null) {
            $this->pathAsArray = [
                $this,
            ];
            $this->pathAsString = $this->name;
            return;
        }
        $this->pathAsArray = $this->parent
            ->pathAsArray();
        $this->pathAsString = $this->parent
            ->pathAsString() . DIRECTORY_SEPARATOR . $this->name;
        $this->pathAsArray[] = $this;
    }

}