#Requires -RunAsAdministrator
<#
.SYNOPSIS
    Setup-Script für Starface Outlook Sync Add-in.
.DESCRIPTION
    - Fragt Starface-Host (für Zertifikat) und lokalen Port ab
    - Extrahiert das SSL-Zertifikat der Starface und importiert es als vertrauenswürdig
    - Erstellt eine lokale CA und ein localhost-Zertifikat
    - Installiert den lokalen HTTPS-Webserver als Windows-Dienst
    - Registriert das Outlook Add-in
    Login-Daten werden NICHT benötigt - diese werden später im Add-in selbst
    in den Sync-Profilen konfiguriert.
#>

param(
    [string]$InstallDir = "$env:ProgramFiles\StarfaceOutlookSync"
)

$ErrorActionPreference = "Stop"
$scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path

# ============================================================
# Hilfsfunktionen
# ============================================================

function Write-Header($text) {
    Write-Host ""
    Write-Host "============================================================" -ForegroundColor Cyan
    Write-Host "  $text" -ForegroundColor Cyan
    Write-Host "============================================================" -ForegroundColor Cyan
    Write-Host ""
}

function Write-Step($text) {
    Write-Host "  → $text" -ForegroundColor Green
}

function Write-Warn($text) {
    Write-Host "  ⚠ $text" -ForegroundColor Yellow
}

function Write-Err($text) {
    Write-Host "  ✗ $text" -ForegroundColor Red
}

function Test-NodeJs {
    try {
        $version = & node --version 2>$null
        if ($version) {
            Write-Step "Node.js gefunden: $version"
            return $true
        }
    } catch {}
    return $false
}

function Test-PortAvailable($port) {
    $listener = Get-NetTCPConnection -LocalPort $port -ErrorAction SilentlyContinue
    return ($null -eq $listener)
}

function Import-StarfaceCert($host_, $port_) {
    Write-Step "Verbinde mit ${host_}:${port_} ..."

    $tcpClient = New-Object System.Net.Sockets.TcpClient
    $tcpClient.Connect($host_, $port_)
    $sslStream = New-Object System.Net.Security.SslStream(
        $tcpClient.GetStream(),
        $false,
        { $true }  # Alle Zertifikate akzeptieren für den Abruf
    )
    $sslStream.AuthenticateAsClient($host_)

    $remoteCert = $sslStream.RemoteCertificate
    $x509Cert = New-Object System.Security.Cryptography.X509Certificates.X509Certificate2($remoteCert)

    $sslStream.Close()
    $tcpClient.Close()

    Write-Step "Zertifikat erhalten: $($x509Cert.Subject)"
    Write-Step "Aussteller: $($x509Cert.Issuer)"
    Write-Step "Gültig bis: $($x509Cert.NotAfter)"

    # In den Trusted Root Store importieren
    $store = New-Object System.Security.Cryptography.X509Certificates.X509Store(
        [System.Security.Cryptography.X509Certificates.StoreName]::Root,
        [System.Security.Cryptography.X509Certificates.StoreLocation]::LocalMachine
    )
    $store.Open([System.Security.Cryptography.X509Certificates.OpenFlags]::ReadWrite)
    $store.Add($x509Cert)
    $store.Close()

    Write-Step "Starface-Zertifikat als vertrauenswürdig importiert."
    return $x509Cert
}

# ============================================================
# Voraussetzungen prüfen
# ============================================================

Write-Header "Starface Outlook Sync - Setup"

# Node.js prüfen
if (-not (Test-NodeJs)) {
    Write-Err "Node.js ist nicht installiert."
    Write-Host "  Bitte installieren Sie Node.js von https://nodejs.org/" -ForegroundColor Yellow
    Write-Host "  (LTS-Version empfohlen)" -ForegroundColor Yellow
    Read-Host "Eingabetaste zum Beenden"
    exit 1
}

# ============================================================
# Benutzereingaben
# ============================================================

Write-Header "Starface-Verbindung (nur für Zertifikat-Import)"
Write-Host "  Login-Daten werden hier nicht benötigt." -ForegroundColor Gray
Write-Host "  Diese konfigurieren Sie später im Add-in in den Sync-Profilen." -ForegroundColor Gray
Write-Host ""

$starfaceHost = Read-Host "Starface Host/IP-Adresse (z.B. 192.168.1.100 oder pbx.firma.local)"
if ([string]::IsNullOrWhiteSpace($starfaceHost)) {
    Write-Err "Kein Host angegeben."
    exit 1
}

