Accessibility

struct NoteToolbar: ToolbarContent {
    let onCapture: () -> Void

    var body: some ToolbarContent {
        ToolbarItem(placement: .primaryAction) {
            Button(action: onCapture) {
                Image(systemName: "camera.viewfinder")
            }
            .accessibilityLabel("Capture Photo Note")
        }
    }
}

struct NoteRow: View {
    let note: Note

    var body: some View {
        HStack(alignment: .firstTextBaseline, spacing: 12) {
            Image(systemName: note.isPinned ? "pin.fill" : "note.text")
                .accessibilityHidden(true)           // decorative: state goes into the value
            VStack(alignment: .leading, spacing: 4) {
                Text(note.title).font(.headline)
                Text(note.body).font(.subheadline).lineLimit(2)
                Text(note.createdAt, format: .dateTime.day().month().year())
                    .font(.caption)
            }
        }
        .accessibilityValue(note.isPinned ? Text("Pinned") : Text(""))
    }
}

NavigationLink(value: note) {
    NoteRow(note: note)
}
.accessibilityHint("Opens the note")

struct NoteDetailSection: View {
    let title: LocalizedStringKey

    var body: some View {
        Text(title)
            .font(.title3.weight(.semibold))
            .accessibilityAddTraits(.isHeader)
    }
}

struct NotebookCell: View {
    let notebook: Notebook
    let isSelected: Bool

    var body: some View {
        Label(notebook.name, systemImage: notebook.symbolName)
            .accessibilityAddTraits(isSelected ? [.isButton, .isSelected] : .isButton)
    }
}

struct NoteList: View {
    @Environment(NoteStore.self) private var store

    var body: some View {
        List(store.notes) { note in
            NavigationLink(value: note) {
                NoteRow(note: note)
                    .accessibilityElement(children: .combine)
            }
            .swipeActions {
                Button("Delete", systemImage: "trash", role: .destructive) { store.delete(note) }
            }
            .accessibilityAction(named: note.isPinned ? "Unpin" : "Pin") {
                store.togglePin(note)
            }
            .accessibilityAction(named: "Delete") {
                store.delete(note)
            }
        }
    }
}

struct NotebookCarousel: View {
    let notebooks: [Notebook]
    @Binding var selection: Notebook.ID?

    private var index: Int {
        notebooks.firstIndex { $0.id == selection } ?? 0
    }

    var body: some View {
        ScrollView(.horizontal) {
            LazyHStack { ForEach(notebooks) { NotebookCard(notebook: $0) } }
                .scrollTargetLayout()
        }
        .scrollPosition(id: $selection)
        .accessibilityElement(children: .ignore)
        .accessibilityLabel("Notebooks")
        .accessibilityValue(notebooks.isEmpty ? "" : notebooks[index].name)
        .accessibilityAdjustableAction { direction in
            guard !notebooks.isEmpty else { return }
            switch direction {
            case .increment: selection = notebooks[min(index + 1, notebooks.count - 1)].id
            case .decrement: selection = notebooks[max(index - 1, 0)].id
            @unknown default: break
            }
        }
    }
}

// Packages/FieldNotesUI/Sources/FieldNotesUI/TagChipStyle.swift (revised for Dynamic Type)
struct TagChipStyle: ViewModifier {
    var isSelected = false
    @ScaledMetric(relativeTo: .caption) private var horizontalPadding = 8.0
    @ScaledMetric(relativeTo: .caption) private var iconSize = 12.0

    func body(content: Content) -> some View {
        HStack(spacing: 4) {
            Image(systemName: "tag")
                .resizable().scaledToFit()
                .frame(width: iconSize, height: iconSize)
                .accessibilityHidden(true)
            content.font(.caption)
        }
        .padding(.horizontal, horizontalPadding)
        .padding(.vertical, horizontalPadding / 2)
        .foregroundStyle(isSelected ? Color.white : Color.primary)
        .background(isSelected ? AnyShapeStyle(Color.accentColor) : AnyShapeStyle(.quaternary), in: Capsule())
    }
}

struct NoteRowLayout<Content: View>: View {
    @Environment(\.dynamicTypeSize) private var dynamicTypeSize
    @ViewBuilder var content: Content

    var body: some View {
        let layout = dynamicTypeSize.isAccessibilitySize
            ? AnyLayout(VStackLayout(alignment: .leading, spacing: 6))
            : AnyLayout(HStackLayout(alignment: .firstTextBaseline, spacing: 12))
        layout { content }
    }
}

struct SyncButton: View {
    let syncer: any NoteSyncing

    var body: some View {
        Button("Sync", systemImage: "arrow.triangle.2.circlepath") {
            Task { try? await syncer.sync() }
        }
        .dynamicTypeSize(...DynamicTypeSize.accessibility2)
        .accessibilityShowsLargeContentViewer()
    }
}

struct PinBadge: View {
    let isPinned: Bool
    @Environment(\.accessibilityReduceMotion) private var reduceMotion

    var body: some View {
        Image(systemName: "pin.fill")
            .opacity(isPinned ? 1 : 0)
            .offset(y: isPinned || reduceMotion ? 0 : -12)
            .animation(reduceMotion ? .easeInOut(duration: 0.2) : .spring, value: isPinned)
    }
}

struct CaptureControlsPanel: View {
    var startCapture: () -> Void
    @Environment(\.accessibilityReduceTransparency) private var reduceTransparency

    var body: some View {
        HStack(spacing: 12) {
            Text("New note from the camera")
            CaptureButton(action: startCapture)
        }
        .padding()
        .background {
            if reduceTransparency {
                RoundedRectangle(cornerRadius: 20).fill(Color(.systemBackground))
            } else {
                RoundedRectangle(cornerRadius: 20).fill(.ultraThinMaterial)
            }
        }
    }
}

struct TagChipBorder: ViewModifier {
    @Environment(\.colorSchemeContrast) private var contrast

    func body(content: Content) -> some View {
        content.overlay {
            if contrast == .increased {
                Capsule().strokeBorder(.primary, lineWidth: 1)
            }
        }
    }
}

struct SyncStatusDot: View {
    let isSynced: Bool
    @Environment(\.accessibilityDifferentiateWithoutColor) private var differentiateWithoutColor

    var body: some View {
        if differentiateWithoutColor {
            Image(systemName: isSynced ? "checkmark.circle.fill" : "exclamationmark.triangle.fill")
                .foregroundStyle(isSynced ? .green : .orange)
        } else {
            Circle().fill(isSynced ? .green : .orange).frame(width: 8, height: 8)
        }
    }
}

import XCTest

final class AccessibilityAuditTests: XCTestCase {
    @MainActor
    func testNoteListPassesAudit() throws {
        let app = XCUIApplication()
        app.launch()

        try app.performAccessibilityAudit(for: [.dynamicType, .contrast, .sufficientElementDescription,
                                                .hitRegion, .textClipped]) { issue in
            // Ignore the decorative header gradient; fail on everything else.
            issue.auditType == .contrast && issue.element?.identifier == "noteList.headerGradient"
        }
    }
}

#Preview("NoteRow at AX3", traits: .sizeThatFitsLayout) {
    NoteRow(note: .sample)
        .dynamicTypeSize(.accessibility3)
}