FoundationModels

import FoundationModels

let model = SystemLanguageModel.default

switch model.availability {
case .available:
    // 可以用
    break
case .unavailable(let reason):
    switch reason {
    case .deviceNotEligible:
        // 设备不支持Apple Intelligence
        break
    case .appleIntelligenceNotEnabled:
        // 用户未启用
        break
    case .modelNotReady:
        // 模型正在下载或准备中
        break
    @unknown default:
        break
    }
}

import FoundationModels

let session = LanguageModelSession()
let response = try await session.respond(to: "用一句话介绍Swift")
print(response.content)

let session = LanguageModelSession()
_ = try await session.respond(to: "你是一个iOS面试官")
let answer = try await session.respond(to: "请出一道关于weak的题")
// 第二轮调用会携带第一轮的上下文

let session = LanguageModelSession(
    instructions: Instructions("""
    你是一个简洁的iOS助手。
    规则：
    - 回答不超过2句话
    - 使用中文
    - 避免冗长的前缀
    """)
)

let answer = try await session.respond(to: "什么是ARC？")

let options = GenerationOptions(
    temperature: 0.2,         // 低温度→稳定、确定性
    sampling: .topP(0.9),     // nucleus sampling
    maximumResponseTokens: 200
)

let response = try await session.respond(
    to: "列出Swift的值类型",
    options: options
)

import FoundationModels

@Generable
struct Recipe {
    @Guide(description: "菜名")
    let name: String

    @Guide(description: "大致所需分钟数", .range(5...180))
    let minutes: Int

    @Guide(description: "食材清单")
    let ingredients: [Ingredient]

    @Guide(description: "步骤说明，按顺序")
    let steps: [String]
}

@Generable
struct Ingredient {
    let name: String

    @Guide(description: "数量，可为浮点")
    let amount: Double

    @Guide(description: "计量单位", .anyOf(["g", "ml", "个", "勺"]))
    let unit: String
}

let response = try await session.respond(
    to: "给我一个30分钟能做好的番茄意面菜谱",
    generating: Recipe.self
)

let recipe: Recipe = response.content
print(recipe.name)
print(recipe.ingredients.map { $0.name })

@Generable
enum Priority: String, CaseIterable {
    case low, medium, high
}

@Generable
struct Todo {
    @Guide(description: "事项标题", .pattern("^.{1,50}$"))
    let title: String

    let priority: Priority    // 枚举天然带候选集

    @Guide(description: "截止日期，YYYY-MM-DD")
    let dueDate: String

    @Guide(description: "最多5个tag", .count(0...5))
    let tags: [String]
}

@Generable
struct SearchResult {
    let query: String
    let items: [Item]
    let suggestion: String?
}

@Generable
struct Item {
    let title: String
    let score: Double
}

import FoundationModels

struct WeatherTool: Tool {
    let name = "get_weather"
    let description = "获取指定城市的当前天气"

    @Generable
    struct Arguments {
        @Guide(description: "城市名，例如：北京、上海")
        let city: String
    }

    func call(arguments: Arguments) async throws -> ToolOutput {
        let data = try await WeatherAPI.fetch(city: arguments.city)
        return ToolOutput(data.summary) // 也可以返回自定义Generable
    }
}

let session = LanguageModelSession(
    tools: [WeatherTool(), ClockTool()],
    instructions: Instructions("你是一个本地生活助手，能查天气、报时间。")
)

let answer = try await session.respond(to: "明天北京会下雨吗？")

let stream = session.streamResponse(to: "写一首关于iOS的打油诗")

for try await partial in stream {
    // partial 是当前累积的字符串（每次都是完整的快照，不是增量）
    await MainActor.run {
        self.text = partial
    }
}

let stream = session.streamResponse(
    to: "给我一个番茄意面菜谱",
    generating: Recipe.self
)

for try await partial in stream {
    // partial: Recipe.PartiallyGenerated
    // 此时 name 可能已经有了，steps 可能只有前两步
    if let name = partial.name {
        self.recipeName = name
    }
    self.ingredients = partial.ingredients ?? []
    self.steps = partial.steps ?? []
}

