// SPDX-FileCopyrightText: 2026 Kaede Akino
// SPDX-License-Identifier: GPL-3.0-only

import AgentKit
import Foundation
import TermindApplication
import TermindDomain
import TermindPresentation
import Testing

@testable import TermindApplication

@Suite @MainActor
struct AssistantNotificationTests {
    @Test(arguments: [false, true])
    func removingConversationOrStoppingCancelsDeliveryAndDetachesEvents(stop: Bool) async {
        let conversation = ConversationModel()
        let store = AssistantConversationStore(conversations: [conversation])
        let sender = NotificationDeliveryRecorder()
        let coordinator = AssistantNotificationCoordinator(
            service: sender, preferences: { .init() }, isFocused: { _ in false },
            content: AssistantNotificationContent.make)
        coordinator.observe(conversation)
        conversation.handle(.runFinished(.init(id: UUID(), state: .completed, startedAt: .now)))
        _ = await sender.nextRequest()
        if stop { coordinator.stop() } else { store.remove(conversation.id) }
        await sender.finishDelivery()
        #expect(sender.sent.isEmpty)
        let unread = conversation.unreadNotificationCount
        conversation.handle(.runFinished(.init(id: UUID(), state: .completed, startedAt: .now)))
        #expect(conversation.unreadNotificationCount == unread)
        #expect(conversation.notificationEvent == nil)
    }

    @Test func stoppingKeepsAlreadyDeliveredCompletionNotifications() async {
        let conversation = ConversationModel()
        let sender = NotificationDeliveryRecorder()
        let coordinator = AssistantNotificationCoordinator(
            service: sender, preferences: { .init() }, isFocused: { _ in false },
            content: AssistantNotificationContent.make)
        coordinator.observe(conversation)
        conversation.handle(.runFinished(.init(id: UUID(), state: .completed, startedAt: .now)))
        _ = await sender.nextRequest()
        await sender.finishDelivery()
        coordinator.stop()
        #expect(sender.sent.count == 1)
        #expect(sender.removed.isEmpty)
    }

    @Test func manuallyChangingUnreadStateIsIdempotentAndDoesNotSendNotifications() async {
        let fixture = AssistantNotificationFixture()
        let conversation = fixture.conversation
        conversation.markNotificationsUnread()
        conversation.markNotificationsUnread()
        #expect(conversation.unreadNotificationCount == 1)
        conversation.markNotificationsRead()
        #expect(conversation.unreadNotificationCount == 0)
        await settle()
        #expect(fixture.sender.sent.isEmpty)
        #expect(ConversationModel().unreadNotificationCount == 0)
    }

    @Test func completedNotificationUsesTheFinalReplyFromThatRun() async {
        let fixture = AssistantNotificationFixture()
        fixture.conversation.customTitle = "Deploy staging"
        let old = AgentRunSummary(id: UUID(), state: .running, startedAt: .now)
        fixture.conversation.handle(.runStarted(old))
        fixture.conversation.handle(.messageFinished(.init(role: .assistant, text: "Old reply")))
        var run = AgentRunSummary(id: UUID(), state: .running, startedAt: .now)
        fixture.conversation.handle(.runStarted(run))
        fixture.conversation.handle(.messageFinished(.init(role: .assistant, text: "Deployment is ready.")))
        run.state = .completed
        fixture.conversation.handle(.runFinished(run))
        await settle()
        #expect(fixture.sender.sent.last?.title == "Deploy staging")
        #expect(fixture.sender.sent.last?.body == "Deployment is ready.")
        let emptyRun = AgentRunSummary(id: UUID(), state: .completed, startedAt: .now)
        fixture.conversation.handle(.runFinished(emptyRun))
        await settle()
        #expect(fixture.sender.sent.last?.body != "Deployment is ready.")
    }

    @Test func unreadCountsAreIndependentOfSystemDeliveryAndResetWithTheModel() async {
        let fixture = AssistantNotificationFixture()
        fixture.settings.isEnabled = false
        let run = AgentRunSummary(id: UUID(), state: .completed, startedAt: .now)
        fixture.conversation.handle(.runFinished(run))
        fixture.conversation.handle(.runFinished(run))
        #expect(fixture.conversation.unreadNotificationCount == 1)
        let request = request()
        fixture.conversation.present(request)
        #expect(fixture.conversation.unreadNotificationCount == 2)
        fixture.conversation.cancelUserInput()
        #expect(fixture.conversation.unreadNotificationCount == 1)
        fixture.conversation.markNotificationsRead()
        #expect(fixture.conversation.unreadNotificationCount == 0)
        #expect(ConversationModel().unreadNotificationCount == 0)
        await settle()
        #expect(fixture.sender.sent.isEmpty)
    }

