import SwiftUI
import UIKit

struct KnowledgeView: View {
  @Bindable var session: AssistantSession
  @State private var selection: ContinuitySection = .knowledge
  @State private var searchQuery = ""
  @State private var isPresentingCapture = false
  @State private var isPresentingHandoff = false
  @State private var feedback: ContinuityFeedback?
  @State private var searchResults: [KnowledgeItem] = []
  @State private var proactiveInsights: [ProactiveKnowledgeInsight] = []

  var body: some View {
    NavigationStack {
      VStack(spacing: 0) {
        Picker("Continuity", selection: $selection) {
          Text("Knowledge").tag(ContinuitySection.knowledge)
          Text("Handoffs").tag(ContinuitySection.handoffs)
          Text("Tasks").tag(ContinuitySection.tasks)
        }
        .pickerStyle(.segmented)
        .padding(.horizontal)
        .padding(.vertical, 12)

        selectedContent
      }
      .navigationTitle("Continuity")
      .navigationBarTitleDisplayMode(.inline)
      .searchable(
        text: $searchQuery,
        placement: .navigationBarDrawer(displayMode: .automatic),
        prompt: "Search saved knowledge"
      )
      .toolbar {
        ToolbarItem(placement: .topBarTrailing) {
          Menu {
            Button("Capture Knowledge", systemImage: "square.and.pencil") {
              isPresentingCapture = true
            }

            Button("Create Handoff", systemImage: "arrow.triangle.branch") {
              isPresentingHandoff = true
            }
          } label: {
            Image(systemName: "plus.circle")
          }
          .disabled(!session.isWorkspaceReady || session.isRunning)
          .accessibilityLabel("Add continuity item")
        }
      }
      .onChange(of: selection) { _, newValue in
        if newValue != .knowledge {
          searchQuery = ""
        }
      }
      .task(id: trimmedSearchQuery) {
        await refreshSearchResults()
      }
      .task(id: insightInputSignature) {
        await refreshProactiveInsights()
      }
      .sheet(isPresented: $isPresentingCapture) {
        CaptureKnowledgeSheet { kind, title, content, tags in
          session.captureKnowledge(
            kind: kind,
            title: title,
            content: content,
            tags: tags
          )
        }
      }
      .sheet(isPresented: $isPresentingHandoff) {
        CreateHandoffSheet { title, focus in
          session.createHandoff(title: title, focus: focus)
        }
      }
      .alert(item: $feedback) { feedback in
        Alert(
          title: Text(feedback.title),
          message: Text(feedback.message),
          dismissButton: .default(Text("OK"))
        )
      }
    }
  }

  @ViewBuilder
  private var selectedContent: some View {
    switch selection {
    case .knowledge:
      KnowledgeOverview(
        session: session,
        items: matchingKnowledge,
        insights: proactiveInsights,
        isFiltering: !trimmedSearchQuery.isEmpty,
        capture: { isPresentingCapture = true }
      )
    case .handoffs:
      HandoffOverview(
        session: session,
        create: { isPresentingHandoff = true },
        restore: restoreHandoff,
        deactivate: { session.deactivateHandoff() }
      )
    case .tasks:
      TaskOverview(session: session)
    }
  }

  private var trimmedSearchQuery: String {
    searchQuery.trimmingCharacters(in: .whitespacesAndNewlines)
  }

  private var matchingKnowledge: [KnowledgeItem] {
    if trimmedSearchQuery.isEmpty {
      return session.workspace.knowledgeItems.sorted { lhs, rhs in
        if lhs.updatedAt != rhs.updatedAt { return lhs.updatedAt > rhs.updatedAt }
        return lhs.id.uuidString < rhs.id.uuidString
      }
    }
    return searchResults
  }

  private var activeHandoff: SessionHandoff? {
    guard let activeID = session.workspace.activeHandoffID else { return nil }
    return session.workspace.handoffs.first { $0.id == activeID }
  }

  private var insightInputSignature: String {
    let completedTaskCount = session.workspace.tasks.filter(\.isCompleted).count
    return [
      String(session.workspace.knowledgeItems.count),
      String(session.workspace.tasks.count),
      String(completedTaskCount),
      session.workspace.activeHandoffID?.uuidString ?? "none",
      session.workspace.handoffs.last?.restoredAt?.description ?? "never",
    ].joined(separator: "|")
  }

