import PrismIntelligence

let sentiment = PrismNLPActions.analyzeSentiment("I absolutely love this product!")
// .positive

let mixed = PrismNLPActions.analyzeSentiment("The design is great but the battery is terrible")
// .mixed

import PrismIntelligence

let text = "Tim Cook announced the new iPhone at Apple Park on June 9th."
let entities = PrismNLPActions.extractEntities(text)

for entity in entities {
    print("\(entity.type): \(entity.text)")
}
// person: Tim Cook
// organization: Apple
// place: Apple Park
// date: June 9th

import PrismIntelligence

let store = PrismEmbeddingStore()

// Add embeddings
await store.add(PrismEmbedding(
    id: "doc-1",
    vector: [0.1, 0.8, 0.3, 0.5],
    metadata: ["title": "Swift Concurrency Guide"]
))

await store.add(PrismEmbedding(
    id: "doc-2",
    vector: [0.9, 0.2, 0.1, 0.4],
    metadata: ["title": "SwiftUI Layout System"]
))

await store.add(PrismEmbedding(
    id: "doc-3",
    vector: [0.15, 0.75, 0.35, 0.45],
    metadata: ["title": "Async/Await Patterns"]
))

// Search by similarity
let results = await store.search(
    query: [0.12, 0.78, 0.32, 0.48],
    topK: 2
)

for result in results {
    print("\(result.embedding.id): \(result.similarity)")
}
// doc-3: 0.998
// doc-1: 0.995

import PrismIntelligence

let chunker = PrismTextChunker()
let longText = "Swift is a powerful programming language..."

let chunks = chunker.chunk(longText, size: 500, overlap: 50)
// Each chunk is ~500 characters with 50-character overlap between neighbors

import PrismIntelligence

let config = PrismRAGConfig(
    chunkSize: 500,    // Characters per chunk
    overlapSize: 50,   // Overlap between chunks
    topK: 3            // Number of results to retrieve
)

let response = PrismRAGResponse(
    answer: "Swift concurrency uses structured concurrency...",
    sources: ["Chapter 3: ...", "Chapter 5: ..."],
    confidence: 0.87
)

print(response.answer)
print("Sources: \(response.sources.count)")
print("Confidence: \(response.confidence)")

import PrismIntelligence

let parser = PrismStructuredParser()

// Extract JSON from mixed text
let text = """
Here's the data you requested:
{"name": "Alice", "age": 30, "role": "engineer"}
Let me know if you need more.
"""

struct Person: Decodable {
    let name: String
    let age: Int
    let role: String
}

if let person: Person = parser.parse(text, as: Person.self) {
    print(person.name) // Alice
}

let raw = "The results are: [1, 2, 3] and that's all."
let json = parser.extractJSON(raw)
// "[1, 2, 3]"

let report = """
Name: Alice Johnson
Role: Senior Engineer
Team: Platform
Start Date: 2023-01-15
"""

let pairs = parser.extractKeyValues(report)
// ["Name": "Alice Johnson", "Role": "Senior Engineer",
//  "Team": "Platform", "Start Date": "2023-01-15"]

import PrismIntelligence

// 1. Configure the pipeline
let config = PrismRAGConfig(chunkSize: 300, overlapSize: 30, topK: 3)
let chunker = PrismTextChunker()
let store = PrismEmbeddingStore()

// 2. Ingest documents
let documents = [
    "Swift concurrency introduces structured concurrency with async/await...",
    "Actors in Swift provide data isolation for concurrent access...",
    "Task groups allow spawning multiple child tasks that run concurrently..."
]

for (index, doc) in documents.enumerated() {
    let chunks = chunker.chunk(doc, size: config.chunkSize, overlap: config.overlapSize)
    for (chunkIndex, chunk) in chunks.enumerated() {
        // In production, generate real embeddings from a model
        let embedding = PrismEmbedding(
            id: "doc-\(index)-chunk-\(chunkIndex)",
            vector: generateEmbedding(chunk),
            metadata: ["source": "doc-\(index)", "text": chunk]
        )
        await store.add(embedding)
    }
}

// 3. Query
let queryVector = generateEmbedding("How do actors work in Swift?")
let results = await store.search(query: queryVector, topK: config.topK)

// 4. Build context from retrieved chunks
let context = results.map { $0.embedding.metadata["text"] ?? "" }
    .joined(separator: "\n\n")

print("Retrieved \(results.count) chunks")
print("Top similarity: \(results.first?.similarity ?? 0)")

// 5. Analyze sentiment of the query
let sentiment = PrismNLPActions.analyzeSentiment("How do actors work in Swift?")
print("Query sentiment: \(sentiment)") // .neutral