import Foundation

@MainActor
final class ChatStore: ObservableObject {
    @Published var conversations: [HopeConversation] = []
    @Published var workspaces: [HopeWorkspace] = []
    @Published var preferences = HopePreferences()
    @Published var selected: HopeConversation?
    @Published var messages: [HopeMessage] = []
    @Published var runs: [HopeRun] = []
    @Published var draft = ""
    @Published var error: String?
    @Published var progress: String?
    @Published var busy = false
    @Published var searching = false
    @Published var nextCursor: String?
    @Published var olderMessagesCursor: String?
    private var currentQuery = ""
    private var currentArchived = false
    private var currentWorkspace: String?
    @Published private(set) var mutatingConversationIds: Set<String> = []
    private(set) var draftGeneration = 0
    private var searchGeneration = 0
    @Published var approval: (id: String, prompt: String)?
    @Published var researchAvailable = false
    @Published var research = false
    @Published var exportText: String?
    @Published var exportFile: PrivateChatExport?
    private var syncCursor = 0
    private var syncTask: Task<Void, Never>?
    @Published var model = ""
    @Published var thinkingLevel = ""
    @Published var models: [ChatModelChoice] = []
    @Published var modelNote: String?
    let features: ChatFeatureStore
    @Published var selectedAttachmentIds: Set<String> = []
    private var queuedAttachments: [String: ChatAttachment] = [:]
    var canSendAttachments: Bool {
        guard !closed else { return false }
        if selectedAttachmentIds.isEmpty { return true }
        guard features.enabled.contains("attachments"), selectedAttachmentIds.count <= 8 else { return false }
        return selectedAttachmentIds.allSatisfy { id in
            guard let attachment = queuedAttachments[id] ?? features.attachments.first(where: { $0.id == id }) else { return false }
            return attachmentEligible(attachment)
        }
    }
    private func attachmentEligible(_ attachment: ChatAttachment) -> Bool {
        let image = ["image/png", "image/jpeg", "image/webp"].contains(attachment.mime)
        let document = ["text/plain", "text/markdown", "application/pdf"].contains(attachment.mime)
        return (image && attachment.extractionStatus == "image" && features.enabled.contains("image_input")) ||
            (document && ["ready", "truncated"].contains(attachment.extractionStatus))
    }
    private let api: ChatTransport
    private var generation = 0
    private var stream: Task<Void, Never>?
    private var cursors: [String: Int] = [:]
    private var drafts: [String: String] = [:]
    private var pendingKey: (content: String, key: String)?
    private var closed = false
    var onUnauthorized: (() async -> Void)?
    var activeRun: HopeRun? { runs.first(where: \.active) }