  private func refreshSearchResults() async {
    let query = trimmedSearchQuery
    guard !query.isEmpty else {
      searchResults = []
      return
    }
    searchResults = []
    do {
      try await Task.sleep(for: .milliseconds(220))
    } catch {
      return
    }
    let corpus = KnowledgeEngine.searchableKnowledge(
      typedItems: session.workspace.knowledgeItems,
      legacyMemories: session.workspace.memories
    )
    let results = await Task.detached(priority: .userInitiated) {
      KnowledgeEngine().search(
        query: query,
        in: corpus,
        limit: KnowledgeEngine.Limits.maxSearchResults
      )
    }.value
    guard !Task.isCancelled, query == trimmedSearchQuery else { return }
    searchResults = results
  }

  private func refreshProactiveInsights() async {
    let knowledge = session.workspace.knowledgeItems
    let tasks = session.workspace.tasks
    let handoff = activeHandoff
    let insights = await Task.detached(priority: .utility) {
      KnowledgeEngine().deriveProactiveInsights(
        knowledge: knowledge,
        tasks: tasks,
        handoff: handoff
      )
    }.value
    guard !Task.isCancelled else { return }
    proactiveInsights = insights
  }

  private func restoreHandoff(_ handoff: SessionHandoff) {
    guard session.restoreHandoff(id: handoff.id) else {
      feedback = ContinuityFeedback(
        title: "Handoff Not Restored",
        message: "Dolphin could not restore this handoff. Try again when the current run is finished."
      )
      return
    }

    UIAccessibility.post(
      notification: .announcement,
      argument: "Restored \(handoff.title)"
    )
  }
}

private enum ContinuitySection: Hashable {
  case knowledge
  case handoffs
  case tasks
}

private struct ContinuityFeedback: Identifiable {
  let id = UUID()
  let title: String
  let message: String
}

private struct ContinuityDeletionTarget: Identifiable {
  enum Kind {
    case knowledge
    case memory
    case handoff
    case task
  }

  let id = UUID()
  let entityID: UUID
  let kind: Kind
  let title: String
  let message: String
}

private struct KnowledgeOverview: View {
  @Bindable var session: AssistantSession
  let items: [KnowledgeItem]
  let insights: [ProactiveKnowledgeInsight]
  let isFiltering: Bool
  let capture: () -> Void
  @State private var pendingDeletion: ContinuityDeletionTarget?

  var body: some View {
    if hasNoContent {
      ContentUnavailableView {
        Label("No saved knowledge", systemImage: "books.vertical")
      } description: {
        Text("Capture a decision, preference, goal, or useful context for future conversations.")
      } actions: {
        Button("Capture Knowledge", action: capture)
          .disabled(!session.isWorkspaceReady || session.isRunning)
      }
    } else if isFiltering, items.isEmpty {
      ContentUnavailableView.search
    } else {
      List {
        if !isFiltering {
          Section {
            KnowledgeSummaryCard(
              knowledgeCount: session.workspace.knowledgeItems.count,
              handoffCount: session.workspace.handoffs.count,
              openTaskCount: session.workspace.tasks.filter { !$0.isCompleted }.count
            )
          }
          .listRowBackground(Color.clear)
          .listRowInsets(EdgeInsets(top: 4, leading: 16, bottom: 4, trailing: 16))

          if !insights.isEmpty {
            Section("Proactive insights") {
              ForEach(insights) { insight in
                ProactiveInsightRow(insight: insight)
              }
            }
          }

          if !session.workspace.knowledgeDigests.isEmpty {
            Section("Synthesis") {
              ForEach(sortedDigests) { digest in
                KnowledgeDigestRow(digest: digest)
              }
            }
          }
        }

        if !items.isEmpty {
          Section {
            ForEach(items) { item in
              KnowledgeItemRow(item: item)
                .swipeActions {
                  Button("Delete", systemImage: "trash", role: .destructive) {
                    pendingDeletion = deletionTarget(for: item)
                  }
                  .disabled(!session.isWorkspaceReady || session.isRunning)
                }
            }
          } header: {
            Text(isFiltering ? "Search results" : "Structured knowledge")
          } footer: {
            if isFiltering {
              Text("Results use deterministic local hybrid lexical ranking, not embedding or semantic search.")
            }
          }
        }

        if !isFiltering, !session.workspace.memories.isEmpty {
          Section {
            ForEach(session.workspace.memories.reversed()) { memory in
              LegacyMemoryRow(memory: memory)
                .swipeActions {
                  Button("Delete", systemImage: "trash", role: .destructive) {
                    pendingDeletion = memoryDeletionTarget(memory)
                  }
                  .disabled(!session.isWorkspaceReady || session.isRunning)
                }
            }
          } header: {
            Text("Legacy memories")
          } footer: {
            Text("Existing memories remain available to Dolphin and can be removed here.")
          }
        }
      }
      .listStyle(.insetGrouped)
      .alert(item: $pendingDeletion) { target in
        Alert(
          title: Text(target.title),
          message: Text(target.message),
          primaryButton: .destructive(Text("Delete")) {
            performDeletion(target)
          },
          secondaryButton: .cancel()
        )
      }
    }
  }

