ChatThreadEntity.swift

//
//  ChatThreadEntity.swift
//  Slices Chat
//
//  AppEntity for ChatThread with search integration
//  Created by Williamson Quintero on 1/9/26.
//

import AppIntents
import Foundation
import SwiftData

/// AppEntity representing a chat thread for search and App Intents integration
struct ChatThreadEntity: AppEntity {
    
    // MARK: - AppEntity Requirements
    
    static var typeDisplayRepresentation = TypeDisplayRepresentation(
        name: "Chat Thread",
        numericFormat: "\(placeholder: .int) threads"
    )
    
    static var defaultQuery = ChatThreadQuery()
    
    // MARK: - Entity Properties
    
    var id: String
    
    @Property(title: "Title")
    var title: String
    
    @Property(title: "Last Message Preview")
    var lastMessagePreview: String?
    
    @Property(title: "Updated")
    var updatedAt: Date
    
    // MARK: - Display Representation
    
    var displayRepresentation: DisplayRepresentation {
        DisplayRepresentation(
            title: "\(title)",
            subtitle: lastMessagePreview.map { "\($0)" },
            image: .init(systemName: "bubble.left.and.bubble.right")
        )
    }
    
    // MARK: - Initialization
    
    init(id: String, title: String, lastMessagePreview: String?, updatedAt: Date) {
        self.id = id
        self.title = title
        self.lastMessagePreview = lastMessagePreview
        self.updatedAt = updatedAt
    }
    
    /// Create entity from SwiftData ChatThread
    init(from thread: ChatThread) {
        self.id = (thread.id ?? UUID()).uuidString
        self.title = thread.safeTitle
        self.lastMessagePreview = thread.lastMessageText
        self.updatedAt = thread.safeUpdatedAt
    }
}

// MARK: - Entity Query

struct ChatThreadQuery: EntityQuery, EntityStringQuery {
    
    /// Search threads by string query
    func entities(for identifiers: [String]) async throws -> [ChatThreadEntity] {
        return try await fetchThreads(with: identifiers)
    }
    
    /// Suggested entities (recent or pinned threads)
    func suggestedEntities() async throws -> [ChatThreadEntity] {
        return try await fetchRecentThreads(limit: 5)
    }
    
    /// Search by string (required by EntityStringQuery)
    func entities(matching string: String) async throws -> [ChatThreadEntity] {
        let searchTerm = string.lowercased()
        return try await searchThreads(by: [searchTerm])
    }
    
    // MARK: - Private Helpers
    
    @MainActor
    private func searchThreads(by terms: [String]) async throws -> [ChatThreadEntity] {
        // Get the model context from the app
        guard let modelContext = await getModelContext() else {
            return []
        }
        
        // Fetch all threads (you could optimize with predicates)
        let descriptor = FetchDescriptor<ChatThread>(
            sortBy: [SortDescriptor(\.updatedAt, order: .reverse)]
        )
        
        let allThreads = try modelContext.fetch(descriptor)
        
        // Filter threads that match any of the search terms
        let matchedThreads = allThreads.filter { thread in
            let title = thread.safeTitle.lowercased()
            let lastMessage = (thread.lastMessageText ?? "").lowercased()
            let systemPrompt = (thread.systemPrompt ?? "").lowercased()
            
            // Check if any term matches title, last message, or system prompt
            return terms.contains { term in
                title.contains(term) ||
                lastMessage.contains(term) ||
                systemPrompt.contains(term)
            }
        }
        
        // Limit results to be responsive
        let limitedThreads = Array(matchedThreads.prefix(10))
        
        return limitedThreads.map { ChatThreadEntity(from: $0) }
    }
    
    @MainActor
    private func fetchThreads(with ids: [String]) async throws -> [ChatThreadEntity] {
        guard let modelContext = await getModelContext() else {
            return []
        }
        
        let descriptor = FetchDescriptor<ChatThread>()
        let allThreads = try modelContext.fetch(descriptor)
        
        let matchedThreads = allThreads.filter { thread in
            guard let threadId = thread.id else { return false }
            return ids.contains(threadId.uuidString)
        }
        
        return matchedThreads.map { ChatThreadEntity(from: $0) }
    }
    
    @MainActor
    private func fetchRecentThreads(limit: Int) async throws -> [ChatThreadEntity] {
        guard let modelContext = await getModelContext() else {
            return []
        }
        
        let descriptor = FetchDescriptor<ChatThread>(
            sortBy: [SortDescriptor(\.updatedAt, order: .reverse)]
        )
        
        let threads = try modelContext.fetch(descriptor)
        let recentThreads = Array(threads.prefix(limit))
        
        return recentThreads.map { ChatThreadEntity(from: $0) }
    }
    
    @MainActor
    private func getModelContext() async -> ModelContext? {
        // Access the shared model container from your app
        return await PurpleChatApp.shared?.modelContainer.mainContext
    }
}
// MARK: - Transferable Conformance

/// Makes ChatThreadEntity available to Siri and system integrations
/// Provides plain text and JSON representations
extension ChatThreadEntity: Transferable {
    
    static var transferRepresentation: some TransferRepresentation {
        // Plain text representation for simple sharing
        DataRepresentation(exportedContentType: .plainText) { entity in
            let text = """
            Chat Thread: \(entity.title)
            Last Updated: \(entity.updatedAt.formatted())
            \(entity.lastMessagePreview.map { "Preview: \($0)" } ?? "")
            """
            return text.data(using: .utf8) ?? Data()
        }
        
        // JSON representation for structured data
        DataRepresentation(exportedContentType: .json) { entity in
            let json: [String: Any] = [
                "id": entity.id,
                "title": entity.title,
                "lastMessagePreview": entity.lastMessagePreview ?? "",
                "updatedAt": entity.updatedAt.timeIntervalSince1970
            ]
            return try JSONSerialization.data(withJSONObject: json)
        }
    }
}

// MARK: - Hashable Conformance
extension ChatThreadEntity: Hashable {
    func hash(into hasher: inout Hasher) {
        hasher.combine(id)
    }
    
    static func == (lhs: ChatThreadEntity, rhs: ChatThreadEntity) -> Bool {
        lhs.id == rhs.id
    }
}