    init(api: ChatTransport) { self.api = api; self.features = ChatFeatureStore(api: api) }
    deinit { stream?.cancel(); syncTask?.cancel() }
    private func call<T: Decodable>(_ path: String, method: String = "GET", body: [String: Any]? = nil, query: [URLQueryItem] = [], selectionBound: Bool = true) async throws -> T {
        let epoch = generation
        let data = try await api.request(path, method: method, body: body, query: query)
        try Task.checkCancellation()
        guard !closed, !selectionBound || generation == epoch else { throw CancellationError() }
        return try ChatCoding.decoder.decode(T.self, from: data)
    }
    private func failure(_ value: Error) async {
        guard !closed, !(value is CancellationError) else { return }
        if case ChatFailure.status(let code) = value, code == 401 || code == 403 { await onUnauthorized?(); return }
        error = value.localizedDescription
    }
    func load(query: String = "", archived: Bool = false, workspace: String? = nil, more: Bool = false) async {
        guard !closed else { return }
        let sameScope = currentQuery == query && currentArchived == archived && currentWorkspace == workspace
        currentQuery = query; currentArchived = archived; currentWorkspace = workspace
        searchGeneration += 1
        let search = searchGeneration
        searching = true
        defer { if search == searchGeneration { searching = false } }
        do {
            var q = [URLQueryItem(name: "q", value: query), URLQueryItem(name: "archived", value: String(archived)), URLQueryItem(name: "limit", value: "50")]
            if let workspace { q.append(URLQueryItem(name: "workspace_id", value: workspace)) }
            if more, sameScope, let nextCursor { q.append(URLQueryItem(name: "cursor", value: nextCursor)) }
            let page: ConversationPage = try await call("api/conversations", query: q, selectionBound: false)
            guard search == searchGeneration else { return }
            if more && sameScope { let existing = Set(conversations.map(\.id)); conversations += page.conversations.filter { !existing.contains($0.id) } }
            else { conversations = page.conversations }
            nextCursor = page.nextCursor
            let spaces: WorkspacePage = try await call("api/workspaces", selectionBound: false)
            guard search == searchGeneration else { return }; workspaces = spaces.workspaces
            let prefs: PreferencesEnvelope = try await call("api/preferences", selectionBound: false)
            guard search == searchGeneration else { return }; preferences = prefs.preferences
            error = nil
        } catch { await failure(error) }
    }
    func open(_ conversation: HopeConversation) async {
        guard !closed else { return }
        draftGeneration += 1
        if let selected { drafts[selected.id] = draft }
        generation += 1; stream?.cancel(); stream = nil
        selected = conversation; messages = []; runs = []; progress = nil; approval = nil; exportText = nil; exportFile = nil
        draft = drafts[conversation.id] ?? ""; pendingKey = nil; selectedAttachmentIds = []; olderMessagesCursor = nil; error = nil
        do {
            let detail: ConversationDetail = try await call("api/conversations/\(conversation.id)")
            selected = detail.conversation; messages = detail.messages; runs = detail.runs; olderMessagesCursor = detail.nextCursor
            if let activeRun { replay(activeRun.id) }
        } catch { await failure(error) }
    }
    func loadOlder() async {
        guard let selected, let cursor = olderMessagesCursor else { return }
        do {
            let detail: ConversationDetail = try await call("api/conversations/\(selected.id)", query: [URLQueryItem(name: "cursor", value: cursor)])
            let existing = Set(messages.map(\.id))
            messages = detail.messages.filter { !existing.contains($0.id) } + messages
            olderMessagesCursor = detail.nextCursor
        } catch { await failure(error) }
    }
    func create(workspace: String? = nil) async {
        guard !busy else { return }; busy = true; defer { busy = false }
        do {
            var body: [String: Any] = [:]; if let workspace { body["workspace_id"] = workspace }
            let response: ConversationEnvelope = try await call("api/conversations", method: "POST", body: body)
            let selectionEpoch = generation
            await refreshList()
            guard !closed, generation == selectionEpoch else { busy = false; return }
            await open(response.conversation)
        } catch { await failure(error) }
    }
    func send() async {
        guard let selected, !busy, activeRun == nil, !mutatingConversationIds.contains(selected.id) else { return }
        let content = draft.trimmingCharacters(in: .whitespacesAndNewlines)
        guard !content.isEmpty else { return }
        guard canSendAttachments else {
            error = "Some attachments are unavailable for the current model. Refresh Files, choose a supported model, or remove those files before sending."
            return
        }
        busy = true; error = nil; defer { busy = false }
        let payloadIdentity = content + "\n" + selectedAttachmentIds.sorted().joined(separator: ",") + String(research && researchAvailable)
        if pendingKey?.content != payloadIdentity { pendingKey = (payloadIdentity, UUID().uuidString) }
        do {
            let response: SendEnvelope = try await call("api/conversations/\(selected.id)/messages", method: "POST", body: ["content": content, "idempotency_key": pendingKey!.key, "attachment_ids": Array(selectedAttachmentIds).sorted(), "mode": research && researchAvailable ? "research" : "normal"])
            draftGeneration += 1
            upsert(response.message); upsert(response.run); draft = ""; drafts[selected.id] = ""; pendingKey = nil; selectedAttachmentIds = []
            if response.run.active { replay(response.run.id) }
            else { let detail: ConversationDetail = try await call("api/conversations/\(selected.id)"); messages = detail.messages }
        } catch { await failure(error) }
    }
    private func upsert(_ message: HopeMessage) {
        guard message.conversationId == selected?.id else { return }
        if let index = messages.firstIndex(where: { $0.id == message.id }) { messages[index] = message } else { messages.append(message) }
    }
    private func upsert(_ run: HopeRun) {
        guard run.conversationId == selected?.id else { return }
        if let index = runs.firstIndex(where: { $0.id == run.id }) { runs[index] = run } else { runs.append(run) }
    }
    /// Full-message replacement, never concatenate replayed content.
    func apply(_ event: ChatEvent, run: String) throws {
        guard event.id > cursors[run, default: 0] else { return }
        switch event.name {
        case "message":
            struct Envelope: Decodable { let message: HopeMessage }
            upsert(try ChatCoding.decoder.decode(Envelope.self, from: event.data).message)
        case "run", "done": upsert(try ChatCoding.decoder.decode(RunEnvelope.self, from: event.data).run)
        case "progress":
            struct Envelope: Decodable { let message: String }
            progress = try ChatCoding.decoder.decode(Envelope.self, from: event.data).message
        case "approval":
            struct Envelope: Decodable { let approvalId: String; let prompt: String }
            let value = try ChatCoding.decoder.decode(Envelope.self, from: event.data)
            approval = (value.approvalId, value.prompt)
        default: break
        }
        cursors[run] = event.id
        if activeRun == nil { progress = nil; approval = nil }
    }
    func resume() {
        guard !closed, let activeRun else { return }; replay(activeRun.id)
    }
    private func replay(_ run: String) {
        stream?.cancel()
        let epoch = generation
        stream = Task { [weak self] in
            guard let self else { return }
            do {
                try await api.events(run: run, after: cursors[run, default: 0]) { [weak self] event in
                    guard let self, self.generation == epoch, !self.closed else { throw CancellationError() }
                    try self.apply(event, run: run)
                }
                guard generation == epoch, !closed else { return }
                if activeRun != nil { error = "Connection interrupted. Resume to replay the latest response." }
            } catch { guard generation == epoch else { return }; await failure(error) }
        }
    }
    func stop() async {
        guard let activeRun else { return }
        do { let response: RunEnvelope = try await call("api/runs/\(activeRun.id)/cancel", method: "POST"); upsert(response.run); stream?.cancel(); progress = nil; approval = nil }
        catch { await failure(error) }
    }
    func decide(_ decision: String) async {
        guard let activeRun, let approval else { return }
        do { let result: RunEnvelope = try await call("api/runs/\(activeRun.id)/approval", method: "POST", body: ["approval_id": approval.id, "decision": decision]); upsert(result.run); self.approval = nil; replay(result.run.id) }
        catch { await failure(error) }
    }
    func canMutate(_ conversation: HopeConversation) -> Bool {
        !closed && !mutatingConversationIds.contains(conversation.id) &&
            (selected?.id != conversation.id || (!busy && activeRun == nil))
    }
    private func refreshList() async {
        await load(query: currentQuery, archived: currentArchived, workspace: currentWorkspace)
    }
    private func updateMetadata(_ value: HopeConversation) {
        if selected?.id == value.id { selected = value }
        if value.archived != currentArchived || (currentWorkspace != nil && value.workspaceId != currentWorkspace) {
            conversations.removeAll { $0.id == value.id }
        } else if let index = conversations.firstIndex(where: { $0.id == value.id }) {
            conversations[index] = value
        }
    }
    func patch(_ conversation: HopeConversation, changes: [String: Any]) async {
        guard canMutate(conversation) else { return }
        mutatingConversationIds.insert(conversation.id)
        defer { mutatingConversationIds.remove(conversation.id) }
        var body = changes; body["revision"] = conversation.revision
        do {
            let response: ConversationEnvelope = try await call("api/conversations/\(conversation.id)", method: "PATCH", body: body, selectionBound: false)
            updateMetadata(response.conversation)
            await refreshList()
        } catch ChatFailure.status(409) {
            do {
                let detail: ConversationDetail = try await call("api/conversations/\(conversation.id)", selectionBound: false)
                updateMetadata(detail.conversation)
                await refreshList()
                guard !closed else { return }
                error = "This chat changed elsewhere. Its latest details are loaded. Review your change and try again."
            } catch { await failure(error) }
        } catch { await failure(error) }
    }
    func delete(_ conversation: HopeConversation) async {
        guard canMutate(conversation) else { return }
        mutatingConversationIds.insert(conversation.id)
        defer { mutatingConversationIds.remove(conversation.id) }
        do {
            struct Result: Decodable { let ok: Bool }
            let _: Result = try await call("api/conversations/\(conversation.id)", method: "DELETE", selectionBound: false)
            conversations.removeAll { $0.id == conversation.id }; drafts[conversation.id] = nil
            if selected?.id == conversation.id { clearSelection() }
            await refreshList()
        } catch { await failure(error) }
    }
    private func clearSelection() {
        generation += 1; draftGeneration += 1; stream?.cancel(); stream = nil
        selected = nil; messages = []; runs = []; draft = ""; selectedAttachmentIds = []
        pendingKey = nil; approval = nil; progress = nil; exportText = nil; exportFile = nil; olderMessagesCursor = nil
    }
    func queuedAttachment(_ id: String) -> ChatAttachment? {
        queuedAttachments[id] ?? features.attachments.first(where: { $0.id == id })
    }
    /// Bind asynchronous library/upload results to the composer that opened them.
    @discardableResult
    func queueAttachment(_ attachment: ChatAttachment, expectedDraftGeneration: Int? = nil) async -> Bool {
        guard !closed, let selected, !busy, activeRun == nil, !mutatingConversationIds.contains(selected.id),
              expectedDraftGeneration == nil || expectedDraftGeneration == draftGeneration else { return false }
        guard features.enabled.contains("attachments") else { error = "Attachments are unavailable. Refresh Files and try again."; return false }
        guard attachmentEligible(attachment) else {
            error = "This file cannot be used with the current model. Choose an extracted document or a supported image."; return false
        }
        guard selectedAttachmentIds.contains(attachment.id) || selectedAttachmentIds.count < 8 else {
            error = "Use at most eight attachments per message."; return false
        }
        queuedAttachments[attachment.id] = attachment
        selectedAttachmentIds.insert(attachment.id); pendingKey = nil; error = nil
        return true
    }
    func branch(_ message: HopeMessage, edited: String? = nil, regenerate: Bool = false) async {
        guard let selected, !busy, activeRun == nil, !mutatingConversationIds.contains(selected.id) else { return }
        busy = true
        do {
            let target: HopeMessage
            if regenerate {
                guard let index = messages.firstIndex(where: { $0.id == message.id }), let prior = messages.prefix(index).last(where: { $0.role == "user" }) else { busy = false; return }
                target = prior
            } else { target = message }
            var body: [String: Any] = ["message_id": target.id]
            if let edited { body["content"] = edited }
            else if regenerate { body["content"] = target.content }
            let response: ConversationEnvelope = try await call("api/conversations/\(selected.id)/branch", method: "POST", body: body)
            let selectionEpoch = generation
            await refreshList()
            guard !closed, generation == selectionEpoch else { busy = false; return }
            await open(response.conversation)
            guard !closed, self.selected?.id == response.conversation.id else { busy = false; return }
            if let edited { draft = edited; selectedAttachmentIds = Set(target.attachments) }
            else if regenerate { draft = target.content; selectedAttachmentIds = Set(target.attachments) }
            if edited != nil || regenerate, !target.attachments.isEmpty {
                let attachmentEpoch = generation
                _ = await features.refreshCapabilities()
                guard !closed, generation == attachmentEpoch, self.selected?.id == response.conversation.id else { busy = false; return }
                for id in target.attachments {
                    struct AttachmentEnvelope: Decodable { let attachment: ChatAttachment }
                    let metadata: AttachmentEnvelope = try await call("api/attachments/\(id)")
                    queuedAttachments[id] = metadata.attachment
                }
            }
            busy = false
            if let edited { draft = edited; selectedAttachmentIds = Set(target.attachments); await send() }
            else if regenerate { draft = target.content; selectedAttachmentIds = Set(target.attachments); await send() }
        } catch { busy = false; await failure(error) }
    }
    @discardableResult
    func saveWorkspace(_ workspace: HopeWorkspace?, name: String, instructions: String) async -> Bool {
        guard !name.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
            error = "Enter a workspace name."
            return false
        }
        do {
            var body: [String: Any] = ["name": name, "instructions": instructions]
            if let workspace { body["revision"] = workspace.revision }
            let _: WorkspaceEnvelope = try await call(workspace.map { "api/workspaces/\($0.id)" } ?? "api/workspaces", method: workspace == nil ? "POST" : "PATCH", body: body)
            let result: WorkspacePage = try await call("api/workspaces")
            workspaces = result.workspaces
            error = nil
            return true
        } catch {
            await failure(error)
            return false
        }
    }
    func deleteWorkspace(_ workspace: HopeWorkspace) async {
        do {
            struct Result: Decodable { let ok: Bool }
            let _: Result = try await call("api/workspaces/\(workspace.id)", method: "DELETE")
            workspaces.removeAll { $0.id == workspace.id }
            for i in conversations.indices where conversations[i].workspaceId == workspace.id { conversations[i].workspaceId = nil }
            if selected?.workspaceId == workspace.id { selected?.workspaceId = nil }
            await refreshList()
        } catch { await failure(error) }
    }
    func savePreferences(palette: String, appearance: String) async {
        do { let result: PreferencesEnvelope = try await call("api/preferences", method: "PUT", body: ["revision": preferences.revision, "palette": palette, "appearance": appearance]); preferences = result.preferences }
        catch { await failure(error) }
    }
    func loadModels() async {
        do {
            let result: ChatSettingsResponse = try await call("api/settings/model")
            model = result.settings.model; thinkingLevel = result.settings.thinkingLevel; models = result.models; modelNote = result.thinkingNote ?? result.message
        } catch { modelNote = "Server model settings are not available." }
    }
    func saveModel() async {
        do { let result: ChatSettingsSaved = try await call("api/settings/model", method: "PUT", body: ["model": model, "thinking_level": thinkingLevel], selectionBound: false); model = result.settings.model; thinkingLevel = result.settings.thinkingLevel; modelNote = result.message; _ = await features.refreshCapabilities(); await loadResearch() }
        catch { await failure(error) }
    }
    func loadResearch() async {
        do { struct Result: Decodable { let available: Bool }; let result: Result = try await call("api/research"); researchAvailable = result.available }
        catch { researchAvailable = false; research = false }
    }
    func exportConversation(format: String) async {
        guard let selected else { return }
        do {
            let epoch = generation
            let bytes = try await api.request("api/conversations/\(selected.id)/export", method: "GET", body: nil, query: [URLQueryItem(name: "format", value: format)])
            guard epoch == generation, !closed else { return }
            exportText = String(data: bytes, encoding: .utf8)
            exportFile = PrivateChatExport(data: bytes, filename: "Hope-chat-\(selected.id).\(format == "json" ? "json" : "md")", type: format == "json" ? .json : .plainText)
        } catch { await failure(error) }
    }
    func foreground(_ active: Bool) {
        syncTask?.cancel(); syncTask = nil
        guard active, !closed else { stream?.cancel(); stream = nil; return }
        resume()
        syncTask = Task { [weak self] in
            await self?.loadResearch()
            while !Task.isCancelled {
                guard self?.closed == false else { return }
                await self?.synchronize()
                // Release the store before suspension; its retained task must not
                // keep an otherwise-discarded account alive indefinitely.
                do { try await Task.sleep(for: .seconds(5)) } catch { return }
            }
        }
    }
    func synchronize() async {
        do {
            struct Change: Decodable { let id: String; let kind: String; let deleted: Bool; let data: HopeSyncData? }
            struct Result: Decodable { let changes: [Change]; let cursor: Int }
            let result: Result = try await call("api/sync", query: [URLQueryItem(name: "after", value: String(syncCursor))], selectionBound: false)
            syncCursor = result.cursor
            guard !result.changes.isEmpty else { return }
            for change in result.changes {
                if change.kind == "conversation" {
                    if change.deleted {
                        conversations.removeAll { $0.id == change.id }
                        if selected?.id == change.id { clearSelection() }
                    } else if let value = change.data?.conversation {
                        if value.archived != currentArchived || (currentWorkspace != nil && value.workspaceId != currentWorkspace) { conversations.removeAll { $0.id == value.id } }
                        else if let i = conversations.firstIndex(where: { $0.id == change.id }) { conversations[i] = value }
                        else if currentQuery.isEmpty { conversations.insert(value, at: 0) }
                    }
                }
                if change.kind == "preferences", let value = change.data?.preferences { preferences = value }
                if change.kind == "workspace" {
                    if change.deleted { workspaces.removeAll { $0.id == change.id } }
                    else if let value = change.data?.workspace { if let i = workspaces.firstIndex(where: { $0.id == value.id }) { workspaces[i] = value } else { workspaces.append(value) } }
                }
            }
            // Reconcile only loaded metadata. Re-fetching page one here discards
            // older loaded pages and their continuation cursor every sync tick.
            // Search membership depends on message content, so newly matching rows
            // are discovered only by an explicit search refresh, not guessed here.
            if let selected, result.changes.contains(where: { $0.id == selected.id && !$0.deleted }) {
                let detail: ConversationDetail = try await call("api/conversations/\(selected.id)")
                self.selected = detail.conversation
                for message in detail.messages { upsert(message) }
                for run in detail.runs { upsert(run) }
            }
        } catch { if case ChatFailure.status(let status) = error, status == 401 || status == 403 { await failure(error) } }
    }
    /// Invalidate every outstanding callback before clearing account-visible content.
    func close() { syncTask?.cancel(); syncTask = nil; exportText = nil; exportFile = nil; research = false; features.close(); selectedAttachmentIds = []; queuedAttachments = [:]; closed = true; generation += 1; draftGeneration += 1; searchGeneration += 1; mutatingConversationIds = []; stream?.cancel(); stream = nil; api.cancel(); conversations = []; workspaces = []; selected = nil; messages = []; runs = []; draft = ""; drafts = [:]; cursors = [:]; pendingKey = nil; approval = nil; progress = nil; error = nil }
}
struct ChatModelChoice: Decodable, Identifiable { let id: String; let thinkingLevels: [String]? }
struct ChatSettingsValue: Decodable { let model: String; let thinkingLevel: String }
struct ChatSettingsResponse: Decodable { let settings: ChatSettingsValue; let models: [ChatModelChoice]; let message: String?; let thinkingNote: String? }
struct ChatSettingsSaved: Decodable { let settings: ChatSettingsValue; let message: String? }

struct HopeSyncData: Decodable {
    let conversation: HopeConversation?
    let workspace: HopeWorkspace?
    let preferences: HopePreferences?
    init(from decoder: Decoder) throws {
        let value = try decoder.singleValueContainer()
        conversation = try? value.decode(HopeConversation.self)
        workspace = try? value.decode(HopeWorkspace.self)
        preferences = try? value.decode(HopePreferences.self)
    }
}