param(
    [Parameter(Mandatory = $true)]
    [string[]]$RootPath,

    [Parameter(Mandatory = $true)]
    [string]$OutputHtml,

    [string]$BubbleStopwordsFile,

    [string[]]$ExcludeDirectories = @(
        ".git",
        "node_modules",
        "bin",
        "obj"
    ),

    [switch]$OpenAfterCreate
)

Set-StrictMode -Version Latest
$ErrorActionPreference = "Stop"

function Encode-HtmlDisplay {
    param([string]$Text)

    if ($null -eq $Text) { return "" }

    $encoded = $Text
    $encoded = $encoded.Replace("&", "&")
    $encoded = $encoded.Replace("<", "&lt;")
    $encoded = $encoded.Replace(">", "&gt;")
    $encoded = $encoded.Replace('"', "&quot;")

    return $encoded
}

function Convert-ToBase64Json {
    param(
        [Parameter(Mandatory = $true)]
        [object]$Value
    )

    $json = $Value | ConvertTo-Json -Compress -Depth 100
    $bytes = [System.Text.Encoding]::UTF8.GetBytes($json)
    return [System.Convert]::ToBase64String($bytes)
}

function Normalize-RootPaths {
    param([string[]]$InputPaths)

    $normalized = New-Object System.Collections.Generic.List[string]

    foreach ($rp in $InputPaths) {
        if ([string]::IsNullOrWhiteSpace($rp)) {
            continue
        }

        $parts = @($rp)

        if ($rp -match ',') {
            $parts = $rp -split '\s*,\s*'
        }

        foreach ($part in $parts) {
            if ([string]::IsNullOrWhiteSpace($part)) {
                continue
            }

            $clean = $part.Trim()
            $clean = $clean.Trim('"', "'")

            if ($clean.StartsWith('@(')) {
                $clean = $clean.Substring(2)
            }

            if ($clean.StartsWith('(')) {
                $clean = $clean.Substring(1)
            }

            if ($clean.EndsWith(')')) {
                $clean = $clean.Substring(0, $clean.Length - 1)
            }

            $clean = $clean.Trim().Trim(',')

            if (-not [string]::IsNullOrWhiteSpace($clean)) {
                $normalized.Add($clean)
            }
        }
    }

    return @($normalized)
}

