import AppKit

@main
@MainActor
struct ResolvedPlaybackCheck {
    final class Clock { var now = 100.0 }
    static func require(_ condition: @autoclosure () -> Bool, _ message: String) {
        if !condition() { fatalError("FAIL: " + message) }
    }
    static func until(_ message: String, model: PlayerModel, _ predicate: () -> Bool) async throws {
        let deadline = ContinuousClock.now.advanced(by: .seconds(45))
        while !predicate(), ContinuousClock.now < deadline {
            if model.state.status == PLAYER_ERROR || model.commandError != nil {
                fatalError("FAIL: \(message): " + (model.errorText ?? "Playback failed"))
            }
            try await Task.sleep(for: .milliseconds(10))
        }
        require(predicate(), message)
    }
    static func main() async {
        do { try await run() }
        catch { fatalError("FAIL: " + error.localizedDescription) }
    }

    static func run() async throws {
        PlayerModel.metadataLifecycleCheck()
        if CommandLine.arguments[1] == "--metadata-lifecycle" {
            print("PASS: metadata lifecycle replacement, A-B-A stale results, and actual-duration changes")
            return
        }
        _ = NSApplication.shared
        NSApp.setActivationPolicy(.prohibited)
        let input = CommandLine.arguments[1]
        let file = URL(fileURLWithPath: input)
        let source: ResolvedSource
        if input.hasPrefix("https://") {
            guard case .miruro(let mediaID, let episode) = try StreamURL.parse(input) else {
                fatalError("FAIL: URL smoke requires a Miruro episode")
            }
            source = try await MiruroResolver.resolve(mediaID: mediaID, episode: episode)
        } else {
            source = try ResolvedSource.load(from: file)
        }
        if CommandLine.arguments.contains("--enqueue-only") {
            try await enqueueLifecycle(source: source)
            return
        }
        let suite = "terebi.resolved-check." + UUID().uuidString
        let defaults = UserDefaults(suiteName: suite)!
        defer { defaults.removePersistentDomain(forName: suite) }
        let clock = Clock()
        let model = PlayerModel(defaults: defaults, progressFile: CommandLine.arguments.count > 2 ? CommandLine.arguments[2] : nil,
                                miruroMetadataResolver: { id, episode in
                                    if input.hasPrefix("https://") {
                                        return try await MiruroMetadataResolver.resolve(mediaID: id, episode: episode)
                                    }
                                    return MiruroMetadata(title: nil, intervals: [])
                                },
                                skipClock: { clock.now })
        defer { model.shutdown() }
        if input.hasPrefix("https://") { model.openStream(input) }
        else { model.openResolvedSource(file) }
        try await until("video/audio decode and advancing playback", model: model) {
            model.state.status == PLAYER_PLAYING && model.state.has_video && model.state.has_audio && model.state.position > 0.2
        }
        print("PASS: resolved HLS decodes video/audio and advances")
        fflush(stdout)
        if input.hasPrefix("https://") {
            try await until("descriptive title and measured-duration metadata bands", model: model) {
                model.fileName != source.title && !model.visibleIntervals.isEmpty
            }
            let intervals = model.visibleIntervals
            require(intervals.allSatisfy {
                $0.start.isFinite && $0.end.isFinite && $0.start >= 0 &&
                    $0.end > $0.start && $0.end <= model.state.duration
            }, "bands use finite in-bounds actual media duration")
            require(intervals.filter { $0.kind == .intro }.count <= 1 &&
                    intervals.filter { $0.kind == .outro }.count <= 1, "at most one band of each kind")
            print("PASS: Miruro title '\(model.fileName!)' and \(intervals.count) measured-duration bands")
        }
        require(model.setPlayback(playing: false), "pause accepted")
        try await until("pause acknowledged", model: model) { model.state.status == PLAYER_PAUSED }
        require(model.state.can_seek && model.state.duration > 0, "seekable measured duration")
        guard let index = source.subtitles.firstIndex(where: \.isDefault) else {
            fatalError("FAIL: smoke requires a default subtitle")
        }
        let track = source.subtitles[index]
        let document = try await WebVTTDocument.load(url: track.url, headers: track.headers)
        let playableCues = document.cues.filter { !$0.text.isEmpty && $0.start + 0.1 < model.state.duration }
        require(playableCues.count >= 2, "smoke requires two visible subtitle cues")
        let target = playableCues[1].start + min(0.1, (playableCues[1].end - playableCues[1].start) / 2)
        require(!document.text(at: target).isEmpty, "forward seek targets a visible English cue")
        require(model.seekRelative(target - model.state.position), "seek accepted")
        try await until("seek acknowledged and subtitle synchronized", model: model) {
            !model.state.seek_pending && abs(model.state.position - target) < 0.2 &&
                model.subtitleText == document.text(at: model.state.position) && model.subtitleError == nil
        }
        require(model.selectedSubtitle == index && model.subtitleTracks[index].label == track.label, "default selection and label retained")
        let backward = playableCues[0].start + min(0.1, (playableCues[0].end - playableCues[0].start) / 2)
        require(model.seekRelative(backward - model.state.position), "backward seek accepted")
        try await until("backward seek subtitle synchronized", model: model) {
            !model.state.seek_pending && abs(model.state.position - backward) < 0.2 &&
                model.subtitleText == document.text(at: model.state.position)
        }
        print("PASS: default VTT selected, forward/backward seek and acknowledged cue timing")
        if !input.hasPrefix("https://") { try await segmentSkips(model, clock: clock, file: file) }
        if !input.hasPrefix("https://") {
            model.shutdown()
            try await queueMetadataLifecycle(source: source)
            try await streamQueueLifecycle(source: source)
            try await enqueueLifecycle(source: source)
            try await sidebarQueueLifecycle(source: source)
        }
    }