    @Test func globalAssistantSuppressionStillCountsUnseenConversationEvents() async {
        let conversation = ConversationModel()
        let sender = NotificationRecorder()
        let coordinator = AssistantNotificationCoordinator(
            service: sender, preferences: { .init() }, isFocused: { _ in true }, isVisible: { _ in false },
            content: AssistantNotificationContent.make)
        coordinator.observe(conversation)
        conversation.handle(.runFinished(.init(id: UUID(), state: .completed, startedAt: .now)))
        await settle()
        #expect(sender.sent.isEmpty)
        #expect(conversation.unreadNotificationCount == 1)
    }

    @Test func appBadgeTracksOnlyLiveUnreadCountsAndStopsAtZero() async {
        let conversation = ConversationModel()
        let sender = NotificationRecorder()
        let badge = NotificationBadgeCoordinator(service: sender) { conversation.unreadNotificationCount }
        #expect(sender.badgeCounts == [0])
        conversation.markNotificationUnread("first")
        conversation.markNotificationUnread("second")
        await settle()
        #expect(sender.badgeCounts.last == 2)
        conversation.markNotificationsRead()
        await settle()
        #expect(sender.badgeCounts.last == 0)
        badge.stop()
        conversation.markNotificationUnread("third")
        await settle()
        #expect(sender.badgeCounts.last == 0)
    }

    @Test func completedAndFailedRunsNotifyOnceWithoutReplacingOtherCallbacks() async {
        let fixture = AssistantNotificationFixture()
        var titleCalls = 0
        var memoryCalls = 0
        fixture.conversation.runDidFinish = { titleCalls += 1 }
        fixture.conversation.memoryRunFinished = { _, _, _, _ in memoryCalls += 1 }
        for state in [AgentRunState.completed, .failed, .cancelled, .interrupted] {
            let run = AgentRunSummary(id: UUID(), state: state, startedAt: .now, finishedAt: .now)
            fixture.conversation.handle(.runState(state))
            fixture.conversation.handle(.runFinished(run))
            fixture.conversation.handle(.runFinished(run))
        }
        await settle()
        #expect(fixture.sender.sent.count == 2)
        #expect(titleCalls == 4 && memoryCalls == 8)
        #expect(fixture.sender.sent.allSatisfy { $0.target == .assistant(fixture.conversation.id) })
    }

    @Test func preparationFailuresNotifyAndRestorationDoesNotReplay() async {
        let fixture = AssistantNotificationFixture()
        let snapshot = AgentRunSnapshot(
            conversationID: fixture.conversation.id, state: .failed,
            permissionMode: .askForApproval, failure: "Connection failed: password=secret-value")
        fixture.conversation.recordFailedRun(snapshot)
        fixture.conversation.recordFailedRun(snapshot)
        await settle()
        #expect(fixture.sender.sent.count == 1)
        #expect(fixture.sender.sent[0].body.contains("Connection failed"))
        #expect(!fixture.sender.sent[0].body.contains("secret-value"))
        let restored = ConversationModel(
            runState: .completed,
            runs: [.init(id: UUID(), state: .completed, startedAt: .now)])
        fixture.coordinator.observe(restored)
        await settle()
        #expect(fixture.sender.sent.count == 1)
    }

    @Test(arguments: NotificationPreferences.Mode.allCases, [false, true])
    func assistantModeUsesTheConversationFocus(_ mode: NotificationPreferences.Mode, focused: Bool) async {
        let fixture = AssistantNotificationFixture()
        fixture.settings.assistantMode = mode
        fixture.focused = focused
        let run = AgentRunSummary(id: UUID(), state: .completed, startedAt: .now)
        fixture.conversation.handle(.runFinished(run))
        await settle()
        #expect(fixture.sender.sent.count == (mode.allows(isFocused: focused) ? 1 : 0))
        fixture.settings.assistantMode = .always
        fixture.focused = false
        fixture.conversation.handle(.runFinished(run))
        await settle()
        #expect(fixture.sender.sent.count == (mode.allows(isFocused: focused) ? 1 : 0))
    }