$starfacePortInput = Read-Host "Starface HTTPS-Port [443]"
$starfacePort = if ([string]::IsNullOrWhiteSpace($starfacePortInput)) { 443 } else { [int]$starfacePortInput }

Write-Host ""
Write-Header "Lokaler Webserver"

$localPortInput = Read-Host "Lokaler HTTPS-Port für das Add-in [444]"
$localPort = if ([string]::IsNullOrWhiteSpace($localPortInput)) { 444 } else { [int]$localPortInput }

if (-not (Test-PortAvailable $localPort)) {
    Write-Warn "Port $localPort ist bereits belegt!"
    $localPortInput = Read-Host "Bitte einen anderen Port wählen"
    $localPort = [int]$localPortInput
    if (-not (Test-PortAvailable $localPort)) {
        Write-Err "Port $localPort ist ebenfalls belegt. Abbruch."
        exit 1
    }
}
Write-Step "Verwende Port: $localPort"

# ============================================================
# Schritt 1: Starface SSL-Zertifikat extrahieren und importieren
# ============================================================

Write-Header "Schritt 1: Starface-Zertifikat importieren"

try {
    Import-StarfaceCert $starfaceHost $starfacePort
} catch {
    Write-Err "Fehler beim Abrufen des Starface-Zertifikats: $_"
    Write-Warn "Die Verbindung zur Starface API könnte fehlschlagen."
    Write-Warn "Sie können das Zertifikat später nachholen mit:"
    Write-Host "    .\import-cert.ps1 -Host $starfaceHost -Port $starfacePort" -ForegroundColor White
    Write-Host ""
    Write-Host "  Möchten Sie trotzdem fortfahren? (j/n)" -ForegroundColor Yellow
    $continue = Read-Host
    if ($continue -ne "j") { exit 1 }
}

# ============================================================
# Schritt 2: Lokale CA und localhost-Zertifikat erstellen
# ============================================================

Write-Header "Schritt 2: Lokale Zertifikate erstellen"

$certDir = Join-Path $InstallDir "certs"
New-Item -ItemType Directory -Path $certDir -Force | Out-Null

# Lokale CA erstellen
Write-Step "Erstelle lokale CA ..."

$caParams = @{
    Subject           = "CN=Starface Outlook Sync Local CA"
    KeyLength         = 2048
    KeyAlgorithm      = "RSA"
    HashAlgorithm     = "SHA256"
    KeyExportPolicy   = "Exportable"
    NotAfter          = (Get-Date).AddYears(10)
    CertStoreLocation = "Cert:\LocalMachine\My"
    KeyUsage          = "CertSign", "CRLSign"
    TextExtension     = @("2.5.29.19={text}CA=true&pathlength=1")
}

$caCert = New-SelfSignedCertificate @caParams
Write-Step "Lokale CA erstellt: $($caCert.Thumbprint)"

# CA in Trusted Root Store importieren
$rootStore = New-Object System.Security.Cryptography.X509Certificates.X509Store(
    [System.Security.Cryptography.X509Certificates.StoreName]::Root,
    [System.Security.Cryptography.X509Certificates.StoreLocation]::LocalMachine
)
$rootStore.Open([System.Security.Cryptography.X509Certificates.OpenFlags]::ReadWrite)
$rootStore.Add($caCert)
$rootStore.Close()
Write-Step "Lokale CA als vertrauenswürdig importiert."

# Localhost-Zertifikat erstellen, signiert von der lokalen CA
Write-Step "Erstelle localhost-Zertifikat ..."

$localhostParams = @{
    Subject           = "CN=localhost"
    KeyLength         = 2048
    KeyAlgorithm      = "RSA"
    HashAlgorithm     = "SHA256"
    KeyExportPolicy   = "Exportable"
    NotAfter          = (Get-Date).AddYears(5)
    CertStoreLocation = "Cert:\LocalMachine\My"
    Signer            = $caCert
    DnsName           = "localhost", "127.0.0.1"
    TextExtension     = @("2.5.29.37={text}1.3.6.1.5.5.7.3.1")  # Server Authentication
}

$localhostCert = New-SelfSignedCertificate @localhostParams
Write-Step "Localhost-Zertifikat erstellt: $($localhostCert.Thumbprint)"