  private var hasNoContent: Bool {
    !isFiltering
      && session.workspace.knowledgeItems.isEmpty
      && session.workspace.memories.isEmpty
      && session.workspace.knowledgeDigests.isEmpty
      && session.workspace.handoffs.isEmpty
      && session.workspace.tasks.isEmpty
      && insights.isEmpty
  }

  private var sortedDigests: [KnowledgeDigest] {
    session.workspace.knowledgeDigests.sorted { lhs, rhs in
      if lhs.createdAt != rhs.createdAt { return lhs.createdAt > rhs.createdAt }
      return lhs.id.uuidString < rhs.id.uuidString
    }
  }

  private func deletionTarget(
    for item: KnowledgeItem
  ) -> ContinuityDeletionTarget {
    let isTyped = session.workspace.knowledgeItems.contains { $0.id == item.id }
    if !isTyped,
      let memory = session.workspace.memories.first(where: { $0.id == item.id })
    {
      return memoryDeletionTarget(memory)
    }
    let cascade = KnowledgeEngine().deletionCascade(
      deletingKnowledgeIDs: [item.id],
      handoffs: session.workspace.handoffs,
      digests: session.workspace.knowledgeDigests
    )
    let provenanceNote = cascade.removesAllDigests
      ? " All synthesis snapshots are included because schema v5 does not record which handoff focus each snapshot copied."
      : ""
    return ContinuityDeletionTarget(
      entityID: item.id,
      kind: .knowledge,
      title: "Delete \(item.title)?",
      message: "This removes the live record, \(cascade.handoffIDs.count) linked handoff(s), and \(cascade.digestIDs.count) synthesis snapshot(s).\(provenanceNote) A mirrored legacy memory with the same ID is also removed. Original chat and Activity receipts remain until you clear the conversation."
    )
  }

  private func memoryDeletionTarget(
    _ memory: MemoryItem
  ) -> ContinuityDeletionTarget {
    ContinuityDeletionTarget(
      entityID: memory.id,
      kind: .memory,
      title: "Delete this saved memory?",
      message: "This removes the legacy memory, its typed mirror, and derived handoffs or synthesis snapshots that reference the mirror. If a linked handoff is removed, all synthesis snapshots are included because schema v5 does not record handoff provenance. Original chat and Activity receipts remain until you clear the conversation."
    )
  }

  private func performDeletion(_ target: ContinuityDeletionTarget) {
    switch target.kind {
    case .knowledge:
      session.deleteKnowledge(id: target.entityID)
    case .memory:
      session.deleteMemory(id: target.entityID)
    case .handoff, .task:
      break
    }
  }
}

private struct KnowledgeSummaryCard: View {
  let knowledgeCount: Int
  let handoffCount: Int
  let openTaskCount: Int

  var body: some View {
    VStack(alignment: .leading, spacing: 12) {
      Label("Local continuity", systemImage: "lock.shield")
        .font(.headline)

      Text("Saved context stays in Dolphin’s protected app container and helps it continue without pretending a cloud action occurred.")
        .font(.subheadline)
        .foregroundStyle(.secondary)

      HStack(spacing: 10) {
        SummaryMetric(value: knowledgeCount, label: "Items")
        SummaryMetric(value: handoffCount, label: "Handoffs")
        SummaryMetric(value: openTaskCount, label: "Open tasks")
      }
    }
    .padding(16)
    .frame(maxWidth: .infinity, alignment: .leading)
    .background(.thinMaterial, in: RoundedRectangle(cornerRadius: 18, style: .continuous))
    .accessibilityElement(children: .combine)
  }
}

private struct SummaryMetric: View {
  let value: Int
  let label: String

  var body: some View {
    VStack(alignment: .leading, spacing: 2) {
      Text(value, format: .number)
        .font(.headline.monospacedDigit())
      Text(label)
        .font(.caption)
        .foregroundStyle(.secondary)
        .lineLimit(1)
        .minimumScaleFactor(0.8)
    }
    .frame(maxWidth: .infinity, alignment: .leading)
  }
}

private struct KnowledgeItemRow: View {
  let item: KnowledgeItem

