import SwiftUI
import AVFoundation
import Combine

// MARK: - 1. 資料模型
struct ChatMessage: Identifiable, Equatable {
    let id = UUID()
    var content: String // 改為 var 以便動態追加文字
    let isUser: Bool
}

struct OllamaRequest: Encodable {
    let model: String
    let messages: [OllamaMessage]
    let stream: Bool
}

struct OllamaMessage: Codable {
    let role: String
    let content: String
}

// 串流回應的結構 (Ollama 回傳的是一行行的 JSON)
struct OllamaStreamResponse: Decodable {
    let message: OllamaMessage?
    let done: Bool
}

// MARK: - 2. 語音管理器 (支援串流斷句)
class SpeechManager: ObservableObject {
    private let synthesizer = AVSpeechSynthesizer()
    private var sentenceBuffer: String = "" // 用來暫存還沒唸的文字
    
    @Published var isMuted: Bool = false
    
    // 定義句子的結束符號 (句號、問號、驚嘆號、換行)
    private let delimiters: CharacterSet = CharacterSet(charactersIn: "。！？!?\n")
    
    /// 處理串流進來的文字片段
    func processStream(_ token: String) {
        if isMuted { return }
        
        sentenceBuffer += token
        
        // 檢查暫存區是否包含結束符號
        if let _ = sentenceBuffer.rangeOfCharacter(from: delimiters) {
            // 嘗試分割句子
            speakBufferedSentences()
        }
    }
    
    /// 串流結束時，強制唸出剩下的文字
    func flush() {
        if !sentenceBuffer.isEmpty {
            speak(sentenceBuffer)
            sentenceBuffer = ""
        }
    }
    
    /// 內部邏輯：切分句子並朗讀
    private func speakBufferedSentences() {
        // 這裡做簡單的切割：只要遇到標點符號就切斷
        // 為了避免複雜的 Regex，我們逐字元檢查，或是簡單地 split
        // 這裡採用簡單策略：如果 buffer 裡有標點，就把標點前的內容拿去唸
        
        var content = sentenceBuffer
        
        // 簡單迴圈：只要字串裡還有標點，就一直切出來唸
        while let range = content.rangeOfCharacter(from: delimiters) {
            // 切割出第一句 (包含標點)
            let endIndex = range.upperBound
            let sentence = String(content[..<endIndex])
            
            // 唸出來
            speak(sentence)
            
            // 剩下的放回 content 繼續處理
            content = String(content[endIndex...])
        }
        
        // 更新 buffer 為剩下還沒唸的片段
        sentenceBuffer = content
    }
    
    /// 執行朗讀動作
    private func speak(_ text: String) {
        let cleanText = text.trimmingCharacters(in: .whitespacesAndNewlines)
        guard !cleanText.isEmpty else { return }
        
        let utterance = AVSpeechUtterance(string: cleanText)
        utterance.rate = 0.52 // 稍微加快一點點，配合串流速度
        
        // 指定男性聲音
        let allVoices = AVSpeechSynthesisVoice.speechVoices()
        if let maleVoice = allVoices.first(where: { $0.language == "zh-TW" && $0.gender == .male }) {
            utterance.voice = maleVoice
        } else {
            utterance.voice = AVSpeechSynthesisVoice(language: "zh-TW")
        }
        
        // AVSpeechSynthesizer 自動會把這句加入佇列 (Queue)，講完上一句會接著講這句
        synthesizer.speak(utterance)
    }
    
    func stop() {
        synthesizer.stopSpeaking(at: .immediate)
        sentenceBuffer = "" // 清空暫存
    }
}

// MARK: - 3. 主視圖
struct ContentView: View {
    @State private var inputText: String = ""
    @State private var messages: [ChatMessage] = []
    @State private var isLoading: Bool = false
    
    @StateObject private var speechManager = SpeechManager()
    
    private let modelName = "gemma3:4b"
    
    // 嚴格版系統提示詞
    private let systemPrompt = "你是一個嚴肅的專業助理，請全程使用繁體中文（台灣）。【絕對禁止】嚴格禁止使用任何表情符號（Emoji）、顏文字或圖示。回答時請保持語氣冷靜、直接且不帶情緒，僅輸出純文字內容。"
    
