import NaturalLanguage
 
/// Loads a contextual (transformer-based) embedding model for a language,
/// downloading the on-device assets on first use if they are not cached yet.
func makeContextualEmbedding(for language: NLLanguage) throws -> NLContextualEmbedding? {
    guard let embedding = NLContextualEmbedding(language: language) else {
        return nil // No contextual model ships for this language/script
    }
 
    if !embedding.hasAvailableAssets {
        let group = DispatchGroup()
        group.enter()
        embedding.requestAssets { _, _ in group.leave() }
        group.wait()
    }
 
    try embedding.load()
    return embedding
}
 
/// Produces one fixed-length vector for a whole sentence by mean-pooling
/// the subword token vectors that NLContextualEmbedding returns.
func sentenceVector(
    for text: String,
    embedding: NLContextualEmbedding,
    language: NLLanguage
) throws -> [Double] {
    let result = try embedding.embeddingResult(for: text, language: language)
    var sum = [Double](repeating: 0, count: embedding.dimension)
    var tokenCount = 0
 
    result.enumerateTokenVectors(in: text.startIndex..<text.endIndex) { vector, _ in
        for i in 0..<vector.count { sum[i] += vector[i] }
        tokenCount += 1
        return true // keep iterating
    }
 
    guard tokenCount > 0 else { return sum }
    return sum.map { $0 / Double(tokenCount) }
}

/// Cosine similarity between two vectors.
/// 1.0 = same direction (same meaning), 0.0 = unrelated, -1.0 = opposite.
func cosineSimilarity(_ a: [Double], _ b: [Double]) -> Double {
    guard a.count == b.count, !a.isEmpty else { return 0 }
 
    var dot = 0.0
    var normA = 0.0
    var normB = 0.0
 
    for i in 0..<a.count {
        dot += a[i] * b[i]
        normA += a[i] * a[i]
        normB += b[i] * b[i]
    }
 
    guard normA > 0, normB > 0 else { return 0 }
    return dot / (normA.squareRoot() * normB.squareRoot())
}

/// A diary entry paired with its precomputed semantic vector.
struct IndexedEntry {
    let id: UUID
    let text: String
    let vector: [Double]
}
 
/// Builds an in-memory semantic index for a set of entries.
/// In a real app this runs once per entry, on save — never on every search.
final class SemanticEntryIndex {
    private var embedding: NLContextualEmbedding?
    private let language: NLLanguage
    private(set) var entries: [IndexedEntry] = []
 
    init(language: NLLanguage = .russian) {
        self.language = language
    }
 
    func prepare() throws {
        embedding = try makeContextualEmbedding(for: language)
    }
 
    func index(id: UUID, text: String) throws {
        guard let embedding else { return }
        let vector = try sentenceVector(for: text, embedding: embedding, language: language)
        entries.append(IndexedEntry(id: id, text: text, vector: vector))
    }
}

/// Returns entries closest in meaning to `query`, best match first.
func semanticSearch(
    query: String,
    in index: SemanticEntryIndex,
    embedding: NLContextualEmbedding,
    language: NLLanguage,
    limit: Int = 10
) throws -> [(entry: IndexedEntry, score: Double)] {
    let queryVector = try sentenceVector(for: query, embedding: embedding, language: language)
 
    return index.entries
        .map { entry in (entry: entry, score: cosineSimilarity(queryVector, entry.vector)) }
        .sorted { $0.score > $1.score }
        .prefix(limit)
        .map { $0 }
}