    @Test func queueHeadsNotifyOnceAndResolvedOrStoppedRequestsAreRemoved() async throws {
        let fixture = AssistantNotificationFixture()
        let first = request()
        let second = request(secret: true, date: first.createdAt.addingTimeInterval(1))
        fixture.conversation.present(first)
        fixture.conversation.present(second)
        await settle()
        #expect(fixture.sender.sent.count == 1)
        fixture.conversation.cancelUserInput()
        await settle()
        #expect(fixture.sender.sent.count == 2)
        #expect(fixture.sender.removed.contains(fixture.sender.sent[0].id))
        #expect(fixture.conversation.notificationInteraction?.kind == .secret)
        fixture.conversation.handle(.runState(.cancelled))
        #expect(fixture.sender.removed.contains(fixture.sender.sent[1].id))
        fixture.conversation.cancelUserInput()
    }

    @Test func pendingDeliveryRechecksRequestAndSettingsAfterSuspension() async {
        let fixture = AssistantNotificationFixture()
        fixture.sender.hold = true
        fixture.conversation.present(request())
        await settle()
        #expect(fixture.sender.waiter != nil)
        fixture.conversation.cancelUserInput()
        fixture.sender.resume()
        await settle()
        #expect(fixture.sender.sent.isEmpty)
        fixture.conversation.present(request())
        await settle()
        fixture.settings.isEnabled = false
        fixture.sender.resume()
        await settle()
        #expect(fixture.sender.sent.isEmpty)
        fixture.conversation.cancelUserInput()
    }

    @Test func timeoutRemovesThePromptWithoutResettingItsDeadline() async {
        let fixture = AssistantNotificationFixture()
        var wake: CheckedContinuation<Void, Never>?
        fixture.conversation.questionClockSleep = { _ in await withCheckedContinuation { wake = $0 } }
        fixture.conversation.present(request())
        await settle()
        #expect(fixture.sender.sent.count == 1)
        wake?.resume()
        await settle()
        #expect(fixture.conversation.pendingUserInput == nil)
        #expect(fixture.sender.removed.contains(fixture.sender.sent[0].id))
    }

    @Test(arguments: [false, true])
    func authenticationAndPassphraseUseOnlyTheirCategory(passphrase: Bool) async {
        let fixture = AssistantNotificationFixture()
        let request = AgentSSHAuthenticationRequest(
            invocationID: UUID(), hostID: UUID(), displayName: "private-host",
            address: "secret.example", mode: passphrase ? .passphrase(keyID: UUID()) : .identity,
            username: "private-user")
        let task = Task { await fixture.conversation.requestSSHAuthentication(request) }
        await settle()
        #expect(fixture.conversation.notificationInteraction?.kind == (passphrase ? .passphrase : .authentication))
        #expect(fixture.sender.sent.count == 1)
        #expect(!fixture.sender.sent[0].body.contains("private"))
        fixture.conversation.respondToSSHAuthentication(.cancelled)
        _ = await task.value
        #expect(fixture.sender.removed.contains(fixture.sender.sent[0].id))
    }

    @Test func emptyKeyboardChallengeCompletesWithoutNotification() async {
        let fixture = AssistantNotificationFixture()
        let challenge = SSHKeyboardInteractiveChallenge(
            connectionID: UUID(), hostID: UUID(), hostname: "example",
            port: 22, username: "user", round: 0, name: "", instruction: "", prompts: [])
        let request = AgentSSHAuthenticationRequest(
            invocationID: UUID(), hostID: UUID(), displayName: "example",
            address: "example", mode: .keyboardInteractive(challenge), username: "user")
        _ = await fixture.conversation.requestSSHAuthentication(request)
        await settle()
        #expect(fixture.sender.sent.isEmpty)
    }