    var body: some View {
        ZStack {
            Color(red: 0.1, green: 0.1, blue: 0.12).ignoresSafeArea()
            
            VStack(spacing: 0) {
                // Header
                HStack {
                    Text("Ollama Stream")
                        .font(.headline)
                        .foregroundColor(.gray)
                    Spacer()
                    Button(action: {
                        speechManager.isMuted.toggle()
                        if speechManager.isMuted { speechManager.stop() }
                    }) {
                        Image(systemName: speechManager.isMuted ? "speaker.slash.fill" : "speaker.wave.2.fill")
                            .foregroundColor(speechManager.isMuted ? .gray : .purple)
                            .padding(8)
                            .background(Color.black.opacity(0.3))
                            .clipShape(Circle())
                    }
                    .help(speechManager.isMuted ? "開啟語音" : "靜音")
                    
                    Text(modelName)
                        .font(.caption)
                        .padding(6)
                        .background(Color.purple.opacity(0.3))
                        .cornerRadius(8)
                        .foregroundColor(.purple)
                }
                .padding()
                .background(Color.black.opacity(0.5))
                
                // Messages Area
                ScrollViewReader { proxy in
                    ScrollView {
                        LazyVStack(spacing: 12) {
                            ForEach(messages) { msg in
                                MessageBubble(message: msg)
                            }
                            // 移除原本的 Loading Indicator，因為現在文字會直接出現
                        }
                        .padding()
                    }
                    // 監聽陣列最後一個元素的內容變化，以實現即時捲動
                    .onChange(of: messages.last?.content) { _, _ in
                         if let lastId = messages.last?.id {
                             proxy.scrollTo(lastId, anchor: .bottom)
                         }
                    }
                    // 也要監聽陣列本身的變化(新增訊息時)
                    .onChange(of: messages.count) { _, _ in
                        if let lastId = messages.last?.id {
                            proxy.scrollTo(lastId, anchor: .bottom)
                        }
                    }
                }
                
                // Input Area
                HStack(spacing: 10) {
                    TextField("", text: $inputText)
                        .padding(10)
                        .background(Color(white: 0.2))
                        .cornerRadius(20)
                        .foregroundColor(.white)
                        .onSubmit {
                            startStreaming()
                        }
                    
                    Button(action: startStreaming) {
                        Image(systemName: "paperplane.fill")
                            .font(.system(size: 20))
                            .foregroundColor(inputText.isEmpty ? .gray : .purple)
                            .padding(10)
                            .background(Color(white: 0.2))
                            .clipShape(Circle())
                    }
                    .disabled(inputText.isEmpty || isLoading)
                }
                .padding()
                .background(Color.black.opacity(0.8))
            }
        }
        .preferredColorScheme(.dark)
    }
    
    // MARK: - 4. 串流邏輯核心
    func startStreaming() {
        let cleanInput = inputText.trimmingCharacters(in: .whitespacesAndNewlines)
        guard !cleanInput.isEmpty else { return }
        
        speechManager.stop()
        
        let userMsg = cleanInput
        inputText = ""
        
        // 1. UI 顯示使用者訊息
        messages.append(ChatMessage(content: userMsg, isUser: true))
        
        // 2. 預先建立一個空的 AI 訊息，等等要一點一點填入內容
        let aiMsgId = UUID()
        messages.append(ChatMessage(content: "", isUser: false))
        
        isLoading = true
        
        // 使用 Task 進行非同步操作
        Task {
            await streamResponse(userMessage: userMsg)
        }
    }
    
    func streamResponse(userMessage: String) async {
        guard let url = URL(string: "http://127.0.0.1:11434/api/chat") else { return }
        
        let apiMessages = [
            OllamaMessage(role: "system", content: systemPrompt),
            OllamaMessage(role: "user", content: userMessage)
        ]
        
        // 設定 stream 為 true
        let requestBody = OllamaRequest(
            model: modelName,
            messages: apiMessages,
            stream: true
        )
        
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.httpBody = try? JSONEncoder().encode(requestBody)
        
        do {
            // 使用 URLSession 的 bytes 方法來讀取串流
            let (result, _) = try await URLSession.shared.bytes(for: request)
            
            // 逐行讀取回傳的資料
            for try await line in result.lines {
                // 解析每一行的 JSON
                if let data = line.data(using: .utf8),
                   let response = try? JSONDecoder().decode(OllamaStreamResponse.self, from: data) {
                    
                    if response.done {
                        // 結束時，把語音緩衝區剩下的字唸完
                        await MainActor.run {
                            speechManager.flush()
                            isLoading = false
                        }
                        break
                    }
                    
                    if let content = response.message?.content {
                        // 1. 更新 UI (必須在 Main Thread)
                        await MainActor.run {
                            // 找到最後一則訊息 (也就是 AI 那則)，追加文字
                            if let index = messages.indices.last {
                                messages[index].content += content
                            }
                            
                            // 2. 送給語音管理器處理 (它會自己判斷要不要唸)
                            speechManager.processStream(content)
                        }
                    }
                }
            }
        } catch {
            await MainActor.run {
                if let index = messages.indices.last {
                    messages[index].content += "\n[連線錯誤: \(error.localizedDescription)]"
                }
                isLoading = false
            }
        }
    }
}

// MARK: - 5. UI 元件
struct MessageBubble: View {
    let message: ChatMessage
    
    var body: some View {
        HStack(alignment: .top) { // 改為 top 對齊，長文比較好看
            if message.isUser { Spacer() }
            
            Text(message.content)
                .padding(12)
                .background(message.isUser ? Color.purple : Color(white: 0.2))
                .foregroundColor(.white)
                .cornerRadius(16)
                .frame(maxWidth: 300, alignment: message.isUser ? .trailing : .leading)
                .textSelection(.enabled)
                // 為了讓打字機效果看起來順暢，這裡可以加一點動畫，但在串流頻率高時可能會閃爍，故保持原樣
            
            if !message.isUser { Spacer() }
        }
    }
}

#Preview {
    ContentView()
}