  var body: some View {
    VStack(alignment: .leading, spacing: 8) {
      HStack(alignment: .firstTextBaseline, spacing: 8) {
        Label(item.kind.label, systemImage: item.kind.symbolName)
          .font(.caption.weight(.semibold))
          .foregroundStyle(item.kind.tint)

        Spacer(minLength: 8)
      }

      Text(item.title)
        .font(.headline)
        .textSelection(.enabled)

      if item.content != item.title {
        Text(item.content)
          .font(.subheadline)
          .foregroundStyle(.secondary)
          .lineLimit(5)
          .textSelection(.enabled)
      }

      if !item.tags.isEmpty {
        ScrollView(.horizontal, showsIndicators: false) {
          HStack(spacing: 6) {
            ForEach(item.tags, id: \.self) { tag in
              Text(tag)
                .font(.caption2.weight(.medium))
                .padding(.horizontal, 8)
                .padding(.vertical, 4)
                .background(Color.secondary.opacity(0.12), in: Capsule())
            }
          }
        }
        .accessibilityElement(children: .combine)
        .accessibilityLabel("Tags: \(item.tags.joined(separator: ", "))")
      }

      HStack(spacing: 6) {
        Text(item.source.label)
        Text("·")
        Text(item.updatedAt, format: .dateTime.month().day().year().hour().minute())
      }
      .font(.caption)
      .foregroundStyle(.tertiary)
    }
    .padding(.vertical, 5)
    .accessibilityElement(children: .combine)
    .accessibilityHint("Swipe left to delete this knowledge item.")
  }
}

private struct LegacyMemoryRow: View {
  let memory: MemoryItem

  var body: some View {
    VStack(alignment: .leading, spacing: 6) {
      Label("Memory", systemImage: "brain.head.profile")
        .font(.caption.weight(.semibold))
        .foregroundStyle(.secondary)
      Text(memory.content)
        .textSelection(.enabled)
      Text(memory.createdAt, format: .dateTime.month().day().year().hour().minute())
        .font(.caption)
        .foregroundStyle(.tertiary)
    }
    .padding(.vertical, 4)
    .accessibilityElement(children: .combine)
  }
}

private struct KnowledgeDigestRow: View {
  let digest: KnowledgeDigest
  @State private var isExpanded = false

  var body: some View {
    DisclosureGroup(isExpanded: $isExpanded) {
      VStack(alignment: .leading, spacing: 10) {
        Text(digest.summary)
          .font(.subheadline)
          .foregroundStyle(.secondary)
          .textSelection(.enabled)

        if !digest.priorities.isEmpty {
          DigestList(title: "Priorities", items: digest.priorities)
        }

        if !digest.openQuestions.isEmpty {
          DigestList(title: "Open questions", items: digest.openQuestions)
        }
      }
      .padding(.top, 8)
    } label: {
      VStack(alignment: .leading, spacing: 4) {
        Label("Context synthesis", systemImage: "sparkles")
          .font(.subheadline.weight(.semibold))
        Text("\(digest.trigger) · \(digest.createdAt.formatted(date: .abbreviated, time: .shortened))")
          .font(.caption)
          .foregroundStyle(.secondary)
      }
    }
    .padding(.vertical, 3)
  }
}

private struct DigestList: View {
  let title: String
  let items: [String]

  var body: some View {
    VStack(alignment: .leading, spacing: 5) {
      Text(title)
        .font(.caption.weight(.semibold))
      ForEach(Array(items.enumerated()), id: \.offset) { _, item in
        Label(item, systemImage: "circle.fill")
          .font(.caption)
          .labelStyle(BulletLabelStyle())
      }
    }
  }
}

private struct BulletLabelStyle: LabelStyle {
  func makeBody(configuration: Configuration) -> some View {
    HStack(alignment: .firstTextBaseline, spacing: 7) {
      configuration.icon
        .font(.system(size: 5))
        .foregroundStyle(.secondary)
      configuration.title
    }
  }
}

private struct ProactiveInsightRow: View {
  let insight: ProactiveKnowledgeInsight

  var body: some View {
    HStack(alignment: .top, spacing: 11) {
      Image(systemName: insight.priority.symbolName)
        .foregroundStyle(insight.priority.tint)
        .frame(width: 24)
        .accessibilityHidden(true)

      VStack(alignment: .leading, spacing: 4) {
        HStack(alignment: .firstTextBaseline) {
          Text(insight.title)
            .font(.subheadline.weight(.semibold))
          Spacer(minLength: 8)
          Text(insight.priority.label)
            .font(.caption2.weight(.semibold))
            .foregroundStyle(insight.priority.tint)
        }
        Text(insight.detail)
          .font(.caption)
          .foregroundStyle(.secondary)
      }
    }
    .padding(.vertical, 3)
    .accessibilityElement(children: .combine)
  }
}

private struct HandoffOverview: View {
  @Bindable var session: AssistantSession
  let create: () -> Void
  let restore: (SessionHandoff) -> Void
  let deactivate: () -> Bool
  @State private var pendingDeletion: ContinuityDeletionTarget?