# Zertifikat und Key als PEM exportieren (für Node.js)
Write-Step "Exportiere Zertifikate für den Webserver ..."

# Zertifikat als PEM
$certPem = "-----BEGIN CERTIFICATE-----`n"
$certPem += [Convert]::ToBase64String($localhostCert.RawData, [Base64FormattingOptions]::InsertLineBreaks)
$certPem += "`n-----END CERTIFICATE-----"
Set-Content -Path (Join-Path $certDir "localhost.crt") -Value $certPem -Encoding ASCII

# Private Key als PEM
$keyBytes = $localhostCert.PrivateKey.ExportPkcs8PrivateKey()

$keyPem = "-----BEGIN PRIVATE KEY-----`n"
$keyPem += [Convert]::ToBase64String($keyBytes, [Base64FormattingOptions]::InsertLineBreaks)
$keyPem += "`n-----END PRIVATE KEY-----"
Set-Content -Path (Join-Path $certDir "localhost.key") -Value $keyPem -Encoding ASCII

# CA-Zertifikat exportieren (für Deinstallation)
$caCertPem = "-----BEGIN CERTIFICATE-----`n"
$caCertPem += [Convert]::ToBase64String($caCert.RawData, [Base64FormattingOptions]::InsertLineBreaks)
$caCertPem += "`n-----END CERTIFICATE-----"
Set-Content -Path (Join-Path $certDir "local-ca.crt") -Value $caCertPem -Encoding ASCII

# Thumbprints speichern (für Deinstallation)
$certInfo = @{
    caThumbprint        = $caCert.Thumbprint
    localhostThumbprint = $localhostCert.Thumbprint
}
$certInfo | ConvertTo-Json | Set-Content (Join-Path $InstallDir "cert-info.json") -Encoding UTF8

Write-Step "Zertifikate exportiert nach: $certDir"

# ============================================================
# Schritt 3: Add-in Dateien installieren
# ============================================================

Write-Header "Schritt 3: Add-in Dateien installieren"

$webrootDir = Join-Path $InstallDir "webroot"
New-Item -ItemType Directory -Path $webrootDir -Force | Out-Null

# Prüfen ob dist-Ordner existiert (bereits gebaut)
$distDir = Join-Path $scriptDir "..\dist"
if (-not (Test-Path $distDir)) {
    Write-Step "Baue Add-in (npm run build) ..."
    Push-Location (Join-Path $scriptDir "..")
    & npm run build 2>&1 | Out-Null
    Pop-Location
}

if (-not (Test-Path $distDir)) {
    Write-Err "Build fehlgeschlagen. dist-Ordner nicht gefunden."
    exit 1
}

# Dateien kopieren
Copy-Item -Path "$distDir\*" -Destination $webrootDir -Recurse -Force
Write-Step "Add-in Dateien kopiert nach: $webrootDir"

# manifest.xml mit korrektem Port anpassen
$manifestPath = Join-Path $webrootDir "manifest.xml"
if (Test-Path $manifestPath) {
    $manifestContent = Get-Content $manifestPath -Raw -Encoding UTF8
    $manifestContent = $manifestContent -replace "https://localhost:3000", "https://localhost:$localPort"
    Set-Content -Path $manifestPath -Value $manifestContent -Encoding UTF8
    Write-Step "manifest.xml angepasst (Port: $localPort)"
}

# Auch eine Kopie der manifest.xml ins Installationsverzeichnis
Copy-Item -Path $manifestPath -Destination (Join-Path $InstallDir "manifest.xml") -Force

# ============================================================
# Schritt 4: Server-Konfiguration und Installation
# ============================================================

Write-Header "Schritt 4: Lokalen Webserver einrichten"

# Server-Dateien kopieren
Copy-Item -Path (Join-Path $scriptDir "local-server.js") -Destination $InstallDir -Force

# import-cert.ps1 ins Installationsverzeichnis kopieren (für spätere Nutzung)
$importCertSrc = Join-Path $scriptDir "import-cert.ps1"
if (Test-Path $importCertSrc) {
    Copy-Item -Path $importCertSrc -Destination $InstallDir -Force
}

# uninstall.ps1 ins Installationsverzeichnis kopieren
$uninstallSrc = Join-Path $scriptDir "uninstall.ps1"
if (Test-Path $uninstallSrc) {
    Copy-Item -Path $uninstallSrc -Destination $InstallDir -Force
}