    @Test func hostKeyConfirmationAndApprovalFollowTheVisibleInteractionPriority() async {
        let fixture = AssistantNotificationFixture()
        let question = request()
        fixture.conversation.present(question)
        await settle()
        let invocation = AgentToolInvocation(
            runID: UUID(),
            call: AgentToolCall(id: "call", name: "review", arguments: .object([:])))
        let approval = AgentApprovalRequest(
            invocation: invocation,
            descriptor: .init(
                name: "review", summary: "private", inputSchema: .object([:]),
                target: .host, approvalPolicy: .ask), userIntent: "private-intent")
        let approvalTask = Task { await fixture.conversation.requestApproval(approval) }
        let hostKey = AgentSSHHostKeyRequest(
            createdAt: question.createdAt.addingTimeInterval(1), invocationID: UUID(), hostID: UUID(),
            displayName: "private-host", address: "private.example",
            prompt: .init(
                observation: .init(
                    hostname: "private.example", port: 22, algorithm: .ed25519,
                    fingerprint: "private-fingerprint"), kind: .firstUse), allowsPersistentTrust: true)
        let hostTask = Task { await fixture.conversation.requestSSHHostKeyConfirmation(hostKey) }
        await settle()
        #expect(fixture.sender.sent.count == 1)
        fixture.conversation.cancelUserInput()
        await settle()
        #expect(fixture.conversation.notificationInteraction?.kind == .hostKey)
        #expect(fixture.sender.sent.count == 2)
        fixture.conversation.respondToSSHHostKey(.deny)
        _ = await hostTask.value
        await settle()
        #expect(fixture.conversation.notificationInteraction?.kind == .approval)
        #expect(fixture.sender.sent.count == 3)
        fixture.conversation.respondToApproval(approval.id, allow: false)
        _ = await approvalTask.value
        #expect(fixture.sender.removed.count == 3)
        #expect(fixture.sender.sent.allSatisfy { !$0.body.contains("private") })
    }

    @Test func questionPagingDoesNotNotifyAgainOrMoveTheDeadline() async {
        let fixture = AssistantNotificationFixture()
        let request = AgentUserInputRequest(questions: [
            .init(id: "first", prompt: "First", kind: .text),
            .init(id: "second", prompt: "Second", kind: .text),
        ])
        fixture.conversation.present(request)
        let deadline = fixture.conversation.userInputDeadline
        await settle()
        fixture.conversation.skipUserInputQuestion()
        await settle()
        #expect(fixture.sender.sent.count == 1)
        #expect(fixture.conversation.userInputDeadline == deadline)
        fixture.conversation.cancelUserInput()
    }

    @Test func notificationTitlesMatchTheConversationTitleAndInteractionBodiesExcludePrompts() {
        let conversation = ConversationModel(messages: [.init(role: .user, text: "password=secret")])
        let text = AssistantNotificationContent.make(conversation, kind: .questions)
        #expect(text.title == conversation.derivedTitle)
        #expect(!text.body.contains("password"))
        conversation.customTitle = "Build\nstatus"
        #expect(AssistantNotificationContent.make(conversation, kind: .completed).title == "Build status")
    }

    private func request(secret: Bool = false, date: Date = .now) -> AgentUserInputRequest {
        .init(createdAt: date, questions: [.init(id: "q", prompt: "private-prompt", kind: secret ? .secret : .text)])
    }

    private func settle() async { for _ in 0..<30 { await Task.yield() } }
}

@MainActor private final class AssistantNotificationFixture {
    let conversation = ConversationModel()
    let sender = NotificationRecorder()
    var settings = NotificationPreferences()
    var focused = false
    lazy var coordinator = AssistantNotificationCoordinator(
        service: sender,
        preferences: { [unowned self] in settings }, isFocused: { [unowned self] _ in focused },
        content: AssistantNotificationContent.make)
    init() {
        settings.isEnabled = true
        coordinator.observe(conversation)
    }
}

@MainActor private final class NotificationRecorder: NotificationSending {
    var sent: [AppNotification] = []
    var removed: [String] = []
    var badgeCounts: [Int] = []
    func setBadgeCount(_ count: Int) { badgeCounts.append(count) }
    var hold = false
    var waiter: CheckedContinuation<Void, Never>?
    func authorization(request: Bool) async -> NotificationAuthorization { .allowed }
    func send(_ notification: AppNotification, ifCurrent: @escaping @MainActor () -> Bool) async {
        if hold { await withCheckedContinuation { waiter = $0 } }
        guard !Task.isCancelled, ifCurrent() else { return }
        sent.append(notification)
    }
    func remove(_ identifiers: [String]) { removed.append(contentsOf: identifiers) }
    func resume() {
        waiter?.resume()
        waiter = nil
    }
}