    static func queueMetadataLifecycle(source: ResolvedSource) async throws {
        let suite = "terebi.queue-metadata-check." + UUID().uuidString
        let defaults = UserDefaults(suiteName: suite)!
        defer { defaults.removePersistentDomain(forName: suite) }
        let urls = ["AAAAAAAAAAA", "BBBBBBBBBBB", "CCCCCCCCCCC", "DDDDDDDDDDD"].map {
            URL(string: "https://www.youtube.com/watch?v=\($0)")!
        }
        let episode = URL(string: "https://barelystarted.miruro.tv/watch/fixture-ID/episode?ep=1")!
        var foreground: CheckedContinuation<YouTubeVideo, Never>?
        var background: CheckedContinuation<YouTubeVideo, Never>?
        var holdFirst = true
        var episodeRequests = 0
        func video(_ url: URL, title: String) -> YouTubeVideo {
            YouTubeVideo(title: title, video: .init(url: source.url, headers: source.headers), audio: nil,
                duration: 0, isLive: false, webpageURL: url, height: nil, availableHeights: [])
        }
        let model = PlayerModel(defaults: defaults, youtubeResolver: { url, _ in
            if url == urls[0], holdFirst {
                holdFirst = false
                return await withCheckedContinuation { foreground = $0 }
            }
            if url == urls[1], Task.currentPriority <= .utility {
                return await withCheckedContinuation { background = $0 }
            }
            if url == urls[2] { throw CocoaError(.fileReadCorruptFile) }
            return video(url, title: url == urls[0] ? "Playing title" : "Fresh playback title")
        }, miruroResolver: { _, _ in
            fatalError("FAIL: sidebar enrichment must not fetch Miruro playback sources")
        }, miruroMetadataResolver: { _, _ in
            episodeRequests += 1
            return MiruroMetadata(title: "Queued episode", intervals: [])
        })
        defer { model.shutdown() }
        func queue(_ entries: [URL]) -> StreamQueue {
            StreamQueue(entries: entries.map { url in
                .init(url: url, identity: url == episode ? source.identity : url.absoluteString,
                      progressFile: FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString),
                      label: url.absoluteString)
            })
        }
        model.openStreamQueue(queue([urls[0], urls[1], episode, urls[2], urls[3]]))
        try await until("foreground extraction starts first", model: model) { foreground != nil }
        require(background == nil && episodeRequests == 0, "sidebar lookups yield to selected extraction")
        foreground!.resume(returning: video(urls[0], title: "Playing title"))
        foreground = nil
        try await until("native playback and background extraction start", model: model) {
            !model.isBusy && model.state.status == PLAYER_PLAYING && background != nil
        }
        require(episodeRequests == 0, "sidebar lookups are serial")
        require(model.setPlayback(playing: false), "pause for background title resolution")
        try await until("metadata smoke pause acknowledged", model: model) { model.state.status == PLAYER_PAUSED }
        let selected = model.queue.currentID
        let position = model.state.position
        let pendingID = model.queue.items[1].id
        model.moveQueueItems(fromOffsets: IndexSet(integer: 1), toOffset: 5)
        background!.resume(returning: video(urls[1], title: "Queued title"))
        background = nil
        let deadline = ContinuousClock.now.advanced(by: .seconds(2))
        while model.queue.items.last?.displayName != "Queued title", ContinuousClock.now < deadline {
            try await Task.sleep(for: .milliseconds(10))
        }
        require(model.queue.items.last?.id == pendingID && model.queue.items.last?.displayName == "Queued title",
                "unplayed queue entry resolves by identity after reorder")
        try await until("mixed queue metadata continues after failure", model: model) {
            model.queue.items.first { $0.url == episode }?.displayName == "Queued episode" &&
                model.queue.items.first { $0.url == urls[3] }?.displayName == "Fresh playback title"
        }
        require(model.queue.items.first { $0.url == urls[2] }?.displayName == urls[2].absoluteString &&
                model.commandError == nil, "failed enrichment preserves fallback and does not block later titles")
        require(model.queue.currentID == selected &&
                model.state.position == position && model.state.status == PLAYER_PAUSED &&
                model.fileName == "Playing title", "background metadata preserves selection, position, paused state and current title")