  var body: some View {
    if sortedHandoffs.isEmpty {
      ContentUnavailableView {
        Label("No session handoffs", systemImage: "arrow.triangle.branch")
      } description: {
        Text("Create a local checkpoint with current context and open tasks, then restore it in a later session.")
      } actions: {
        Button("Create Handoff", action: create)
          .disabled(!session.isWorkspaceReady || session.isRunning)
      }
    } else {
      List {
        if let activeHandoff {
          Section("Active handoff") {
            ActiveHandoffBanner(
              handoff: activeHandoff,
              isEnabled: session.isWorkspaceReady && !session.isRunning,
              deactivate: deactivate
            )
          }
        }

        Section {
          ForEach(sortedHandoffs) { handoff in
            HandoffRow(
              handoff: handoff,
              isActive: handoff.id == session.workspace.activeHandoffID,
              isEnabled: session.isWorkspaceReady && !session.isRunning,
              restore: { restore(handoff) }
            )
            .swipeActions {
              Button("Delete", systemImage: "trash", role: .destructive) {
                pendingDeletion = ContinuityDeletionTarget(
                  entityID: handoff.id,
                  kind: .handoff,
                  title: "Delete \(handoff.title)?",
                  message: "This removes the checkpoint and all synthesis snapshots that might contain its focus. Original chat and Activity receipts remain until you clear the conversation."
                )
              }
              .disabled(!session.isWorkspaceReady || session.isRunning)
            }
          }
        } header: {
          Text("Saved handoffs")
        } footer: {
          Text("Restoring marks a handoff as the active local context. It does not contact a cloud service or alter external data.")
        }
      }
      .listStyle(.insetGrouped)
      .alert(item: $pendingDeletion) { target in
        Alert(
          title: Text(target.title),
          message: Text(target.message),
          primaryButton: .destructive(Text("Delete")) {
            session.deleteHandoff(id: target.entityID)
          },
          secondaryButton: .cancel()
        )
      }
    }
  }

  private var sortedHandoffs: [SessionHandoff] {
    session.workspace.handoffs.sorted { lhs, rhs in
      if lhs.createdAt != rhs.createdAt { return lhs.createdAt > rhs.createdAt }
      return lhs.id.uuidString < rhs.id.uuidString
    }
  }

  private var activeHandoff: SessionHandoff? {
    guard let activeID = session.workspace.activeHandoffID else { return nil }
    return session.workspace.handoffs.first { $0.id == activeID }
  }
}

private struct ActiveHandoffBanner: View {
  let handoff: SessionHandoff
  let isEnabled: Bool
  let deactivate: () -> Bool

  var body: some View {
    HStack(alignment: .top, spacing: 12) {
      Image(systemName: "checkmark.seal.fill")
        .foregroundStyle(.green)
        .font(.title3)
        .accessibilityHidden(true)
      VStack(alignment: .leading, spacing: 4) {
        Text(handoff.title)
          .font(.headline)
        if !handoff.focus.isEmpty {
          Text(handoff.focus)
            .font(.subheadline)
            .foregroundStyle(.secondary)
            .lineLimit(3)
        }
        Button("Deactivate", systemImage: "pause.circle") {
          if deactivate() {
            UIAccessibility.post(
              notification: .announcement,
              argument: "Handoff deactivated"
            )
          }
        }
        .buttonStyle(.bordered)
        .controlSize(.small)
        .disabled(!isEnabled)
        .accessibilityHint("Keeps this checkpoint saved but stops adding it to new requests.")
      }
    }
    .padding(.vertical, 4)
    .accessibilityElement(children: .contain)
    .accessibilityValue("Active")
  }
}

private struct HandoffRow: View {
  let handoff: SessionHandoff
  let isActive: Bool
  let isEnabled: Bool
  let restore: () -> Void
  @State private var isExpanded = false