# config.json erstellen
$serverConfig = @{
    port = $localPort
}
$serverConfig | ConvertTo-Json | Set-Content (Join-Path $InstallDir "config.json") -Encoding UTF8
Write-Step "Server-Konfiguration erstellt."

# Windows Scheduled Task erstellen (startet beim Systemstart)
$taskName = "StarfaceOutlookSyncServer"

# Bestehenden Task entfernen falls vorhanden
Unregister-ScheduledTask -TaskName $taskName -Confirm:$false -ErrorAction SilentlyContinue

$nodeExe = (Get-Command node).Source
$serverScript = Join-Path $InstallDir "local-server.js"

$action = New-ScheduledTaskAction -Execute $nodeExe -Argument "`"$serverScript`"" -WorkingDirectory $InstallDir
$trigger = New-ScheduledTaskTrigger -AtStartup
$principal = New-ScheduledTaskPrincipal -UserId "SYSTEM" -LogonType ServiceAccount -RunLevel Highest
$settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -StartWhenAvailable -ExecutionTimeLimit ([TimeSpan]::Zero)

Register-ScheduledTask -TaskName $taskName -Action $action -Trigger $trigger -Principal $principal -Settings $settings -Description "Lokaler HTTPS-Server für Starface Outlook Sync Add-in" | Out-Null

# Task sofort starten
Start-ScheduledTask -TaskName $taskName
Start-Sleep -Seconds 2

# Prüfen ob der Server läuft
try {
    [System.Net.ServicePointManager]::ServerCertificateValidationCallback = { $true }
    $response = Invoke-WebRequest -Uri "https://localhost:$localPort/taskpane.html" -UseBasicParsing -TimeoutSec 5
    if ($response.StatusCode -eq 200) {
        Write-Step "Lokaler Webserver läuft auf https://localhost:$localPort"
    }
} catch {
    Write-Warn "Server-Test fehlgeschlagen. Server startet möglicherweise verzögert."
}

# ============================================================
# Schritt 5: Outlook Add-in registrieren
# ============================================================

Write-Header "Schritt 5: Outlook Add-in registrieren"

# Manifest-Katalog-Ordner einrichten
$catalogDir = Join-Path $InstallDir "manifest-catalog"
New-Item -ItemType Directory -Path $catalogDir -Force | Out-Null
Copy-Item -Path (Join-Path $InstallDir "manifest.xml") -Destination $catalogDir -Force

# Terminal Server erkennen
$isTerminalServer = $false
$rdRole = Get-WindowsFeature -Name "RDS-RD-Server" -ErrorAction SilentlyContinue
if ($rdRole -and $rdRole.Installed) {
    $isTerminalServer = $true
} elseif ((Get-ItemProperty "HKLM:\SYSTEM\CurrentControlSet\Control\Terminal Server" -Name "TSAppCompat" -ErrorAction SilentlyContinue).TSAppCompat -eq 1) {
    $isTerminalServer = $true
}

if ($isTerminalServer) {
    Write-Step "Terminal Server erkannt - registriere Add-in für alle Benutzer (HKLM)."
}

# Outlook Classic: Shared Folder Catalog per Registry konfigurieren
# Terminal Server: HKLM (gilt für alle User), sonst HKCU
$outlookVersions = @("16.0", "15.0")
$registeredClassic = $false

foreach ($ver in $outlookVersions) {
    # Prüfen ob diese Outlook-Version installiert ist
    $outlookPath = "HKLM:\Software\Microsoft\Office\$ver\Outlook"
    if (-not (Test-Path $outlookPath)) {
        $outlookPath = "HKLM:\Software\WOW6432Node\Microsoft\Office\$ver\Outlook"
    }

    if (Test-Path $outlookPath) {
        Write-Step "Outlook $ver (Classic) gefunden."

        $catalogId = [guid]::NewGuid().ToString("B")

        # Bei Terminal Server: in HKLM registrieren (gilt für alle User)
        if ($isTerminalServer) {
            $outlookRegPath = "HKLM:\Software\Microsoft\Office\$ver\WEF\TrustedCatalogs"
            $catalogRegPath = Join-Path $outlookRegPath $catalogId
            New-Item -Path $catalogRegPath -Force | Out-Null
            New-ItemProperty -Path $catalogRegPath -Name "Url" -Value $catalogDir -PropertyType String -Force | Out-Null
            New-ItemProperty -Path $catalogRegPath -Name "Flags" -Value 1 -PropertyType DWord -Force | Out-Null
            Write-Step "Add-in Katalog für alle Benutzer registriert (HKLM)."
        }

        # Immer auch in HKCU für den aktuellen User (Fallback / Einzelplatz)
        $outlookRegPathUser = "HKCU:\Software\Microsoft\Office\$ver\WEF\TrustedCatalogs"
        $catalogRegPathUser = Join-Path $outlookRegPathUser $catalogId
        New-Item -Path $catalogRegPathUser -Force | Out-Null
        New-ItemProperty -Path $catalogRegPathUser -Name "Url" -Value $catalogDir -PropertyType String -Force | Out-Null
        New-ItemProperty -Path $catalogRegPathUser -Name "Flags" -Value 1 -PropertyType DWord -Force | Out-Null

        Write-Step "Add-in Katalog für Outlook Classic registriert."
        $registeredClassic = $true
    }
}

if (-not $registeredClassic) {
    Write-Warn "Outlook Classic nicht in der Registry gefunden."
}

# Prüfen ob New Outlook installiert ist
$newOutlook = Get-AppxPackage -Name "Microsoft.OutlookForWindows" -ErrorAction SilentlyContinue
if ($newOutlook) {
    Write-Step "Neues Outlook gefunden: Version $($newOutlook.Version)"
    Write-Warn "Für das neue Outlook muss das Add-in manuell hinzugefügt werden:"
    Write-Host "    1. Neues Outlook öffnen" -ForegroundColor White
    Write-Host "    2. Einstellungen (Zahnrad) → Add-Ins verwalten" -ForegroundColor White
    Write-Host "    3. 'Benutzerdefinierte Add-Ins' → 'Aus Datei hinzufügen'" -ForegroundColor White
    Write-Host "    4. Datei wählen: $catalogDir\manifest.xml" -ForegroundColor White
} else {
    Write-Step "Neues Outlook nicht installiert (nur Classic erkannt)."
}

# ============================================================
# Schritt 6: Installationsinfo speichern
# ============================================================

$installInfo = @{
    installDir          = $InstallDir
    localPort           = $localPort
    taskName            = $taskName
    installedAt         = (Get-Date).ToString("o")
    catalogDir          = $catalogDir
    manifestUrl         = "https://localhost:$localPort"
    caThumbprint        = $caCert.Thumbprint
    localhostThumbprint = $localhostCert.Thumbprint
}
$installInfo | ConvertTo-Json | Set-Content (Join-Path $InstallDir "install-info.json") -Encoding UTF8

# ============================================================
# Zusammenfassung
# ============================================================

Write-Header "Installation abgeschlossen!"

Write-Host "  Installationsverzeichnis: $InstallDir" -ForegroundColor White
Write-Host "  Lokaler Server:           https://localhost:$localPort" -ForegroundColor White
Write-Host "  Manifest:                 $catalogDir\manifest.xml" -ForegroundColor White
Write-Host ""

if ($registeredClassic) {
    Write-Host "  Outlook Classic: Add-in wurde automatisch registriert." -ForegroundColor Green
    Write-Host "  → Outlook neu starten, dann 'Kontakt-Sync' im Ribbon suchen." -ForegroundColor Green
}

if ($newOutlook) {
    Write-Host ""
    Write-Host "  Neues Outlook: Bitte Add-in manuell hinzufügen (siehe oben)." -ForegroundColor Yellow
}

Write-Host ""
Write-Host "  Nächster Schritt: Im Add-in ein Sync-Profil mit den" -ForegroundColor White
Write-Host "  Starface-Zugangsdaten einrichten." -ForegroundColor White
Write-Host ""
Write-Host "  Weitere Starface-Anlagen einbinden? Zertifikat importieren mit:" -ForegroundColor Gray
Write-Host "    .\import-cert.ps1 -StarfaceHost <host> [-Port <port>]" -ForegroundColor Gray
Write-Host ""
Write-Host "  Deinstallation: uninstall.ps1 als Administrator ausführen" -ForegroundColor Gray
Write-Host ""

# Firewall-Regel für den lokalen Port (nur localhost, rein vorsichtshalber)
New-NetFirewallRule -DisplayName "Starface Outlook Sync" -Direction Inbound -LocalPort $localPort -Protocol TCP -Action Allow -Profile Private -ErrorAction SilentlyContinue | Out-Null

Read-Host "Eingabetaste zum Beenden"