@preconcurrency import AVFoundation
import Foundation
import OSLog

private let logger = Logger(subsystem: AppIdentifiers.subsystem, category: "DictationProvider")

/// Voice transcription provider that streams audio to the Oppi server.
///
/// Dictation uses the server-level `/dictation/stream` WebSocket directly.
@MainActor
final class OppiDictationProvider: VoiceTranscriptionProvider {
    nonisolated let id: VoiceProviderID = .oppiServer
    nonisolated let engine: VoiceInputManager.TranscriptionEngine = .serverDictation

    /// Per-recording message stream. Created in `prepareSession`, consumed by the session.
    private var activeRecordingMessages: AsyncStream<ServerMessage>?
    /// Continuation for feeding dictation messages into the recording stream.
    private var activeRecordingContinuation: AsyncStream<ServerMessage>.Continuation?
    /// Background task that sends `dictation_start` and awaits `dictation_ready`.
    private var activeReadinessTask: Task<DictationProviderInfo?, Error>?
    private var preparationTask: Task<Void, Never>?
    /// Task consuming the active dictation transport.
    private var dictationRouteTask: Task<Void, Never>?
    private var activeTransport: (any DictationTransport)?

#if DEBUG
    var _makeDictationTransportForTesting: (() -> (transport: any DictationTransport, messages: AsyncStream<ServerMessage>))?
#endif

    func invalidateCache() {
        activeReadinessTask?.cancel()
        activeReadinessTask = nil
        stopDictationRouting()
    }

    func cancelPreparation() {
        preparationTask?.cancel()
        preparationTask = nil
        activeReadinessTask?.cancel()
        activeReadinessTask = nil
        stopDictationRouting()
    }

    func prewarm(context _: VoiceProviderContext) async throws {
        // No warm connection: dictation opens its ASR stream on demand.
    }

    func prepareSession(context: VoiceProviderContext) async throws -> VoiceProviderPreparation {
        guard context.serverCredentials != nil else {
            throw VoiceInputError.serverNotConnected
        }
        guard let connection = context.serverConnection else {
            throw VoiceInputError.serverNotConnected
        }

        let transport: any DictationTransport
        let messageStream: AsyncStream<ServerMessage>
#if DEBUG
        if let makeDictationTransport = _makeDictationTransportForTesting {
            let prepared = makeDictationTransport()
            transport = prepared.transport
            messageStream = prepared.messages
        } else {
            guard let client = connection.makeDictationStreamClient() else {
                throw VoiceInputError.serverNotConnected
            }
            transport = client
            messageStream = client.connect()
        }
#else
        guard let client = connection.makeDictationStreamClient() else {
            throw VoiceInputError.serverNotConnected
        }
        transport = client
        messageStream = client.connect()
#endif
        stopDictationRouting()
        activeTransport = transport

        // Subscribe to dictation messages before creating the recording stream.
        startDictationRouting(messages: messageStream)

        // Create a fresh per-recording message stream.
        let (recordingStream, recordingContinuation) = AsyncStream.makeStream(of: ServerMessage.self)
        self.activeRecordingMessages = recordingStream
        self.activeRecordingContinuation = recordingContinuation

        // Fire readiness in the background. The session awaits this task before
        // flushing buffered audio, so the UI transitions to .recording immediately
        // while the server-side ASR setup completes (~one RTT).
        let readinessTask: Task<DictationProviderInfo?, Error> = Task {
            try await transport.sendDictation(
                .dictationStart(
                    contextualStrings: DictationContextualStrings.prepared(context.contextualStrings)
                )
            )

            // Wait for dictation_ready to arrive in the recording stream.
            // The message routing task yields it; we consume a copy here.
            let info = try await waitForReady(timeout: .seconds(10))
            logger.info(
                "Dictation recording ready (stt=\(info?.sttProvider ?? "unknown", privacy: .public), model=\(info?.sttModel ?? "unknown", privacy: .public))"
            )
            return info
        }
        self.activeReadinessTask = readinessTask

        return VoiceProviderPreparation(
            audioFormat: nil,
            modelPath: .dictationAudioWs,
            provider: Self.providerTelemetry()
        )
    }

    /// Wait for `dictation_ready` from the server by monitoring the dictation subscription.
    /// Uses a continuation that the routing task resolves when it sees `.dictationReady`.
    private var readyContinuation: CheckedContinuation<DictationProviderInfo?, Error>?
    private var readyTimeoutTask: Task<Void, Never>?
    private var routingFailure: Error?