  var body: some View {
    VStack(alignment: .leading, spacing: 9) {
      HStack(alignment: .firstTextBaseline, spacing: 8) {
        Text(handoff.title)
          .font(.headline)

        Spacer(minLength: 8)

        if isActive {
          Label("Active", systemImage: "checkmark.circle.fill")
            .font(.caption.weight(.semibold))
            .foregroundStyle(.green)
        }
      }

      if !handoff.focus.isEmpty {
        Text(handoff.focus)
          .font(.subheadline)
          .foregroundStyle(.secondary)
          .lineLimit(isExpanded ? nil : 3)
          .textSelection(.enabled)
      }

      if isExpanded {
        if !handoff.summary.isEmpty {
          Text(handoff.summary)
            .font(.caption)
            .foregroundStyle(.secondary)
            .textSelection(.enabled)
        }

        if !handoff.nextSteps.isEmpty {
          DigestList(title: "Next steps", items: handoff.nextSteps)
        }
      }

      HStack(spacing: 7) {
        Text(handoff.createdAt, format: .dateTime.month().day().year().hour().minute())
        Text("·")
        Text("\(handoff.knowledgeItemIDs.count) items")
        Text("·")
        Text("\(handoff.taskIDs.count) tasks")
      }
      .font(.caption2)
      .foregroundStyle(.tertiary)

      HStack {
        Button(isExpanded ? "Show Less" : "Details") {
          withAnimation(.easeInOut(duration: 0.18)) {
            isExpanded.toggle()
          }
        }
        .buttonStyle(.borderless)

        Spacer()

        if !isActive {
          Button("Restore", systemImage: "arrow.counterclockwise", action: restore)
            .buttonStyle(.bordered)
            .controlSize(.small)
            .disabled(!isEnabled)
        }
      }
    }
    .padding(.vertical, 5)
  }
}

private struct TaskOverview: View {
  @Bindable var session: AssistantSession
  @State private var pendingDeletion: ContinuityDeletionTarget?

  var body: some View {
    if sortedTasks.isEmpty {
      ContentUnavailableView(
        "No tasks",
        systemImage: "checklist",
        description: Text("Ask Dolphin to add a task. Completed tasks remain visible until deleted.")
      )
    } else {
      List {
        Section {
          ForEach(sortedTasks) { task in
            Button {
              toggleCompletion(of: task)
            } label: {
              HStack(alignment: .top, spacing: 12) {
                Image(systemName: task.isCompleted ? "checkmark.circle.fill" : "circle")
                  .foregroundStyle(task.isCompleted ? Color.green : Color.secondary)
                  .accessibilityHidden(true)

                VStack(alignment: .leading, spacing: 5) {
                  Text(task.title)
                    .strikethrough(task.isCompleted)
                    .foregroundStyle(task.isCompleted ? Color.secondary : Color.primary)
                  Text(task.createdAt, format: .dateTime.month().day().year().hour().minute())
                    .font(.caption)
                    .foregroundStyle(.secondary)
                }

                Spacer(minLength: 8)

                Text(task.isCompleted ? "Reopen" : "Complete")
                  .font(.caption.weight(.semibold))
                  .foregroundStyle(.tint)
              }
            }
            .buttonStyle(.plain)
            .contentShape(Rectangle())
            .padding(.vertical, 4)
            .disabled(!session.isWorkspaceReady || session.isRunning)
            .accessibilityLabel(task.title)
            .accessibilityValue(task.isCompleted ? "Completed" : "Incomplete")
            .accessibilityHint(
              task.isCompleted
                ? "Double tap to reopen this task."
                : "Double tap to mark this task complete."
            )
            .swipeActions {
              Button("Delete", systemImage: "trash", role: .destructive) {
                let handoffCount = session.workspace.handoffs.filter {
                  $0.taskIDs.contains(task.id)
                }.count
                pendingDeletion = ContinuityDeletionTarget(
                  entityID: task.id,
                  kind: .task,
                  title: "Delete \(task.title)?",
                  message: "This removes the task, \(handoffCount) linked handoff(s), and all synthesis snapshots that might contain its title. Original chat and Activity receipts remain until you clear the conversation."
                )
              }
              .disabled(!session.isWorkspaceReady || session.isRunning)
            }
          }
        } header: {
          Text("\(openTaskCount) open · \(sortedTasks.count) total")
        }
      }
      .listStyle(.insetGrouped)
      .alert(item: $pendingDeletion) { target in
        Alert(
          title: Text(target.title),
          message: Text(target.message),
          primaryButton: .destructive(Text("Delete")) {
            session.deleteTask(id: target.entityID)
          },
          secondaryButton: .cancel()
        )
      }
    }
  }

  private var sortedTasks: [AssistantTaskItem] {
    session.workspace.tasks.sorted { lhs, rhs in
      if lhs.isCompleted != rhs.isCompleted { return !lhs.isCompleted }
      if lhs.createdAt != rhs.createdAt { return lhs.createdAt > rhs.createdAt }
      return lhs.id.uuidString < rhs.id.uuidString
    }
  }

  private var openTaskCount: Int {
    sortedTasks.filter { !$0.isCompleted }.count
  }