function Get-NormalizedPathForLogic {
    param([string]$Path)

    if ([string]::IsNullOrWhiteSpace($Path)) {
        return ""
    }

    if ($Path.StartsWith("\\")) {
        return $Path.TrimEnd('\')
    }

    return [System.IO.Path]::GetFullPath($Path).TrimEnd('\')
}

function Get-RelativePathSafe {
    param(
        [string]$BasePath,
        [string]$TargetPath
    )

    $baseFull = Get-NormalizedPathForLogic -Path $BasePath
    $targetFull = Get-NormalizedPathForLogic -Path $TargetPath

    if ([string]::IsNullOrWhiteSpace($baseFull) -or [string]::IsNullOrWhiteSpace($targetFull)) {
        return ""
    }

    if ($baseFull -ieq $targetFull) {
        return "."
    }

    if ($baseFull.StartsWith("\\") -and $targetFull.StartsWith("\\")) {
        $baseTrim = $baseFull.TrimStart('\')
        $targetTrim = $targetFull.TrimStart('\')

        $baseParts = $baseTrim -split '\\'
        $targetParts = $targetTrim -split '\\'

        $maxCommon = [Math]::Min($baseParts.Count, $targetParts.Count)
        $commonCount = 0

        for ($i = 0; $i -lt $maxCommon; $i++) {
            if ($baseParts[$i] -ieq $targetParts[$i]) {
                $commonCount++
            }
            else {
                break
            }
        }

        if ($commonCount -eq $baseParts.Count) {
            if ($commonCount -ge $targetParts.Count) {
                return "."
            }

            $restParts = @()
            for ($j = $commonCount; $j -lt $targetParts.Count; $j++) {
                $restParts += $targetParts[$j]
            }

            if ($restParts.Count -eq 0) {
                return "."
            }

            return ($restParts -join '\')
        }

        return $targetFull
    }

    $baseWithSlash = $baseFull
    if (-not $baseWithSlash.EndsWith([System.IO.Path]::DirectorySeparatorChar)) {
        $baseWithSlash += [System.IO.Path]::DirectorySeparatorChar
    }

    $baseUri = [System.Uri]::new($baseWithSlash)
    $targetUri = [System.Uri]::new($targetFull)
    $relativeUri = $baseUri.MakeRelativeUri($targetUri)
    $relativePath = [System.Uri]::UnescapeDataString($relativeUri.ToString())

    return $relativePath -replace '/', '\'
}

function Convert-ToFileUri {
    param([string]$Path)

    if ([string]::IsNullOrWhiteSpace($Path)) {
        return ""
    }

    if ($Path.StartsWith("\\")) {
        $trimmed = $Path.TrimStart('\')
        $parts = $trimmed -split '\\'

        if ($parts.Count -ge 2) {
            $server = $parts[0]
            $segments = New-Object System.Collections.Generic.List[string]

            for ($i = 1; $i -lt $parts.Count; $i++) {
                $segments.Add([System.Uri]::EscapeDataString($parts[$i]))
            }

            return "file://$server/" + ($segments -join '/')
        }

        return ""
    }

    $full = [System.IO.Path]::GetFullPath($Path)

    if ($full -match '^[A-Za-z]:\\') {
        $normalized = $full -replace '\\', '/'

        if ($normalized -match '^([A-Za-z]):/(.*)$') {
            $drive = $matches[1]
            $rest = $matches[2]

            $segments = New-Object System.Collections.Generic.List[string]
            foreach ($segment in ($rest -split '/')) {
                if ($segment -ne "") {
                    $segments.Add([System.Uri]::EscapeDataString($segment))
                }
            }

            return "file:///$drive`:/" + ($segments -join '/')
        }
    }

    if ($full.StartsWith("/")) {
        $segments = New-Object System.Collections.Generic.List[string]
        foreach ($segment in ($full -split '/')) {
            if ($segment -ne "") {
                $segments.Add([System.Uri]::EscapeDataString($segment))
            }
        }

        return "file:///" + ($segments -join '/')
    }

    return [System.Uri]::new($full).AbsoluteUri
}

function Get-PathTerms {
    param(
        [string]$RelativePath,
        [string]$FolderName
    )

    $terms = New-Object System.Collections.Generic.List[string]

    if (-not [string]::IsNullOrWhiteSpace($RelativePath) -and $RelativePath -ne ".") {
        $parts = $RelativePath -split '[\\/\s_\-\.]+'
        foreach ($part in $parts) {
            if (-not [string]::IsNullOrWhiteSpace($part)) {
                $terms.Add($part.ToLowerInvariant())
            }
        }
    }

    if (-not [string]::IsNullOrWhiteSpace($FolderName)) {
        $nameParts = $FolderName -split '[\\/\s_\-\.]+'
        foreach ($part in $nameParts) {
            if (-not [string]::IsNullOrWhiteSpace($part)) {
                $terms.Add($part.ToLowerInvariant())
            }
        }
    }

    return ($terms | Select-Object -Unique)
}

function Get-AllSearchTokens {
    param(
        [string]$RelativePath,
        [string]$FullPath,
        [string]$FolderName
    )

    $all = New-Object System.Collections.Generic.List[string]

    foreach ($source in @($RelativePath, $FullPath, $FolderName)) {
        if (-not [string]::IsNullOrWhiteSpace($source)) {
            $parts = $source -split '[\\/\s_\-\.]+'
            foreach ($part in $parts) {
                if (-not [string]::IsNullOrWhiteSpace($part)) {
                    $all.Add($part.ToLowerInvariant())
                }
            }
        }
    }

    return ($all | Select-Object -Unique)
}

function Test-IsExcludedDirectory {
    param(
        [System.IO.DirectoryInfo]$Directory,
        [string[]]$ExcludedNames
    )

    return $ExcludedNames -contains $Directory.Name
}

function Get-BubbleStopwords {
    param(
        [string]$StopwordsFile
    )

    $candidates = New-Object System.Collections.Generic.List[string]

    if (-not [string]::IsNullOrWhiteSpace($StopwordsFile)) {
        $candidates.Add($StopwordsFile)
    }

    if (-not [string]::IsNullOrWhiteSpace($PSCommandPath)) {
        $scriptDir = Split-Path -Path $PSCommandPath -Parent
        $scriptBase = [System.IO.Path]::GetFileNameWithoutExtension($PSCommandPath)
        $candidates.Add((Join-Path $scriptDir "$scriptBase.bubbles.conf.txt"))
    }

    foreach ($candidate in $candidates) {
        if (-not [string]::IsNullOrWhiteSpace($candidate) -and (Test-Path -LiteralPath $candidate)) {
            $words = Get-Content -LiteralPath $candidate -ErrorAction Stop |
                ForEach-Object { $_.Trim() } |
                Where-Object { $_ -and -not $_.StartsWith('#') } |
                ForEach-Object { $_.ToLowerInvariant() } |
                Select-Object -Unique

            Write-Host "Verwendete Bubble-Stopwortdatei: $candidate"
            return @($words)
        }
    }

    Write-Host "Keine Bubble-Stopwortdatei gefunden."
    return @()
}

function Get-DirectoryTree {
    param(
        [System.IO.DirectoryInfo]$Directory,
        [string]$BasePath,
        [string[]]$ExcludedDirNames
    )

    $relativePath = Get-RelativePathSafe -BasePath $BasePath -TargetPath $Directory.FullName
    if ([string]::IsNullOrWhiteSpace($relativePath)) {
        $relativePath = "."
    }

    $terms = Get-PathTerms -RelativePath $relativePath -FolderName $Directory.Name
    $linkUri = Convert-ToFileUri -Path $Directory.FullName

    $children = New-Object System.Collections.Generic.List[object]

    $subDirs = Get-ChildItem -LiteralPath $Directory.FullName -Directory -Force -ErrorAction SilentlyContinue |
        Where-Object { -not (Test-IsExcludedDirectory -Directory $_ -ExcludedNames $ExcludedDirNames) } |
        Sort-Object Name

    foreach ($subDir in $subDirs) {
        $children.Add((Get-DirectoryTree -Directory $subDir -BasePath $BasePath -ExcludedDirNames $ExcludedDirNames))
    }

    return [PSCustomObject]@{
        Name                 = $Directory.Name
        FullPath             = $Directory.FullName
        RelativePath         = $relativePath
        TermsArray           = @($terms)
        SearchTokens         = @(Get-AllSearchTokens -RelativePath $relativePath -FullPath $Directory.FullName -FolderName $Directory.Name)
        LinkUri              = $linkUri
        LastWriteTime        = $Directory.LastWriteTime.ToString("yyyy-MM-dd HH:mm:ss")
        LastWriteDate        = $Directory.LastWriteTime.ToString("yyyy-MM-dd")
        LastWriteDateDisplay = $Directory.LastWriteTime.ToString("dd.MM.yyyy")
        Children             = $children
    }
}

$RootPath = Normalize-RootPaths -InputPaths $RootPath
$BubbleStopwords = Get-BubbleStopwords -StopwordsFile $BubbleStopwordsFile

Write-Host "Verwendete RootPaths:"
$RootPath | ForEach-Object { Write-Host " - $_" }

$rootItems = @()
foreach ($rp in $RootPath) {
    $resolved = $null
    try {
        $resolved = Get-Item -LiteralPath $rp -ErrorAction Stop
    }
    catch {
        throw "RootPath konnte nicht gelesen werden: $rp"
    }

    if (-not $resolved.PSIsContainer) {
        throw "RootPath muss ein Verzeichnis sein: $rp"
    }

    $rootItems += $resolved
}

$forest = foreach ($rootItem in $rootItems) {
    Get-DirectoryTree -Directory $rootItem -BasePath $rootItem.FullName -ExcludedDirNames $ExcludeDirectories
}

$forestB64 = Convert-ToBase64Json -Value $forest
$stopwordsB64 = Convert-ToBase64Json -Value $BubbleStopwords
$rootsDisplay = ($rootItems | ForEach-Object { $_.FullName }) -join " | "
$rootsEscaped = Encode-HtmlDisplay $rootsDisplay
$generatedAt = (Get-Date).ToString("yyyy-MM-dd HH:mm:ss")

$html = @'
<!DOCTYPE html>
<html lang="de">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Ordnerbaum</title>
<style>
body {
    font-family: Arial, sans-serif;
    margin: 0;
    background: #f4f6f8;
    color: #222;
}
header {
    background: #1f3b5b;
    color: white;
    padding: 18px 24px;
}
header h1 {
    margin: 0 0 8px 0;
    font-size: 24px;
}
header .sub {
    font-size: 14px;
    opacity: 0.96;
    line-height: 1.4;
}
main {
    padding: 20px;
}
.panel {
    background: white;
    border-radius: 10px;
    padding: 16px;
    margin-bottom: 16px;
    box-shadow: 0 2px 8px rgba(0,0,0,0.08);
}
.filters-grid {
    display: grid;
    grid-template-columns: minmax(260px, 2fr) minmax(220px, 1fr) minmax(160px, 1fr) minmax(160px, 1fr);
    gap: 12px;
    align-items: end;
}
label {
    font-weight: bold;
    display: block;
    margin-bottom: 6px;
}
input[type="text"], input[type="date"], select {
    width: 100%;
    padding: 10px 12px;
    font-size: 14px;
    border: 1px solid #b8c2cc;
    border-radius: 6px;
    box-sizing: border-box;
    background: white;
}
.helper {
    margin-top: 8px;
    color: #555;
    font-size: 13px;
    line-height: 1.45;
}
.stats {
    margin-top: 10px;
    font-size: 13px;
    color: #333;
}
.options-panel {
    margin-top: 10px;
    padding: 12px;
    background: #f8fafc;
    border: 1px solid #d9e2ec;
    border-radius: 8px;
}
.options-panel.hidden {
    display: none;
}
.option-list {
    display: flex;
    flex-wrap: wrap;
    gap: 16px;
}
.option-list label {
    font-weight: normal;
    margin-bottom: 0;
}
.bubble-filter-box {
    margin-top: 12px;
    padding-top: 10px;
    border-top: 1px solid #d9e2ec;
}
.bubble-filter-box.hidden {
    display: none;
}
.dual-range-box {
    margin-top: 10px;
}
.dual-range-scale {
    display: flex;
    justify-content: space-between;
    font-size: 12px;
    color: #666;
    margin-bottom: 6px;
}
.dual-range-current {
    display: flex;
    justify-content: space-between;
    font-size: 12px;
    color: #444;
    margin-top: 8px;
}
.dual-range-wrap {
    position: relative;
    height: 34px;
}
.dual-range-track {
    position: absolute;
    top: 14px;
    left: 0;
    right: 0;
    height: 6px;
    border-radius: 999px;
    background: #d9e2ec;
}
.dual-range-fill {
    position: absolute;
    top: 14px;
    height: 6px;
    border-radius: 999px;
    background: #5b8fd1;
}
.dual-range-wrap input[type="range"] {
    position: absolute;
    left: 0;
    top: 6px;
    width: 100%;
    margin: 0;
    background: transparent;
    pointer-events: none;
    -webkit-appearance: none;
    appearance: none;
}
.dual-range-wrap input[type="range"]::-webkit-slider-thumb {
    pointer-events: auto;
    -webkit-appearance: none;
    appearance: none;
    width: 18px;
    height: 18px;
    border-radius: 50%;
    background: #1f4f8a;
    border: 2px solid white;
    box-shadow: 0 1px 4px rgba(0,0,0,0.2);
    cursor: pointer;
}
.dual-range-wrap input[type="range"]::-moz-range-thumb {
    pointer-events: auto;
    width: 18px;
    height: 18px;
    border-radius: 50%;
    background: #1f4f8a;
    border: 2px solid white;
    box-shadow: 0 1px 4px rgba(0,0,0,0.2);
    cursor: pointer;
}
.dual-range-wrap input[type="range"]::-webkit-slider-runnable-track {
    height: 6px;
    background: transparent;
}
.dual-range-wrap input[type="range"]::-moz-range-track {
    height: 6px;
    background: transparent;
}
.tree-root {
    list-style: none;
    padding-left: 0;
    margin: 0;
}
.tree-list {
    list-style: none;
    padding-left: 20px;
    margin: 0;
}
.tree-node {
    margin: 4px 0;
}
summary {
    cursor: pointer;
    padding: 3px 0;
}
.folder-link {
    text-decoration: none;
    font-weight: bold;
    color: #1f4f8a;
}
.folder-link:hover {
    text-decoration: underline;
}
.meta-inline {
    color: #8a8f98;
    font-size: 12px;
    margin-left: 8px;
}
.node-meta {
    margin: 4px 0 8px 20px;
    font-size: 12.5px;
    color: #444;
    line-height: 1.45;
}
button {
    background: #1f3b5b;
    color: white;
    border: 0;
    border-radius: 6px;
    padding: 8px 12px;
    margin-right: 8px;
    margin-bottom: 6px;
    cursor: pointer;
}
button:hover {
    background: #16314d;
}
.toolbar {
    margin-top: 12px;
}
mark.hit {
    background: #ffeb3b;
    color: #000;
    padding: 0 2px;
    border-radius: 2px;
    font-weight: bold;
}
.path-text, .terms-text {
    word-break: break-word;
}
.result-list {
    margin-top: 10px;
    padding-left: 18px;
}
.result-list li {
    margin: 4px 0;
}
.result-list a {
    color: #1f4f8a;
    text-decoration: none;
}
.result-list a:hover {
    text-decoration: underline;
}
.result-hidden {
    display: none;
}
.bubble-panel {
    margin-top: 12px;
}
.bubble-wrap {
    display: flex;
    flex-wrap: wrap;
    gap: 12px;
    align-items: center;
}
.term-bubble {
    border: none;
    border-radius: 999px;
    cursor: pointer;
    background: #d9e8ff;
    color: #12365a;
    padding: 10px 16px;
    font-weight: bold;
    line-height: 1;
    display: inline-flex;
    align-items: center;
    justify-content: center;
    transition: transform 0.12s ease, box-shadow 0.12s ease, background 0.12s ease;
    box-shadow: 0 1px 4px rgba(0,0,0,0.12);
}
.term-bubble:hover {
    background: #bcd7ff;
    transform: scale(1.04);
}
.term-bubble small {
    display: block;
    font-size: 11px;
    font-weight: normal;
    margin-top: 4px;
}
.term-bubble.active {
    background: #1f4f8a;
    color: white;
    box-shadow: 0 2px 8px rgba(0,0,0,0.18);
}
.term-bubble.active:hover {
    background: #173d69;
}
.section-title {
    font-weight: bold;
    margin-top: 12px;
    margin-bottom: 6px;
}
.muted {
    color: #8a8f98;
    font-size: 12px;
}
@media (max-width: 1100px) {
    .filters-grid {
        grid-template-columns: 1fr 1fr;
    }
}
</style>
</head>
<body>
<header>
    <h1>Ordnerbaum</h1>
    <div class="sub"><strong>Wurzeln:</strong> __ROOTS__</div>
    <div class="sub"><strong>Generiert am:</strong> __GENERATED__</div>
</header>

<main>
    <section class="panel">
        <div class="filters-grid">
            <div>
                <label for="searchBox">Pfadfilter</label>
                <input type="text" id="searchBox" placeholder="z. B. befugnis 2014 vfg">
            </div>
            <div>
                <label for="sortMode">Sortierung</label>
                <select id="sortMode">
                    <option value="name-asc">Name A-Z</option>
                    <option value="name-desc">Name Z-A</option>
                    <option value="path-asc">Pfad A-Z</option>
                    <option value="path-desc">Pfad Z-A</option>
                    <option value="date-desc">Datum neu nach alt</option>
                    <option value="date-asc">Datum alt nach neu</option>
                </select>
            </div>
            <div>
                <label for="dateFrom">von Datum</label>
                <input type="date" id="dateFrom">
            </div>
            <div>
                <label for="dateTo">bis Datum</label>
                <input type="date" id="dateTo">
            </div>
        </div>

        <div class="helper">
            Freitextsuche über ganze Suchwörter. Trefferliste zeigt alle sichtbaren Trefferknoten. Bubble-Begriffe kommen aus allen sichtbaren Knoten.
        </div>

        <div class="toolbar">
            <button type="button" id="toggleExpandBtn" title="Alle auf- und einklappen" onclick="toggleExpandCollapse()">Alle auf- und einklappen</button>
            <button type="button" onclick="clearFilters()">Filter zurücksetzen</button>
            <button type="button" onclick="toggleOptions()">Optionen anzeigen/ausblenden</button>
        </div>

        <div id="optionsPanel" class="options-panel hidden">
            <div class="option-list">
                <label><input type="checkbox" id="optShowArchivePath"> Archiv-Pfad anzeigen</label>
                <label><input type="checkbox" id="optShowTerms"> Suchbegriffe anzeigen</label>
                <label><input type="checkbox" id="optShowDate"> Letzte Änderung anzeigen</label>
                <label><input type="checkbox" id="optShowPath"> Vollen Pfad anzeigen</label>
                <label><input type="checkbox" id="optShowResults"> Trefferpfade anzeigen</label>
                <label><input type="checkbox" id="optShowBubbles"> Begriffsbubbles anzeigen</label>
            </div>

            <div id="bubbleFilterBox" class="bubble-filter-box hidden">
                <div><strong>Bubble-Häufigkeitsbereich</strong></div>
                <div class="dual-range-box">
                    <div class="dual-range-scale">
                        <span>Min gesamt: <span id="bubbleAbsMinValue">1</span></span>
                        <span>Max gesamt: <span id="bubbleAbsMaxValue">1</span></span>
                    </div>
                    <div class="dual-range-wrap">
                        <div class="dual-range-track"></div>
                        <div class="dual-range-fill" id="bubbleRangeFill"></div>
                        <input type="range" id="bubbleRangeMin" min="1" max="1" value="1">
                        <input type="range" id="bubbleRangeMax" min="1" max="1" value="1">
                    </div>
                    <div class="dual-range-current">
                        <span>Aktuell Min: <span id="bubbleRangeMinValue">1</span></span>
                        <span>Aktuell Max: <span id="bubbleRangeMaxValue">1</span></span>
                    </div>
                </div>
            </div>
        </div>

        <div class="stats" id="statsLine"></div>

        <div id="bubblePanel" class="bubble-panel result-hidden">
            <div class="section-title">Begriffsbubbles</div>
            <div class="muted">Klick auf eine Bubble fügt den Begriff hinzu oder entfernt ihn wieder.</div>
            <div id="bubbleWrap" class="bubble-wrap"></div>
        </div>

        <div id="resultsPanel" class="result-hidden">
            <div class="section-title">Trefferpfade</div>
            <div id="resultGroups"></div>
        </div>
    </section>

    <section class="panel">
        <ul class="tree-root" id="treeRoot"></ul>
    </section>
</main>

<script>
const FOREST_B64 = "__FOREST_B64__";
const BUBBLE_STOPWORDS_B64 = "__STOPWORDS_B64__";
let CURRENT_FOREST = [];
let CURRENT_SETTINGS = null;
let OPEN_STATE = {};
let FORCE_ALL_EXPANDED = false;
let BUBBLE_RANGE_INITIALIZED = false;
let BUBBLE_RANGE_STATE = { min: 1, max: 1 };

function normalizeText(value) {
    return (value || "").toLowerCase().trim();
}

function decodeStopwords() {
    try {
        const json = atob(BUBBLE_STOPWORDS_B64);
        const arr = JSON.parse(json);
        if (!Array.isArray(arr)) return [];
        return arr.map(function(x) { return normalizeText(String(x)); }).filter(Boolean);
    } catch (e) {
        return [];
    }
}

const BUBBLE_STOPWORDS = decodeStopwords();

function tokenizeSearchWords(value) {
    return normalizeText(value)
        .split(/\s+/)
        .map(function(x) { return x.trim(); })
        .filter(function(x) { return x.length > 0; });
}

function escapeHtmlJs(value) {
    return (value || "")
        .replace(/&/g, "&amp;")
        .replace(/</g, "&lt;")
        .replace(/>/g, "&gt;")
        .replace(/"/g, "&quot;");
}

function escapeRegex(value) {
    return value.replace(/[.*+?^$`{}()|[\]\\]/g, "\\$&");
}

function decodeForest() {
    const json = atob(FOREST_B64);
    return JSON.parse(json);
}

function cloneNode(node) {
    return {
        Name: node.Name,
        FullPath: node.FullPath,
        RelativePath: node.RelativePath,
        TermsArray: Array.isArray(node.TermsArray) ? node.TermsArray.slice() : [],
        SearchTokens: Array.isArray(node.SearchTokens) ? node.SearchTokens.slice() : [],
        LinkUri: node.LinkUri,
        LastWriteTime: node.LastWriteTime,
        LastWriteDate: node.LastWriteDate,
        LastWriteDateDisplay: node.LastWriteDateDisplay,
        Children: Array.isArray(node.Children) ? node.Children.map(cloneNode) : []
    };
}

function getSettings() {
    return {
        searchWords: tokenizeSearchWords(document.getElementById("searchBox").value),
        sortMode: document.getElementById("sortMode").value,
        dateFrom: document.getElementById("dateFrom").value || "",
        dateTo: document.getElementById("dateTo").value || "",
        showArchivePath: document.getElementById("optShowArchivePath").checked,
        showTerms: document.getElementById("optShowTerms").checked,
        showDate: document.getElementById("optShowDate").checked,
        showPath: document.getElementById("optShowPath").checked,
        showResults: document.getElementById("optShowResults").checked,
        showBubbles: document.getElementById("optShowBubbles").checked
    };
}

function flattenArchiveNodes(nodes) {
    const result = [];

    nodes.forEach(function(node) {
        const children = flattenArchiveNodes(node.Children || []);
        const copy = cloneNode(node);
        copy.Children = children;

        if (normalizeText(copy.Name) === "archiv") {
            result.push.apply(result, copy.Children);
        } else {
            result.push(copy);
        }
    });

    return result;
}

function assignDisplayDepth(nodes, currentDepth) {
    return nodes.map(function(node) {
        const copy = cloneNode(node);
        copy.DisplayDepth = currentDepth;
        copy._matchedSelf = node._matchedSelf;
        copy._matchedChild = node._matchedChild;
        copy.Children = assignDisplayDepth(copy.Children || [], currentDepth + 1);
        return copy;
    });
}

function sortNodes(nodes, sortMode) {
    const sorted = nodes.slice();

    sorted.sort(function(a, b) {
        const aName = normalizeText(a.Name);
        const bName = normalizeText(b.Name);
        const aPath = normalizeText(a.RelativePath || "");
        const bPath = normalizeText(b.RelativePath || "");
        const aDate = a.LastWriteDate || "";
        const bDate = b.LastWriteDate || "";

        switch (sortMode) {
            case "name-desc":
                return bName.localeCompare(aName, "de");
            case "path-asc":
                return aPath.localeCompare(bPath, "de");
            case "path-desc":
                return bPath.localeCompare(aPath, "de");
            case "date-asc":
                if (aDate !== bDate) return aDate.localeCompare(bDate, "de");
                return aName.localeCompare(bName, "de");
            case "date-desc":
                if (aDate !== bDate) return bDate.localeCompare(aDate, "de");
                return aName.localeCompare(bName, "de");
            case "name-asc":
            default:
                return aName.localeCompare(bName, "de");
        }
    });

    return sorted.map(function(node) {
        const copy = cloneNode(node);
        copy.DisplayDepth = node.DisplayDepth;
        copy._matchedSelf = node._matchedSelf;
        copy._matchedChild = node._matchedChild;
        copy.Children = sortNodes(copy.Children || [], sortMode);
        return copy;
    });
}

function matchesSearch(node, searchWords) {
    if (!searchWords.length) return true;
    if (!node.SearchTokens || !node.SearchTokens.length) return false;

    const tokenSet = node.SearchTokens.map(function(t) {
        return normalizeText(String(t));
    });

    for (let i = 0; i < searchWords.length; i++) {
        const word = searchWords[i];
        for (let j = 0; j < tokenSet.length; j++) {
            if (tokenSet[j].indexOf(word) !== -1) {
                return true;
            }
        }
    }

    return false;
}

function matchesDate(node, settings) {
    const nodeDate = node.LastWriteDate || "";
    if (!nodeDate) return true;
    if (settings.dateFrom && nodeDate < settings.dateFrom) return false;
    if (settings.dateTo && nodeDate > settings.dateTo) return false;
    return true;
}

function filterNodes(nodes, settings) {
    const result = [];

    nodes.forEach(function(node) {
        const filteredChildren = filterNodes(node.Children || [], settings);
        const ownMatch = matchesSearch(node, settings.searchWords) && matchesDate(node, settings);

        if (ownMatch || filteredChildren.length > 0) {
            const copy = cloneNode(node);
            copy.Children = filteredChildren;
            copy._matchedSelf = ownMatch;
            copy._matchedChild = filteredChildren.length > 0;
            result.push(copy);
        }
    });

    return result;
}

function buildWorkingForest() {
    const settings = getSettings();
    let forest = decodeForest().map(cloneNode);

    if (!settings.showArchivePath) {
        forest = flattenArchiveNodes(forest);
    }

    forest = assignDisplayDepth(forest, 0);
    forest = sortNodes(forest, settings.sortMode);
    forest = filterNodes(forest, settings);
    forest = assignDisplayDepth(forest, 0);

    return forest;
}

function highlightText(text, searchWords) {
    let html = escapeHtmlJs(text || "");
    if (!searchWords.length) return html;

    searchWords.forEach(function(word) {
        if (!word) return;
        const rx = new RegExp(escapeRegex(word), "ig");
        html = html.replace(rx, function(match) {
            return '<mark class="hit">' + match + '</mark>';
        });
    });

    return html;
}

function createMetaRow(label, valueHtml, cssClass) {
    const div = document.createElement("div");
    div.className = "meta-row " + cssClass;
    div.innerHTML = "<strong>" + label + ":</strong> " + valueHtml;
    return div;
}

function getNodeKey(node) {
    return node.FullPath || node.RelativePath || node.Name;
}

function snapshotOpenState() {
    const next = {};
    document.querySelectorAll("#treeRoot details[data-node-key]").forEach(function(d) {
        next[d.getAttribute("data-node-key")] = d.open;
    });
    OPEN_STATE = next;
}

function renderNodes(nodes, parentUl, settings, filterActive) {
    nodes.forEach(function(node) {
        const li = document.createElement("li");
        li.className = "tree-node";

        const details = document.createElement("details");
        const key = getNodeKey(node);
        details.setAttribute("data-node-key", key);

        const hasSaved = Object.prototype.hasOwnProperty.call(OPEN_STATE, key);
        const shouldOpen =
            FORCE_ALL_EXPANDED ? true :
            hasSaved ? !!OPEN_STATE[key] :
            !!(node.DisplayDepth === 0 || (filterActive && node.Children && node.Children.length > 0));

        details.open = shouldOpen;

        details.addEventListener("toggle", function() {
            OPEN_STATE[key] = details.open;
        });

        const summary = document.createElement("summary");

        const link = document.createElement("a");
        link.className = "folder-link folder-name";
        link.href = node.LinkUri || "#";
        link.innerHTML = highlightText(node.Name, settings.searchWords);

        const meta = document.createElement("span");
        meta.className = "meta-inline";
        meta.textContent = "[" + (node.LastWriteDateDisplay || "") + "]";

        summary.appendChild(link);
        summary.appendChild(meta);
        details.appendChild(summary);

        const metaBox = document.createElement("div");
        metaBox.className = "node-meta";

        if (settings.showPath) {
            metaBox.appendChild(
                createMetaRow(
                    "Voller Pfad",
                    '<span class="path-text">' + highlightText(node.FullPath, settings.searchWords) + '</span>',
                    "meta-path"
                )
            );
        }

        if (settings.showDate) {
            metaBox.appendChild(
                createMetaRow("Letzte Änderung", escapeHtmlJs(node.LastWriteTime), "meta-date")
            );
        }

        if (settings.showTerms) {
            metaBox.appendChild(
                createMetaRow(
                    "Suchbegriffe",
                    '<span class="terms-text">' + highlightText((node.TermsArray || []).join(" "), settings.searchWords) + '</span>',
                    "meta-terms"
                )
            );
        }

        if (metaBox.children.length > 0) {
            details.appendChild(metaBox);
        }

        if (node.Children && node.Children.length > 0) {
            const childUl = document.createElement("ul");
            childUl.className = "tree-list";
            renderNodes(node.Children, childUl, settings, filterActive);
            details.appendChild(childUl);
        }

        li.appendChild(details);
        parentUl.appendChild(li);
    });
}

function flattenVisibleNodes(nodes, bucket) {
    nodes.forEach(function(node) {
        bucket.push(node);
        flattenVisibleNodes(node.Children || [], bucket);
    });
}

function countAllNodes(nodes) {
    let count = 0;
    nodes.forEach(function(node) {
        count += 1;
        count += countAllNodes(node.Children || []);
    });
    return count;
}

function countVisibleNodes(nodes) {
    const flat = [];
    flattenVisibleNodes(nodes, flat);
    return flat.length;
}

function updateStats(visibleForest) {
    const settings = getSettings();
    let totalForest = decodeForest().map(cloneNode);

    if (!settings.showArchivePath) {
        totalForest = flattenArchiveNodes(totalForest);
    }

    totalForest = assignDisplayDepth(totalForest, 0);
    totalForest = sortNodes(totalForest, settings.sortMode);

    const visibleCount = countVisibleNodes(visibleForest);
    const totalCount = countAllNodes(totalForest);

    document.getElementById("statsLine").textContent =
        "Treffer: " + visibleCount + " / Gesamt: " + totalCount;
}

function hasActiveFilter(settings) {
    return settings.searchWords.length > 0 || !!settings.dateFrom || !!settings.dateTo;
}

function buildResultsList(nodes, settings) {
    const panel = document.getElementById("resultsPanel");
    const host = document.getElementById("resultGroups");
    host.innerHTML = "";

    if (!settings.showResults || !hasActiveFilter(settings)) {
        panel.classList.add("result-hidden");
        return;
    }

    panel.classList.remove("result-hidden");

    const flat = [];
    flattenVisibleNodes(nodes, flat);

    if (!flat.length) {
        const empty = document.createElement("div");
        empty.className = "muted";
        empty.textContent = "Keine Treffer.";
        host.appendChild(empty);
        return;
    }

    const ul = document.createElement("ul");
    ul.className = "result-list";

    flat.forEach(function(node) {
        const li = document.createElement("li");
        const nameHtml = highlightText(node.Name, settings.searchWords);
        const fullPathTitle = escapeHtmlJs(node.FullPath || "");

        let extra = ' <span class="muted">[' + escapeHtmlJs(node.LastWriteDateDisplay || "") + ']</span>';

        if (settings.showPath) {
            const shownPath = (node.RelativePath && node.RelativePath !== ".") ? node.RelativePath : node.FullPath;
            extra += ' <span class="muted">- ' + escapeHtmlJs(shownPath) + '</span>';
        }

        li.innerHTML =
            '<a href="' + escapeHtmlJs(node.LinkUri || "#") + '" title="' + fullPathTitle + '">' + nameHtml + '</a>' +
            extra;

        ul.appendChild(li);
    });

    host.appendChild(ul);
}

function collectBubbleEntries(nodes, settings) {
    const visibleNodes = [];
    flattenVisibleNodes(nodes, visibleNodes);

    const activeMap = {};
    settings.searchWords.forEach(function(t) { activeMap[t] = true; });

    const stopMap = {};
    BUBBLE_STOPWORDS.forEach(function(t) { stopMap[t] = true; });

    const counts = {};

    visibleNodes.forEach(function(node) {
        const seen = {};
        (node.SearchTokens || []).forEach(function(term) {
            const t = normalizeText(term);
            if (t.length < 2) return;
            if (stopMap[t]) return;
            if (seen[t]) return;
            seen[t] = true;
            counts[t] = (counts[t] || 0) + 1;
        });
    });

    settings.searchWords.forEach(function(word) {
        if (word && !stopMap[word] && !counts[word]) {
            counts[word] = 0;
        }
    });

    return Object.keys(counts).map(function(key) {
        return {
            term: key,
            count: counts[key],
            active: !!activeMap[key]
        };
    });
}

function getInitialBubbleRange(entries) {
    if (!entries.length) {
        return { absMin: 1, absMax: 1, initialMin: 1, initialMax: 1 };
    }

    const countsAsc = entries
        .map(function(e) { return e.count; })
        .sort(function(a, b) { return a - b; });

    const countsDesc = entries
        .map(function(e) { return e.count; })
        .sort(function(a, b) { return b - a; });

    const absMin = countsAsc[0];
    const absMax = countsAsc[countsAsc.length - 1];
    const idx = Math.min(49, countsDesc.length - 1);
    const initialMin = countsDesc[idx];
    const initialMax = absMax;

    return {
        absMin: absMin,
        absMax: absMax,
        initialMin: initialMin,
        initialMax: initialMax
    };
}

function updateBubbleFilterVisibility(showBubbles) {
    const box = document.getElementById("bubbleFilterBox");
    box.classList.toggle("hidden", !showBubbles);
}

function updateDualRangeUI(entries) {
    const rangeMin = document.getElementById("bubbleRangeMin");
    const rangeMax = document.getElementById("bubbleRangeMax");
    const currentMinEl = document.getElementById("bubbleRangeMinValue");
    const currentMaxEl = document.getElementById("bubbleRangeMaxValue");
    const absMinEl = document.getElementById("bubbleAbsMinValue");
    const absMaxEl = document.getElementById("bubbleAbsMaxValue");
    const fillEl = document.getElementById("bubbleRangeFill");

    const init = getInitialBubbleRange(entries);

    absMinEl.textContent = String(init.absMin);
    absMaxEl.textContent = String(init.absMax);

    rangeMin.min = String(init.absMin);
    rangeMin.max = String(init.absMax);
    rangeMax.min = String(init.absMin);
    rangeMax.max = String(init.absMax);

    if (!BUBBLE_RANGE_INITIALIZED) {
        BUBBLE_RANGE_STATE.min = init.initialMin;
        BUBBLE_RANGE_STATE.max = init.initialMax;
        BUBBLE_RANGE_INITIALIZED = true;
    }

    if (BUBBLE_RANGE_STATE.min < init.absMin) {
        BUBBLE_RANGE_STATE.min = init.absMin;
    }
    if (BUBBLE_RANGE_STATE.max < init.absMin) {
        BUBBLE_RANGE_STATE.max = init.absMin;
    }
    if (BUBBLE_RANGE_STATE.min > init.absMax) {
        BUBBLE_RANGE_STATE.min = init.absMax;
    }
    if (BUBBLE_RANGE_STATE.max > init.absMax) {
        BUBBLE_RANGE_STATE.max = init.absMax;
    }
    if (BUBBLE_RANGE_STATE.min > BUBBLE_RANGE_STATE.max) {
        BUBBLE_RANGE_STATE.min = BUBBLE_RANGE_STATE.max;
    }

    rangeMin.value = String(BUBBLE_RANGE_STATE.min);
    rangeMax.value = String(BUBBLE_RANGE_STATE.max);

    currentMinEl.textContent = String(BUBBLE_RANGE_STATE.min);
    currentMaxEl.textContent = String(BUBBLE_RANGE_STATE.max);

    const absSpan = Math.max(1, init.absMax - init.absMin);
    const leftPct = ((BUBBLE_RANGE_STATE.min - init.absMin) / absSpan) * 100;
    const rightPct = ((BUBBLE_RANGE_STATE.max - init.absMin) / absSpan) * 100;

    fillEl.style.left = leftPct + "%";
    fillEl.style.width = Math.max(0, rightPct - leftPct) + "%";

    return { min: BUBBLE_RANGE_STATE.min, max: BUBBLE_RANGE_STATE.max, globalMax: init.absMax };
}

function buildBubbles(nodes, settings) {
    const panel = document.getElementById("bubblePanel");
    const wrap = document.getElementById("bubbleWrap");
    wrap.innerHTML = "";

    updateBubbleFilterVisibility(settings.showBubbles);

    const allEntries = collectBubbleEntries(nodes, settings);
    const rangeInfo = updateDualRangeUI(allEntries);

    if (!settings.showBubbles) {
        panel.classList.add("result-hidden");
        return;
    }

    panel.classList.remove("result-hidden");

    let entries = allEntries.filter(function(entry) {
        if (entry.active) return true;
        return entry.count >= rangeInfo.min && entry.count <= rangeInfo.max;
    });

    entries = entries.sort(function(a, b) {
        if (a.active !== b.active) return a.active ? -1 : 1;
        if (b.count !== a.count) return b.count - a.count;
        return a.term.localeCompare(b.term, "de");
    });

    if (!entries.length) {
        const empty = document.createElement("div");
        empty.className = "muted";
        empty.textContent = "Keine Bubble-Begriffe verfügbar.";
        wrap.appendChild(empty);
        return;
    }

    const globalMaxCount = Math.max.apply(null, allEntries.map(function(e) { return e.count; }).concat([1]));
    const minSize = 26;
    const maxSize = 92;

    entries.forEach(function(entry) {
        const normalized = globalMaxCount > 0 ? (entry.count / globalMaxCount) : 0;
        const amplified = Math.pow(normalized, 0.60);
        const size = Math.round(minSize + ((maxSize - minSize) * amplified));

        const btn = document.createElement("button");
        btn.type = "button";
        btn.className = "term-bubble" + (entry.active ? " active" : "");
        btn.style.width = size + "px";
        btn.style.height = size + "px";
        btn.style.fontSize = Math.max(11, Math.min(18, Math.round(size / 4.9))) + "px";
        btn.title = entry.term + " (" + entry.count + ")";
        btn.innerHTML = '<div><div>' + escapeHtmlJs(entry.term) + '</div><small>' + entry.count + '</small></div>';

        btn.addEventListener("click", function() {
            const searchBox = document.getElementById("searchBox");
            const existing = tokenizeSearchWords(searchBox.value);

            if (entry.active) {
                const filtered = existing.filter(function(x) { return x !== entry.term; });
                searchBox.value = filtered.join(" ");
            } else {
                if (existing.indexOf(entry.term) === -1) {
                    existing.push(entry.term);
                }
                searchBox.value = existing.join(" ");
            }

            rebuild();
        });

        wrap.appendChild(btn);
    });
}

function toggleExpandCollapse() {
    const details = Array.from(document.querySelectorAll("#treeRoot details"));
    const anyClosed = details.some(function(d) { return !d.open; });

    FORCE_ALL_EXPANDED = anyClosed;

    details.forEach(function(d) {
        d.open = anyClosed;
        const key = d.getAttribute("data-node-key");
        if (key) OPEN_STATE[key] = d.open;
    });
}

function toggleOptions() {
    document.getElementById("optionsPanel").classList.toggle("hidden");
}

function clearFilters() {
    snapshotOpenState();

    document.getElementById("searchBox").value = "";
    document.getElementById("sortMode").value = "name-asc";
    document.getElementById("dateFrom").value = "";
    document.getElementById("dateTo").value = "";

    document.getElementById("optShowArchivePath").checked = false;
    document.getElementById("optShowTerms").checked = false;
    document.getElementById("optShowDate").checked = false;
    document.getElementById("optShowPath").checked = false;
    document.getElementById("optShowResults").checked = false;
    document.getElementById("optShowBubbles").checked = false;

    BUBBLE_RANGE_INITIALIZED = false;
    BUBBLE_RANGE_STATE = { min: 1, max: 1 };
    FORCE_ALL_EXPANDED = false;
    rebuild();
}

function rebuild() {
    const settings = getSettings();
    const filterActive = hasActiveFilter(settings);

    const forest = buildWorkingForest();
    CURRENT_FOREST = forest;
    CURRENT_SETTINGS = settings;

    const treeRoot = document.getElementById("treeRoot");
    treeRoot.innerHTML = "";
    renderNodes(forest, treeRoot, settings, filterActive);

    updateStats(forest);
    buildResultsList(forest, settings);
    buildBubbles(forest, settings);
}

document.getElementById("searchBox").addEventListener("input", function() {
    snapshotOpenState();
    FORCE_ALL_EXPANDED = false;
    rebuild();
});
document.getElementById("sortMode").addEventListener("change", function() {
    snapshotOpenState();
    FORCE_ALL_EXPANDED = false;
    rebuild();
});
document.getElementById("dateFrom").addEventListener("change", function() {
    snapshotOpenState();
    FORCE_ALL_EXPANDED = false;
    rebuild();
});
document.getElementById("dateTo").addEventListener("change", function() {
    snapshotOpenState();
    FORCE_ALL_EXPANDED = false;
    rebuild();
});

document.getElementById("optShowArchivePath").addEventListener("change", function() {
    snapshotOpenState();
    FORCE_ALL_EXPANDED = false;
    rebuild();
});
document.getElementById("optShowTerms").addEventListener("change", function() {
    snapshotOpenState();
    FORCE_ALL_EXPANDED = false;
    rebuild();
});
document.getElementById("optShowDate").addEventListener("change", function() {
    snapshotOpenState();
    FORCE_ALL_EXPANDED = false;
    rebuild();
});
document.getElementById("optShowPath").addEventListener("change", function() {
    snapshotOpenState();
    FORCE_ALL_EXPANDED = false;
    rebuild();
});
document.getElementById("optShowResults").addEventListener("change", function() {
    snapshotOpenState();
    FORCE_ALL_EXPANDED = false;
    rebuild();
});
document.getElementById("optShowBubbles").addEventListener("change", function() {
    snapshotOpenState();
    FORCE_ALL_EXPANDED = false;
    rebuild();
});

document.getElementById("bubbleRangeMin").addEventListener("input", function(e) {
    const v = parseInt(e.target.value || "1", 10);
    if (v > BUBBLE_RANGE_STATE.max) {
        BUBBLE_RANGE_STATE.max = v;
    }
    BUBBLE_RANGE_STATE.min = v;
    rebuild();
});

document.getElementById("bubbleRangeMax").addEventListener("input", function(e) {
    const v = parseInt(e.target.value || "1", 10);
    if (v < BUBBLE_RANGE_STATE.min) {
        BUBBLE_RANGE_STATE.min = v;
    }
    BUBBLE_RANGE_STATE.max = v;
    rebuild();
});

rebuild();
</script>
</body>
</html>
'@

$html = $html.Replace('__ROOTS__', $rootsEscaped)
$html = $html.Replace('__GENERATED__', (Encode-HtmlDisplay $generatedAt))
$html = $html.Replace('__FOREST_B64__', $forestB64)
$html = $html.Replace('__STOPWORDS_B64__', $stopwordsB64)

$outputDir = Split-Path -Path $OutputHtml -Parent
if (-not [string]::IsNullOrWhiteSpace($outputDir) -and -not (Test-Path -LiteralPath $outputDir)) {
    New-Item -ItemType Directory -Path $outputDir -Force | Out-Null
}

$html | Out-File -LiteralPath $OutputHtml -Encoding UTF8

Write-Host "HTML-Datei erstellt: $OutputHtml"

if ($OpenAfterCreate) {
    Start-Process -FilePath $OutputHtml
}