    private func waitForReady(timeout: Duration) async throws -> DictationProviderInfo? {
        try Task.checkCancellation()
        if let routingFailure { throw routingFailure }
        return try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<DictationProviderInfo?, Error>) in
            readyContinuation = continuation

            readyTimeoutTask = Task { [weak self] in
                do { try await Task.sleep(for: timeout) } catch { return }
                guard let self, let cont = self.readyContinuation else { return }
                self.readyContinuation = nil
                cont.resume(throwing: VoiceInputError.remoteRequestTimedOut)
            }
        }
    }

    /// Start a task that consumes dictation messages from the active transport
    /// and forwards them to the per-recording stream + resolves readiness.
    private func startDictationRouting(messages: AsyncStream<ServerMessage>) {
        routingFailure = nil
        dictationRouteTask = Task { [weak self] in
            for await message in messages {
                guard !Task.isCancelled, let self else { break }

                // Resolve readiness if waiting
                if case .dictationReady(let provider, _) = message {
                    readyTimeoutTask?.cancel()
                    readyTimeoutTask = nil
                    if let cont = readyContinuation {
                        readyContinuation = nil
                        cont.resume(returning: provider)
                    }
                }

                // Resolve readiness on fatal error too
                if case .dictationError(_, let fatal) = message, fatal {
                    readyTimeoutTask?.cancel()
                    readyTimeoutTask = nil
                    if let cont = readyContinuation {
                        readyContinuation = nil
                        let errorMsg: String
                        if case .dictationError(let e, _) = message { errorMsg = e } else { errorMsg = "Unknown" }
                        cont.resume(throwing: VoiceInputError.internalError("Server: \(errorMsg)"))
                    }
                }

                // Forward to recording stream
                activeRecordingContinuation?.yield(message)

                // dictation_final ends this recording's stream
                if case .dictationFinal = message {
                    activeRecordingContinuation?.finish()
                    activeRecordingContinuation = nil
                    activeRecordingMessages = nil
                }
            }
            // Cancellation belongs to stopDictationRouting (possibly an older
            // take). Only a live route may terminate its recording on upstream EOF.
            guard !Task.isCancelled, let self else { return }
            let error = VoiceInputError.internalError("Dictation connection lost")
            routingFailure = error
            readyTimeoutTask?.cancel()
            readyTimeoutTask = nil
            if let cont = readyContinuation {
                readyContinuation = nil
                cont.resume(throwing: error)
            }
            activeRecordingContinuation?.finish()
            activeRecordingContinuation = nil
        }
    }

    private func stopDictationRouting() {
        dictationRouteTask?.cancel()
        dictationRouteTask = nil
        activeRecordingContinuation?.finish()
        activeRecordingContinuation = nil
        activeRecordingMessages = nil
        readyTimeoutTask?.cancel()
        readyTimeoutTask = nil
        activeTransport?.closeDictationTransport()
        activeTransport = nil
        if let cont = readyContinuation {
            readyContinuation = nil
            cont.resume(throwing: VoiceInputError.internalError("Dictation routing stopped"))
        }
    }

    // MARK: - Telemetry

    /// The backend is resolved once the server reports readiness, so setup
    /// reports `unknown` and `.sttResolved` fills in the real values later.
    private static func providerTelemetry() -> VoiceProviderTelemetry {
        VoiceProviderTelemetry(
            sttProvider: "oppi_server_dictation",
            sttProviderKind: .localServer,
            sttBackend: TelemetryName.fallback,
            sttModel: TelemetryName.fallback
        )
    }

    func makeSession(
        context: VoiceProviderContext,
        preparation _: VoiceProviderPreparation
    ) throws -> any VoiceTranscriptionSession {
        guard context.serverConnection != nil else {
            throw VoiceInputError.serverNotConnected
        }
        guard let readinessTask = activeReadinessTask else {
            throw VoiceInputError.internalError("Dictation readiness task not prepared")
        }
        guard let recordingMessages = activeRecordingMessages else {
            throw VoiceInputError.internalError("Dictation recording messages not prepared")
        }
        guard let transport = activeTransport else {
            throw VoiceInputError.internalError("Dictation transport not prepared")
        }
        // Clear per-recording state — session now owns these.
        activeReadinessTask = nil
        activeRecordingMessages = nil
        activeTransport = nil
        return OppiDictationSession(
            transport: transport,
            readinessTask: readinessTask,
            messages: recordingMessages
        )
    }

}