  private func toggleCompletion(of task: AssistantTaskItem) {
    let newValue = !task.isCompleted
    guard session.setTaskCompletion(id: task.id, isCompleted: newValue) else {
      return
    }
    UIAccessibility.post(
      notification: .announcement,
      argument: newValue
        ? "\(task.title), completed"
        : "\(task.title), reopened"
    )
  }
}

private struct CaptureKnowledgeSheet: View {
  @Environment(\.dismiss) private var dismiss
  @State private var kind: KnowledgeKind = .context
  @State private var title = ""
  @State private var content = ""
  @State private var tags = ""
  @State private var isShowingFailure = false
  @FocusState private var focusedField: Field?

  let save: (KnowledgeKind, String, String, [String]) -> Bool

  var body: some View {
    NavigationStack {
      Form {
        Section("Classification") {
          Picker("Kind", selection: $kind) {
            ForEach(KnowledgeKind.allCases, id: \.self) { kind in
              Label(kind.label, systemImage: kind.symbolName)
                .tag(kind)
            }
          }

          TextField("Title (optional)", text: $title)
            .textInputAutocapitalization(.sentences)
            .focused($focusedField, equals: .title)

          Text("\(trimmedTitle.count)/\(KnowledgeEngine.Limits.maxItemTitleCharacters)")
            .font(.caption.monospacedDigit())
            .foregroundStyle(titleIsValid ? Color.secondary : Color.red)
            .frame(maxWidth: .infinity, alignment: .trailing)
        }

        Section("Knowledge") {
          TextEditor(text: $content)
            .frame(minHeight: 150)
            .focused($focusedField, equals: .content)
            .accessibilityLabel("Knowledge content")

          Text("\(trimmedContent.count)/\(KnowledgeEngine.Limits.maxItemContentCharacters)")
            .font(.caption.monospacedDigit())
            .foregroundStyle(contentIsValid ? Color.secondary : Color.red)
            .frame(maxWidth: .infinity, alignment: .trailing)
        }

        Section {
          TextField("project, decision, iOS", text: $tags)
            .textInputAutocapitalization(.never)
            .autocorrectionDisabled()
            .focused($focusedField, equals: .tags)
        } header: {
          Text("Tags")
        } footer: {
          Text("Separate tags with commas. Up to \(KnowledgeEngine.Limits.maxTagCount) tags and \(KnowledgeEngine.Limits.maxTagCharacters) characters per tag. Current: \(parsedTags.count). This typed entry is saved locally for deterministic retrieval.")
            .foregroundStyle(tagsAreValid ? Color.secondary : Color.red)
        }
      }
      .navigationTitle("Capture Knowledge")
      .navigationBarTitleDisplayMode(.inline)
      .toolbar {
        ToolbarItem(placement: .cancellationAction) {
          Button("Cancel") { dismiss() }
        }
        ToolbarItem(placement: .confirmationAction) {
          Button("Save") { submit() }
            .disabled(!isValid)
        }
      }
      .alert("Knowledge Not Saved", isPresented: $isShowingFailure) {
        Button("OK", role: .cancel) {}
      } message: {
        Text("Dolphin could not save this item. Check local storage and try again after the current run finishes.")
      }
      .onAppear {
        focusedField = .title
      }
    }
  }

  private var trimmedContent: String {
    content.trimmingCharacters(in: .whitespacesAndNewlines)
  }

  private var trimmedTitle: String {
    title.trimmingCharacters(in: .whitespacesAndNewlines)
  }

  private var parsedTags: [String] {
    tags.split(separator: ",", omittingEmptySubsequences: true).map { tag in
      tag.trimmingCharacters(in: .whitespacesAndNewlines)
    }
    .filter { !$0.isEmpty }
  }

  private var titleIsValid: Bool {
    trimmedTitle.count <= KnowledgeEngine.Limits.maxItemTitleCharacters
  }

  private var contentIsValid: Bool {
    !trimmedContent.isEmpty
      && trimmedContent.count <= KnowledgeEngine.Limits.maxItemContentCharacters
  }

  private var tagsAreValid: Bool {
    parsedTags.count <= KnowledgeEngine.Limits.maxTagCount
      && parsedTags.allSatisfy {
        $0.count <= KnowledgeEngine.Limits.maxTagCharacters
      }
  }

  private var isValid: Bool {
    titleIsValid && contentIsValid && tagsAreValid
  }

  private func submit() {
    if save(kind, title, trimmedContent, parsedTags) {
      UIAccessibility.post(notification: .announcement, argument: "Knowledge saved")
      dismiss()
    } else {
      isShowingFailure = true
    }
  }

  private enum Field: Hashable {
    case title
    case content
    case tags
  }
}

private struct CreateHandoffSheet: View {
  @Environment(\.dismiss) private var dismiss
  @State private var title = "Session handoff"
  @State private var focus = ""
  @State private var isShowingFailure = false
  @FocusState private var focusedField: Field?

