onyx/Packages/OnyxKit/Tests/OnyxWidgetKitTests/LayoutEngineTests.swift

import Testing
import Foundation
import CoreGraphics
@testable import OnyxWidgetKit

// Das Panel wächst in die **Breite**. Widgets stehen nebeneinander, alle gleich
// groß, in der Reihenfolge, die der Nutzer festgelegt hat. Eine zweite Reihe
// entsteht erst, wenn der Bildschirm keine weitere Kachel mehr hergibt.

private func placements(_ count: Int) -> [WidgetPlacement] {
    (0..<count).map { WidgetPlacement(widgetID: "w\($0)") }
}

/// Breit genug für beliebig viele Kacheln in dieser Testreihe.
private let wideScreen: CGFloat = 4000

@Suite("Rasteraufteilung")
struct LayoutEngineTests {

    @Test("Widgets stehen nebeneinander, nicht untereinander")
    func sideBySide() {
        let resolved = LayoutEngine.resolve(placements(4), availableWidth: wideScreen)
        #expect(resolved.allSatisfy { $0.row == 0 })
        #expect(resolved.map(\.column) == [0, 1, 2, 3])
    }

    @Test("Die Reihenfolge des Nutzers bleibt die Reihenfolge im Panel")
    func keepsOrder() {
        let items = [WidgetPlacement(widgetID: "wetter"),
                     WidgetPlacement(widgetID: "kalender"),
                     WidgetPlacement(widgetID: "medien")]
        let resolved = LayoutEngine.resolve(items, availableWidth: wideScreen)
        #expect(resolved.map(\.placement.widgetID) == ["wetter", "kalender", "medien"])
    }

    @Test("Alle Kacheln sind gleich groß")
    func allTilesSameSize() {
        let resolved = LayoutEngine.resolve(placements(5), availableWidth: wideScreen)
        let sizes = Set(resolved.map { LayoutEngine.frame(for: $0).size.debugDescription })
        #expect(sizes.count == 1)
    }

    @Test("Keine zwei Kacheln überlappen sich")
    func noOverlap() {
        // Der eigentliche Punkt. Genau das war im alten Raster zu sehen: der
        // Kalender lag über dem Wetter. Eine Kachel, die eine andere verdeckt,
        // ist kein Schönheitsfehler, sondern eine verlorene Auskunft.
        for count in 1...12 {
            let resolved = LayoutEngine.resolve(placements(count), availableWidth: 1200)
            let frames = resolved.map { LayoutEngine.frame(for: $0) }
            for (index, frame) in frames.enumerated() {
                for other in frames[(index + 1)...] {
                    #expect(!frame.intersects(other),
                            "Überlappung bei \(count) Kacheln: \(frame) und \(other)")
                }
            }
        }
    }

    @Test("Das Panel wächst in die Breite, nicht in die Höhe")
    func growsSideways() {
        let one = LayoutEngine.panelSize(for: placements(1), availableWidth: wideScreen)
        let four = LayoutEngine.panelSize(for: placements(4), availableWidth: wideScreen)
        #expect(four.width > one.width)
        #expect(four.height == one.height)
    }

    @Test("Erst wenn der Bildschirm voll ist, kommt eine zweite Reihe")
    func wrapsOnlyWhenFull() {
        // Ein Panel breiter als der Bildschirm wäre schlimmer als eine zweite
        // Reihe: die Hälfte hinge außerhalb.
        // Genau so breit, dass zwei Kacheln passen und keine dritte.
        let narrow = LayoutEngine.panelSize(for: placements(2), availableWidth: wideScreen).width
        let resolved = LayoutEngine.resolve(placements(3), availableWidth: narrow)
        #expect(resolved.map(\.row) == [0, 0, 1])
        #expect(resolved.map(\.column) == [0, 1, 0])
    }

    @Test("Das Panel bleibt innerhalb des verfügbaren Platzes")
    func neverExceedsAvailableWidth() {
        let available: CGFloat = 900
        for count in 1...10 {
            let size = LayoutEngine.panelSize(for: placements(count), availableWidth: available)
            #expect(size.width <= available)
        }
    }

    @Test("Auf einem sehr schmalen Bildschirm bleibt mindestens eine Spalte")
    func alwaysAtLeastOneColumn() {
        // Lieber ein Panel, das über den Rand ragt, als eine Division durch
        // null oder ein Panel ohne Inhalt.
        let resolved = LayoutEngine.resolve(placements(2), availableWidth: 10)
        #expect(resolved.map(\.column) == [0, 0])
        #expect(resolved.map(\.row) == [0, 1])
    }

    @Test("Ein leeres Layout ergibt trotzdem ein sichtbares Panel")
    func emptyLayoutHasSize() {
        let size = LayoutEngine.panelSize(for: [], availableWidth: wideScreen)
        #expect(size.width > 0)
        #expect(size.height > 0)
    }

    @Test("Die Kacheln stehen in gleichem Abstand")
    func evenSpacing() {
        let resolved = LayoutEngine.resolve(placements(3), availableWidth: wideScreen)
        let frames = resolved.map { LayoutEngine.frame(for: $0) }
        let gaps = zip(frames, frames.dropFirst()).map { $1.minX - $0.maxX }
        #expect(gaps.allSatisfy { abs($0 - LayoutEngine.tileSpacing) < 0.001 })
    }

    @Test("Die Kacheln liegen vollständig im Panel")
    func tilesFitInsidePanel() {
        // Sonst zeichnet etwas außerhalb — und im Panel heißt außerhalb oben:
        // hinter der Notch.
        let items = placements(7)
        let size = LayoutEngine.panelSize(for: items, availableWidth: 1200)
        for item in LayoutEngine.resolve(items, availableWidth: 1200) {
            let frame = LayoutEngine.frame(for: item)
            #expect(frame.minX >= 0)
            #expect(frame.minY >= 0)
            #expect(frame.maxX <= size.width + 0.001)
            #expect(frame.maxY <= size.height + 0.001)
        }
    }
}