        model.openStreamQueue(queue([urls[0], urls[1]]))
        try await until("next background lookup starts", model: model) { background != nil }
        let cancelled = background!
        background = nil
        model.selectQueueItem(model.queue.items[1].id)
        try await until("selection preempts pending metadata with fresh playback extraction", model: model) {
            !model.isBusy && model.state.status == PLAYER_PLAYING && model.fileName == "Fresh playback title"
        }
        cancelled.resume(returning: video(urls[1], title: "Stale title"))
        for _ in 0..<10 { await Task.yield() }
        require(model.queue.currentItem?.displayName == "Fresh playback title" &&
                model.fileName == "Fresh playback title", "cancelled metadata cannot overwrite selected title")

        model.openStreamQueue(queue([urls[0], urls[1]]))
        try await until("removable background lookup starts", model: model) { background != nil }
        let removed = background!
        background = nil
        model.removeQueueItem(model.queue.items[1].id)
        model.openStreamQueue(queue([urls[0], urls[1]]))
        try await until("replacement background lookup starts", model: model) { background != nil }
        removed.resume(returning: video(urls[1], title: "Removed title"))
        for _ in 0..<10 { await Task.yield() }
        require(model.queue.items[1].displayName == urls[1].absoluteString,
                "removed/replaced item cannot rename a new row for the same URL")
        background!.resume(returning: video(urls[1], title: "Replacement title"))
        background = nil
        try await until("replacement result updates its own row", model: model) {
            model.queue.items[1].displayName == "Replacement title"
        }
        print("PASS: background mixed-stream titles, utility priority, serial lookup, reorder, failure, playback preemption and stale removal/replacement")
    }

    static func streamQueueLifecycle(source: ResolvedSource) async throws {
        let directory = FileManager.default.temporaryDirectory
            .appendingPathComponent("terebi.queue-check." + UUID().uuidString).resolvingSymlinksInPath()
        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true,
                                              attributes: [.posixPermissions: 0o700])
        defer { try? FileManager.default.removeItem(at: directory) }
        let youtubeURL = URL(string: "https://www.youtube.com/watch?v=AAAAAAAAAAA")!
        let episodeURL = URL(string: "https://barelystarted.miruro.tv/watch/fixture-ID/episode?ep=1")!
        let firstReport = directory.appendingPathComponent("youtube.jsonl")
        let secondReport = directory.appendingPathComponent("miruro.jsonl")
        let queue = StreamQueue(entries: [
            .init(url: youtubeURL, identity: youtubeURL.absoluteString, progressFile: firstReport, label: "First"),
            .init(url: episodeURL, identity: source.identity, progressFile: secondReport, label: "Second")
        ])
        let suite = "terebi.queue-check." + UUID().uuidString
        let defaults = UserDefaults(suiteName: suite)!
        defer { defaults.removePersistentDomain(forName: suite) }
        var youtubeRequests = 0
        var episodeRequests = 0
        var stale: CheckedContinuation<YouTubeVideo, Never>?
        let video = YouTubeVideo(title: "Queue YouTube fixture",
            video: .init(url: source.url, headers: source.headers), audio: nil,
            duration: 0, isLive: false, webpageURL: youtubeURL, height: nil, availableHeights: [])
        let model = PlayerModel(defaults: defaults, streamQueue: queue, youtubeResolver: { _, _ in
            if Task.currentPriority > .utility {
                youtubeRequests += 1
                if youtubeRequests == 1 {
                    return await withCheckedContinuation { stale = $0 }
                }
            }
            return video
        }, miruroResolver: { _, _ in
            episodeRequests += 1
            return source
        }, miruroMetadataResolver: { _, _ in MiruroMetadata(title: nil, intervals: []) })
        defer { model.shutdown() }
        require(model.progressInitializationError == nil, "queue report registration")
        model.openStreamQueue(queue)
        try await until("only selected first stream resolves", model: model) { stale != nil }
        require(episodeRequests == 0 && model.queue.items.map(\.url) == [youtubeURL, episodeURL],
                "stream queue is lazy and preserves supplied order")
        let firstID = model.queue.items[0].id
        let secondID = model.queue.items[1].id
        model.selectQueueItem(secondID)
        try await until("manual stream selection decodes native media", model: model) {
            !model.isBusy && model.state.status == PLAYER_PLAYING && model.state.position > 0.2
        }
        stale!.resume(returning: video)
        stale = nil
        // Yield to the canceled resolver; it must not open or redirect its report.
        for _ in 0..<10 { await Task.yield() }
        require(model.queue.currentID == secondID && model.fileName == source.title &&
                !FileManager.default.fileExists(atPath: firstReport.path), "stale extraction cannot replace selected media or report")
        model.advanceQueue(-1)
        try await until("previous resolves YouTube afresh", model: model) {
            !model.isBusy && model.state.status == PLAYER_PLAYING && model.fileName == video.title
        }
        require(youtubeRequests == 2 && model.queue.currentID == firstID, "manual previous preserves queue and resolves current item")
        require(model.setPlayback(playing: false), "pause first queued stream")
        try await until("queue pause acknowledged", model: model) { model.state.status == PLAYER_PAUSED }
        require(model.seekRelative(max(0, model.duration - 0.3) - model.state.position), "seek first stream near natural end")
        try await until("end seek acknowledged", model: model) {
            !model.state.seek_pending && !model.isBusy && abs(model.state.position - max(0, model.duration - 0.3)) < 0.1
        }
        require(model.setPlayback(playing: true), "play first stream to natural end")
        try await until("natural end advances and freshly resolves second stream", model: model) {
            model.queue.currentID == secondID && !model.isBusy && model.state.status == PLAYER_PLAYING &&
                model.fileName == source.title && episodeRequests == 2
        }
        require(model.setPlayback(playing: false), "pause second stream for restoration")
        try await until("second paused", model: model) { model.state.status == PLAYER_PAUSED }
        require(model.seekRelative(0.8 - model.state.position), "save an acknowledged second-stream bookmark")
        try await until("second bookmark acknowledged", model: model) {
            !model.state.seek_pending && abs(model.state.position - 0.8) < 0.1
        }
        model.advanceQueue(-1)
        try await until("revisit first report session", model: model) {
            !model.isBusy && model.fileName == video.title && model.state.status == PLAYER_PLAYING
        }
        model.advanceQueue(1)
        try await until("second revisit resumes acknowledged bookmark", model: model) {
            !model.isBusy && model.fileName == source.title && model.state.status == PLAYER_PLAYING &&
                model.state.position >= 0.7
        }
        require(youtubeRequests == 3 && episodeRequests == 3, "every revisit resolves fresh transport metadata")
        model.shutdown()
        func records(_ file: URL) throws -> [[String: Any]] {
            try String(contentsOf: file, encoding: .utf8).split(separator: "\n").map {
                try JSONSerialization.jsonObject(with: Data($0.utf8)) as! [String: Any]
            }
        }
        let youtubeRows = try records(firstReport)
        let episodeRows = try records(secondReport)
        require(youtubeRows.count >= 4 && youtubeRows.allSatisfy {
            $0["version"] as? Int == 1 && $0["media_url"] as? String == youtubeURL.absoluteString
        }, "YouTube report appends on revisit without another identity")
        require(youtubeRows.contains { $0["event"] as? String == "ended" }, "natural end retains its acknowledged completion snapshot")
        require(episodeRows.count >= 6 && episodeRows.allSatisfy {
            let identity = $0["media_identity"] as? [String: Any]
            return $0["version"] as? Int == 2 && identity?["media_id"] as? String == "fixture-ID" &&
                identity?["episode"] as? Int == 1
        }, "Miruro report is isolated through selection, advance and revisits")
        print("PASS: ordered lazy mixed stream queue, stale cancellation, native end advance, fresh revisits/resume and report isolation")
    }

    static func enqueueLifecycle(source: ResolvedSource) async throws {
        let directory = FileManager.default.temporaryDirectory
            .appendingPathComponent("terebi.enqueue-check." + UUID().uuidString).resolvingSymlinksInPath()
        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true,
                                              attributes: [.posixPermissions: 0o700])
        defer { try? FileManager.default.removeItem(at: directory) }
        let first = URL(string: "https://www.youtube.com/watch?v=AAAAAAAAAAA")!
        let second = URL(string: "https://barelystarted.miruro.tv/watch/fixture-ID/episode?ep=1")!
        let third = URL(string: "https://www.youtube.com/watch?v=BBBBBBBBBBB")!
        let fourth = URL(string: "https://www.youtube.com/watch?v=CCCCCCCCCCC")!
        let originalReport = directory.appendingPathComponent("original.jsonl")
        let secondReport = directory.appendingPathComponent("second.jsonl")
        let thirdReport = directory.appendingPathComponent("third.jsonl")
        let fourthReport = directory.appendingPathComponent("fourth.jsonl")
        let manifest = directory.appendingPathComponent("queue & #.json")
        var requests = 0
        var episodeRequests = 0
        let suite = "terebi.enqueue-check." + UUID().uuidString
        let defaults = UserDefaults(suiteName: suite)!
        defer { defaults.removePersistentDomain(forName: suite) }
        let model = PlayerModel(defaults: defaults, progressFile: originalReport.path,
            youtubeResolver: { url, _ in
                requests += 1
                return YouTubeVideo(title: url.absoluteString,
                    video: .init(url: source.url, headers: source.headers), audio: nil,
                    duration: 0, isLive: false, webpageURL: url, height: nil, availableHeights: [])
            }, miruroResolver: { _, _ in episodeRequests += 1; return source },
            miruroMetadataResolver: { _, _ in MiruroMetadata(title: nil, intervals: []) })
        defer { model.shutdown() }
        func deliver(_ items: [(URL, URL)]) throws {
            let document: [String: Any] = ["version": 1, "items": items.map {
                ["url": $0.0.absoluteString, "progress_file": $0.1.path]
            }]
            try JSONSerialization.data(withJSONObject: document).write(to: manifest)
            model.receiveEnqueueURL(StreamQueue.enqueueURL(for: manifest))
        }
        model.openStream(first.absoluteString)
        try await until("standalone stream begins before enqueue", model: model) {
            model.state.status == PLAYER_PLAYING && !model.isBusy && model.state.position > 0.2
        }
        require(model.setPlayback(playing: false), "pause original single-video playback")
        try await until("standalone pause acknowledged", model: model) { model.state.status == PLAYER_PAUSED }
        let selected = model.queue.currentID
        let position = model.state.position
        let revision = model.state.revision
        try deliver([(second, secondReport), (third, thirdReport)])
        require(model.queue.items.map(\.url) == [first, second, third] &&
                model.queue.currentID == selected && model.state.status == PLAYER_PAUSED &&
                model.state.position == position && model.state.revision == revision &&
                model.fileName == first.absoluteString && requests == 1 && episodeRequests == 0,
                "paused enqueue preserves original media, selection and decoder timeline; new items resolve lazily in supplied order")
        require(model.setPlayback(playing: true), "resume original playback")
        try await until("original playing again", model: model) { model.state.status == PLAYER_PLAYING }
        let playingRevision = model.state.revision
        try deliver([(fourth, fourthReport)])
        require(model.queue.items.map(\.url) == [first, second, third, fourth] &&
                model.queue.currentID == selected && model.state.revision == playingRevision &&
                model.state.status == PLAYER_PLAYING,
                "repeated native delivery appends while playing without reopening current media")
        try deliver([(third, directory.appendingPathComponent("conflict.jsonl"))])
        require(model.commandError != nil && model.queue.items.count == 4 && model.queue.currentID == selected,
                "conflicting identity rejects complete enqueue without changing playback")
        try deliver([(URL(string: "https://www.youtube.com/watch?v=DDDDDDDDDDD")!, fourthReport)])
        require(model.commandError != nil && model.queue.items.count == 4,
                "registered report-path conflicts reject complete enqueue before files exist")
        try deliver([(URL(string: "https://www.youtube.com/watch?v=DDDDDDDDDDD")!, directory.appendingPathComponent("valid.jsonl")),
                     (URL(string: "file:///not-a-stream")!, directory.appendingPathComponent("invalid.jsonl"))])
        require(model.commandError != nil && model.queue.items.count == 4,
                "invalid later manifest entry never partially appends or registers reports")
        try deliver([(URL(string: "https://www.youtube.com/watch?v=DDDDDDDDDDD")!, directory.appendingPathComponent("valid.jsonl"))])
        require(model.commandError == nil && model.queue.items.count == 5, "failed batches leave no registrations behind")
        require(model.setPlayback(playing: false), "pause original before natural-end advance")
        try await until("original pause before end seek", model: model) { model.state.status == PLAYER_PAUSED }
        let ending = max(0, model.duration - 0.3)
        require(model.seekRelative(ending - model.state.position), "seek original near natural end")
        try await until("original end seek acknowledged", model: model) {
            !model.state.seek_pending && !model.isBusy && abs(model.state.position - ending) < 0.1
        }
        require(model.setPlayback(playing: true), "resume original through natural end")
        try await until("natural end advances to enqueued Miruro item", model: model) {
            !model.isBusy && model.state.status == PLAYER_PLAYING && model.fileName == source.title &&
                model.queue.currentURL == second
        }
        model.advanceQueue(1)
        try await until("enqueued YouTube item decodes", model: model) {
            !model.isBusy && model.state.status == PLAYER_PLAYING && model.fileName == third.absoluteString
        }
        model.advanceQueue(-1)
        try await until("enqueued Miruro report revisits", model: model) {
            !model.isBusy && model.state.status == PLAYER_PLAYING && model.fileName == source.title
        }
        model.advanceQueue(-1)
        try await until("original single video remains navigable", model: model) {
            !model.isBusy && model.state.status == PLAYER_PLAYING && model.fileName == first.absoluteString
        }
        var retiredReports: [(URL, Data, URL, URL)] = []
        for (url, oldReport) in [(first, originalReport), (third, thirdReport)] {
            let oldID = model.queue.items.first(where: { $0.url == url })!.id
            model.removeQueueItem(oldID)
            let currentID = model.queue.currentID
            let freshReport = directory.appendingPathComponent(oldReport.lastPathComponent + ".fresh")
            try deliver([(url, freshReport)])
            require(model.commandError == nil && model.queue.items.count == 5 &&
                    model.queue.currentID == currentID, "removed video re-enqueues without interrupting current playback")
            let retiredBytes = try Data(contentsOf: oldReport)
            retiredReports.append((oldReport, retiredBytes, freshReport, url))
            require(!FileManager.default.fileExists(atPath: freshReport.path), "re-added report remains lazy")
            model.selectQueueItem(model.queue.items.last!.id)
            try await until("re-added video decodes with a fresh session", model: model) {
                !model.isBusy && model.state.status == PLAYER_PLAYING &&
                    model.queue.currentURL == url && model.state.position > 0.2
            }
            require(model.setPlayback(playing: false), "pause re-added video")
            try await until("re-added pause acknowledged", model: model) { model.state.status == PLAYER_PAUSED }
        }
        model.shutdown()
        for (oldReport, retiredBytes, freshReport, url) in retiredReports {
            let finalBytes = try Data(contentsOf: oldReport)
            require(finalBytes == retiredBytes, "re-added playback leaves the retired report unchanged")
            let freshRows = try String(contentsOf: freshReport, encoding: .utf8).split(separator: "\n").map {
                try JSONSerialization.jsonObject(with: Data($0.utf8)) as! [String: Any]
            }
            require(freshRows.contains { $0["event"] as? String == "closed" } &&
                    freshRows.contains { $0["event"] as? String == "progress" } &&
                    freshRows.allSatisfy { $0["media_url"] as? String == url.absoluteString },
                    "re-added video writes its acknowledged progress and close to the fresh report only")
        }
        for (file, expected) in [(originalReport, first.absoluteString), (thirdReport, third.absoluteString)] {
            let rows = try String(contentsOf: file, encoding: .utf8).split(separator: "\n").map {
                try JSONSerialization.jsonObject(with: Data($0.utf8)) as! [String: Any]
            }
            require(!rows.isEmpty && rows.allSatisfy { $0["media_url"] as? String == expected },
                    "original and appended YouTube reports retain independent identities")
        }
        let episodeRows = try String(contentsOf: secondReport, encoding: .utf8).split(separator: "\n").map {
            try JSONSerialization.jsonObject(with: Data($0.utf8)) as! [String: Any]
        }
        require(!episodeRows.isEmpty && episodeRows.allSatisfy {
            let identity = $0["media_identity"] as? [String: Any]
            return identity?["media_id"] as? String == "fixture-ID" && identity?["episode"] as? Int == 1
        }, "appended Miruro report remains isolated on revisit")
        require(!FileManager.default.fileExists(atPath: fourthReport.path), "unselected enqueued item never owns a writer")
        let empty = PlayerModel(defaults: defaults, youtubeResolver: { url, _ in
            YouTubeVideo(title: "Cold enqueue", video: .init(url: source.url, headers: source.headers), audio: nil,
                         duration: 0, isLive: false, webpageURL: url, height: nil, availableHeights: [])
        })
        defer { empty.shutdown() }
        let coldReport = directory.appendingPathComponent("cold.jsonl")
        empty.enqueueStreamQueue(StreamQueue(entries: [.init(url: fourth, identity: fourth.absoluteString,
                                                             progressFile: coldReport, label: "Cold enqueue")]))
        try await until("empty player starts first enqueued item", model: empty) {
            !empty.isBusy && empty.state.status == PLAYER_PLAYING && empty.queue.currentURL == fourth
        }
        print("PASS: repeated enqueue while paused/playing, standalone navigation, atomic conflicts, independent reports and empty-player start")
    }

    static func sidebarQueueLifecycle(source: ResolvedSource) async throws {
        let suite = "terebi.sidebar-queue-check." + UUID().uuidString
        let defaults = UserDefaults(suiteName: suite)!
        defer { defaults.removePersistentDomain(forName: suite) }
        let first = URL(string: "https://www.youtube.com/watch?v=AAAAAAAAAAA")!
        let second = URL(string: "https://www.youtube.com/watch?v=BBBBBBBBBBB")!
        let episode = URL(string: "https://barelystarted.miruro.tv/watch/fixture-ID/episode?ep=1")!
        let failedURL = URL(string: "https://example.invalid/failure")!
        let cancelledURL = URL(string: "https://example.invalid/cancelled")!
        var requests = 0
        var pending: CheckedContinuation<YouTubeVideo, Never>?
        let model = PlayerModel(defaults: defaults, youtubeResolver: { url, _ in
            requests += 1
            if url == failedURL { throw CocoaError(.fileReadCorruptFile) }
            let video = YouTubeVideo(title: "Sidebar \(url == first ? "first" : "second")",
                video: .init(url: source.url, headers: source.headers), audio: nil,
                duration: 0, isLive: false, webpageURL: url, height: nil, availableHeights: [])
            if url == cancelledURL { return await withCheckedContinuation { pending = $0 } }
            return video
        }, miruroResolver: { _, _ in source },
           miruroMetadataResolver: { _, _ in MiruroMetadata(title: nil, intervals: []) })
        defer { model.shutdown() }
        try await model.addStreamToQueue(first.absoluteString)
        try await until("empty sidebar addition starts fetched video", model: model) {
            !model.isBusy && model.state.status == PLAYER_PLAYING && model.state.position > 0.2
        }
        require(requests == 1 && model.queue.currentURL == first, "empty addition uses fetched source without re-extracting")
        require(model.setPlayback(playing: false), "pause before sidebar addition")
        try await until("sidebar pause acknowledged", model: model) { model.state.status == PLAYER_PAUSED }
        let selected = model.queue.currentID
        let revision = model.state.revision
        let position = model.state.position
        try await model.addStreamToQueue(" https://youtu.be/BBBBBBBBBBB \n")
        try await model.addStreamToQueue(episode.absoluteString)
        require(model.queue.items.map(\.url) == [first, second, episode] &&
                model.queue.items[1].displayName == "Sidebar second" &&
                model.queue.items[2].displayName == source.title &&
                model.queue.currentID == selected && model.state.revision == revision &&
                model.state.position == position && model.state.status == PLAYER_PAUSED,
                "fetched YouTube and Miruro additions preserve paused playback, order and titles")
        for text in ["not a URL", "file:///tmp/video.mp4"] {
            do {
                try await model.addStreamToQueue(text)
                fatalError("FAIL: invalid sidebar URL accepted")
            } catch {}
        }
        do {
            try await model.addStreamToQueue(failedURL.absoluteString)
            fatalError("FAIL: failed extraction accepted")
        } catch {}
        require(model.queue.items.map(\.url) == [first, second, episode] && model.queue.currentID == selected,
                "invalid URLs and failed extraction leave queue untouched")
        require(model.setPlayback(playing: true), "resume before sidebar addition")
        try await until("sidebar resume acknowledged", model: model) { model.state.status == PLAYER_PLAYING }
        let playingRevision = model.state.revision
        try await model.addStreamToQueue(second.absoluteString)
        require(model.state.revision == playingRevision && model.queue.currentID == selected &&
                model.state.status == PLAYER_PLAYING, "addition does not restart playing media")
        let cancelled = Task { try await model.addStreamToQueue(cancelledURL.absoluteString) }
        while pending == nil { await Task.yield() }
        cancelled.cancel()
        pending!.resume(returning: YouTubeVideo(title: "Cancelled", video: .init(url: source.url, headers: source.headers),
            audio: nil, duration: 0, isLive: false, webpageURL: cancelledURL, height: nil, availableHeights: []))
        do {
            try await cancelled.value
            fatalError("FAIL: cancelled sidebar addition accepted")
        } catch is CancellationError {}
        require(model.queue.items.count == 4 && model.queue.currentID == selected,
                "dismissed in-flight addition cannot append a late result")
        model.selectQueueItem(model.queue.items[1].id)
        try await until("sidebar-added item plays through native queue selection", model: model) {
            !model.isBusy && model.state.status == PLAYER_PLAYING && model.queue.currentURL == second &&
                model.fileName == "Sidebar second"
        }
        print("PASS: sidebar URL fetch/add, empty-player decode, paused/playing preservation, validation, failure, cancellation and selection")
    }

    static func segmentSkips(_ model: PlayerModel, clock: Clock, file: URL) async throws {
        let opening = MiruroInterval(kind: .intro, start: 0.5, end: 1.5, episode: 1)
        let ending = MiruroInterval(kind: .outro, start: 2, end: model.duration, episode: 1)
        let metadata = MiruroMetadata(title: nil, intervals: [opening, ending])
        require(model.segmentToSkip == nil && !model.skipSegment(), "absent metadata cannot skip")
        require(model.seekRelative(0.75 - model.state.position), "enter opening")
        try await until("opening position acknowledged", model: model) {
            !model.state.seek_pending && abs(model.state.position - 0.75) < 0.1
        }
        model.supplyMetadataForCheck(metadata, episode: 1)
        require(model.segmentToSkip == opening, "late metadata offers opening at acknowledged paused position")
        require(model.skipOfferRemainingFraction == 1, "late entry starts with a full countdown background")
        clock.now = 105
        require(model.skipOfferRemainingFraction == 0.5, "paused countdown drains by elapsed offer time, not media position")
        clock.now = 109.999
        require(model.segmentToSkip == opening, "opening remains available before ten seconds")
        clock.now = 110
        require(model.segmentToSkip == nil && !model.skipSegment(), "offer expires at ten seconds while paused")
        require(model.skipOfferRemainingFraction == 0, "expired offer has no remaining background")
        clock.now = 111
        try await Task.sleep(for: .milliseconds(100))
        require(model.segmentToSkip == nil, "polling does not reoffer ignored opening")
        require(model.seekRelative(2.25 - model.state.position), "enter ending")
        require(model.segmentToSkip == nil, "pending seek cannot offer stale opening")
        try await until("ending offer", model: model) {
            !model.state.seek_pending && model.segmentToSkip == ending
        }
        require(model.skipSegment(), "ending skip accepted")
        require(model.segmentToSkip == nil, "accepted skip immediately removes button")
        try await until("ending skip reaches exact media end", model: model) {
            !model.state.seek_pending && abs(model.state.position - ending.end) < 0.1
        }
        require(!model.effectivePlaying, "paused skip does not start playback")
        require(model.seekRelative(0.75 - model.state.position), "revisit ignored opening")
        try await until("opening revisit acknowledged", model: model) {
            !model.state.seek_pending && abs(model.state.position - 0.75) < 0.1
        }
        require(model.segmentToSkip == nil, "ignored opening stays dismissed when revisited")
        model.closeFile()
        require(model.segmentToSkip == nil, "close removes offer")
        model.openResolvedSource(file)
        try await until("reopened media playing", model: model) {
            model.state.status == PLAYER_PLAYING && !model.state.seek_pending && !model.isBusy
        }
        require(model.setPlayback(playing: false), "pause reopened media")
        try await until("reopened media paused", model: model) { model.state.status == PLAYER_PAUSED }
        require(model.seekRelative(0.75 - model.state.position), "reenter opening after reopen")
        try await until("reopened opening acknowledged", model: model) {
            !model.state.seek_pending && abs(model.state.position - 0.75) < 0.1
        }
        model.supplyMetadataForCheck(metadata, episode: 1)
        try await until("new open resets dismissal after seek settles", model: model) {
            model.segmentToSkip == opening
        }
        require(model.setPlayback(playing: true), "resume inside opening")
        try await until("playing opening offer", model: model) {
            model.state.status == PLAYER_PLAYING && !model.state.buffering &&
                model.state.position > 0.85 && model.segmentToSkip == opening
        }
        require(model.skipSegment(), "opening skip accepted")
        try await until("opening skip reaches segment end", model: model) {
            !model.state.seek_pending && abs(model.state.position - opening.end) < 0.1
        }
        require(model.segmentToSkip == nil, "segment end is outside opening")
        require(model.effectivePlaying, "opening skip preserves playing intent")
        print("PASS: timed opening/ending offers, dismissal, pending seeks, exact-end skips and reopen reset")
    }
}