  let save: (String, String) -> Bool

  var body: some View {
    NavigationStack {
      Form {
        Section("Checkpoint") {
          TextField("Title", text: $title)
            .textInputAutocapitalization(.sentences)
            .focused($focusedField, equals: .title)

          Text("\(trimmedTitle.count)/\(KnowledgeEngine.Limits.maxItemTitleCharacters)")
            .font(.caption.monospacedDigit())
            .foregroundStyle(titleIsValid ? Color.secondary : Color.red)
            .frame(maxWidth: .infinity, alignment: .trailing)

          TextEditor(text: $focus)
            .frame(minHeight: 150)
            .focused($focusedField, equals: .focus)
            .accessibilityLabel("Current focus")

          Text("\(trimmedFocus.count)/\(KnowledgeEngine.Limits.maxHandoffFocusCharacters)")
            .font(.caption.monospacedDigit())
            .foregroundStyle(focusIsValid ? Color.secondary : Color.red)
            .frame(maxWidth: .infinity, alignment: .trailing)
        }

        Section {
          Label("Structured knowledge", systemImage: "books.vertical")
          Label("Open tasks", systemImage: "checklist")
          Label("Recent local conversation context", systemImage: "bubble.left.and.bubble.right")
        } header: {
          Text("Included in the snapshot")
        } footer: {
          Text("The handoff is a local continuity checkpoint. It does not synchronize with a team or external service.")
        }
      }
      .navigationTitle("Create Handoff")
      .navigationBarTitleDisplayMode(.inline)
      .toolbar {
        ToolbarItem(placement: .cancellationAction) {
          Button("Cancel") { dismiss() }
        }
        ToolbarItem(placement: .confirmationAction) {
          Button("Create") { submit() }
            .disabled(!isValid)
        }
      }
      .alert("Handoff Not Created", isPresented: $isShowingFailure) {
        Button("OK", role: .cancel) {}
      } message: {
        Text("Dolphin could not create this checkpoint. Check local storage and try again after the current run finishes.")
      }
      .onAppear {
        focusedField = .focus
      }
    }
  }

  private var trimmedFocus: String {
    focus.trimmingCharacters(in: .whitespacesAndNewlines)
  }

  private var trimmedTitle: String {
    title.trimmingCharacters(in: .whitespacesAndNewlines)
  }

  private var titleIsValid: Bool {
    !trimmedTitle.isEmpty
      && trimmedTitle.count <= KnowledgeEngine.Limits.maxItemTitleCharacters
  }

  private var focusIsValid: Bool {
    !trimmedFocus.isEmpty
      && trimmedFocus.count <= KnowledgeEngine.Limits.maxHandoffFocusCharacters
  }

  private var isValid: Bool {
    titleIsValid && focusIsValid
  }

  private func submit() {
    if save(trimmedTitle, trimmedFocus) {
      UIAccessibility.post(notification: .announcement, argument: "Session handoff created")
      dismiss()
    } else {
      isShowingFailure = true
    }
  }

  private enum Field: Hashable {
    case title
    case focus
  }
}

private extension KnowledgeKind {
  var label: String {
    switch self {
    case .fact: "Fact"
    case .preference: "Preference"
    case .decision: "Decision"
    case .goal: "Goal"
    case .code: "Code"
    case .context: "Context"
    case .insight: "Insight"
    }
  }

  var symbolName: String {
    switch self {
    case .fact: "checkmark.circle"
    case .preference: "slider.horizontal.3"
    case .decision: "arrow.triangle.branch"
    case .goal: "target"
    case .code: "chevron.left.forwardslash.chevron.right"
    case .context: "doc.text.magnifyingglass"
    case .insight: "lightbulb"
    }
  }

  var tint: Color {
    switch self {
    case .fact: .blue
    case .preference: .purple
    case .decision: .orange
    case .goal: .green
    case .code: .indigo
    case .context: .teal
    case .insight: .yellow
    }
  }
}

private extension KnowledgeSource {
  var label: String {
    switch self {
    case .user: "User"
    case .assistant: "Dolphin"
    case .synthesis: "Synthesis"
    case .import: "Import"
    }
  }
}

private extension KnowledgeInsightPriority {
  var label: String {
    rawValue.capitalized
  }

  var symbolName: String {
    switch self {
    case .high: "exclamationmark.triangle.fill"
    case .medium: "lightbulb.fill"
    case .low: "info.circle.fill"
    }
  }

  var tint: Color {
    switch self {
    case .high: .red
    case .medium: .orange
    case .low: .blue
    }
  }
}