Spanish/Conjuga/Conjuga/Services/PronunciationService.swift

import Foundation
import Speech
import AVFoundation

@MainActor
@Observable
final class PronunciationService {
    var isRecording = false
    var transcript = ""
    var isAuthorized = false

    private var recognizer: SFSpeechRecognizer?
    private var audioEngine: AVAudioEngine?
    private var request: SFSpeechAudioBufferRecognitionRequest?
    private var task: SFSpeechRecognitionTask?
    private var recognizerResolved = false

    func requestAuthorization() {
        // SFSpeechRecognizer.requestAuthorization crashes on simulators
        // without speech services. Check availability first.
        guard SFSpeechRecognizer.self != nil else { return }

        #if targetEnvironment(simulator)
        print("[PronunciationService] skipping speech auth on simulator")
        isAuthorized = false
        #else
        print("[PronunciationService] requesting speech authorization...")
        SFSpeechRecognizer.requestAuthorization { [weak self] status in
            print("[PronunciationService] authorization status: \(status.rawValue)")
            Task { @MainActor in
                self?.isAuthorized = (status == .authorized)
            }
        }
        #endif
    }

    private func resolveRecognizerIfNeeded() {
        guard !recognizerResolved else { return }
        recognizerResolved = true
        recognizer = SFSpeechRecognizer(locale: Locale(identifier: "es-ES"))
    }

    func startRecording() throws {
        guard isAuthorized else { return }
        resolveRecognizerIfNeeded()
        guard let recognizer, recognizer.isAvailable else { return }

        stopRecording()

        let audioSession = AVAudioSession.sharedInstance()
        try audioSession.setCategory(.playAndRecord, mode: .measurement, options: [.duckOthers, .defaultToSpeaker])
        try audioSession.setActive(true, options: .notifyOthersOnDeactivation)

        audioEngine = AVAudioEngine()
        request = SFSpeechAudioBufferRecognitionRequest()

        guard let audioEngine, let request else { return }
        request.shouldReportPartialResults = true

        let inputNode = audioEngine.inputNode
        let recordingFormat = inputNode.outputFormat(forBus: 0)

        inputNode.installTap(onBus: 0, bufferSize: 1024, format: recordingFormat) { buffer, _ in
            request.append(buffer)
        }

        audioEngine.prepare()
        try audioEngine.start()

        transcript = ""
        isRecording = true

        task = recognizer.recognitionTask(with: request) { [weak self] result, error in
            Task { @MainActor in
                if let result {
                    self?.transcript = result.bestTranscription.formattedString
                }
                if error != nil || (result?.isFinal == true) {
                    self?.stopRecording()
                }
            }
        }
    }

    func stopRecording() {
        audioEngine?.stop()
        audioEngine?.inputNode.removeTap(onBus: 0)
        request?.endAudio()
        task?.cancel()
        task = nil
        request = nil
        audioEngine = nil
        isRecording = false
    }

    /// Compare spoken transcript against expected text, returns matched word ratio (0.0-1.0).
    static func scoreMatch(expected: String, spoken: String) -> (score: Double, matches: [WordMatch]) {
        let expectedWords = expected.lowercased()
            .components(separatedBy: .whitespacesAndNewlines)
            .map { $0.trimmingCharacters(in: .punctuationCharacters) }
            .filter { !$0.isEmpty }

        let spokenWords = spoken.lowercased()
            .components(separatedBy: .whitespacesAndNewlines)
            .map { $0.trimmingCharacters(in: .punctuationCharacters) }
            .filter { !$0.isEmpty }

        let spokenSet = Set(spokenWords)
        var matches: [WordMatch] = []

        for word in expectedWords {
            matches.append(WordMatch(word: word, matched: spokenSet.contains(word)))
        }

        let matchCount = matches.filter(\.matched).count
        let score = expectedWords.isEmpty ? 0 : Double(matchCount) / Double(expectedWords.count)
        return (score, matches)
    }

    struct WordMatch: Identifiable {
        let word: String
        let matched: Bool
        var id: String { word }
    }
}