@Observable
final class RecipeViewModel {
    var partial: Recipe.PartiallyGenerated?
    var isRunning = false

    private let session = LanguageModelSession()

    func generate(_ prompt: String) async {
        isRunning = true
        defer { isRunning = false }
        do {
            let stream = session.streamResponse(to: prompt, generating: Recipe.self)
            for try await value in stream {
                partial = value
            }
        } catch {
            // 处理错误
        }
    }
}

for entry in session.transcript {
    switch entry {
    case .instructions(let i):   print("SYS:", i.segments.map(\.text).joined())
    case .prompt(let p):         print("USR:", p.segments.map(\.text).joined())
    case .response(let r):       print("AST:", r.segments.map(\.text).joined())
    case .toolCalls(let c):      print("TOOL call:", c)
    case .toolOutput(let o):     print("TOOL out:", o)
    @unknown default:            break
    }
}

do {
    let answer = try await session.respond(to: userInput)
} catch let error as LanguageModelSession.GenerationError {
    switch error {
    case .guardrailViolation:
        // 被安全策略拦截
        showFallback()
    case .exceededContextWindowSize:
        // 超出上下文
        trimAndRetry()
    case .unsupportedLanguageOrLocale:
        break
    case .assetsUnavailable:
        break
    @unknown default:
        break
    }
}

let model = try SystemLanguageModel(adapter: .init(name: "LegalQA"))
let session = LanguageModelSession(model: model)

// App冷启动后、进入AI功能页面前调用
await session.prewarm()

import FoundationModels

@Generable
struct Todo {
    @Guide(description: "简短标题，<= 30字")
    let title: String

    @Guide(description: "优先级")
    let priority: Priority

    @Guide(description: "提醒时间，ISO 8601格式")
    let reminderAt: String?

    @Guide(description: "标签，最多3个", .count(0...3))
    let tags: [String]
}

@Generable
enum Priority: String, CaseIterable {
    case low, medium, high
}

@Observable
final class TodoParser {
    private let session: LanguageModelSession

    init() {
        self.session = LanguageModelSession(
            instructions: Instructions("""
            你是一个待办事项解析器。
            - 从用户的自然语言中抽取Todo字段
            - 当前时间：\(ISO8601DateFormatter().string(from: Date()))
            - 识别"明天""下周一""今晚"等相对时间，并转成绝对时间
            - 如果无法判断优先级，默认为medium
            - 只抽取用户明确表达的标签
            """)
        )
    }

    func parse(_ text: String) async throws -> Todo {
        let response = try await session.respond(
            to: text,
            generating: Todo.self,
            options: GenerationOptions(temperature: 0.1)
        )
        return response.content
    }
}

struct TodoInputView: View {
    @State private var text = ""
    @State private var parsed: Todo?
    @State private var isParsing = false
    private let parser = TodoParser()

    var body: some View {
        VStack(alignment: .leading, spacing: 12) {
            TextField("随手写点什么…", text: $text, axis: .vertical)
                .textFieldStyle(.roundedBorder)

            Button("解析") {
                Task {
                    isParsing = true
                    parsed = try? await parser.parse(text)
                    isParsing = false
                }
            }
            .disabled(text.isEmpty || isParsing)

            if let todo = parsed {
                VStack(alignment: .leading) {
                    Text(todo.title).font(.headline)
                    Text("优先级：\(todo.priority.rawValue)")
                    if let time = todo.reminderAt {
                        Text("提醒：\(time)")
                    }
                    if !todo.tags.isEmpty {
                        Text("标签：\(todo.tags.joined(separator: ", "))")
                    }
                }
            }
        }
        .padding()
    }
}

do {
    _ = try await session.respond(to: prompt, generating: Todo.self)
} catch let error as LanguageModelSession.GenerationError {
    switch error {
    case .guardrailViolation:        handleBlocked()
    case .exceededContextWindowSize: handleContextOverflow()
    case .unsupportedLanguageOrLocale: handleLocale()
    case .assetsUnavailable:         handleNotReady()
    case .decodingFailure:           handleDecode()
    @unknown default:                handleUnknown()
    }
} catch {
    // 网络/IO/Tool内部错误等
}