Drawing, Animation and Gestures

struct RecordingPulse: View {
    var isRecording: Bool

    var body: some View {
        TimelineView(.animation(minimumInterval: 1.0 / 30.0, paused: !isRecording)) { timeline in
            Canvas { context, size in
                let center = CGPoint(x: size.width / 2, y: size.height / 2)
                let time = timeline.date.timeIntervalSinceReferenceDate
                for ring in 0..<3 {
                    // Each ring grows and fades on a 1.5 s cycle, offset from the previous one.
                    let phase = (time / 1.5 + Double(ring) / 3).truncatingRemainder(dividingBy: 1)
                    let radius = 20 + phase * min(size.width, size.height) / 2
                    let circle = Path(ellipseIn: CGRect(x: center.x - radius, y: center.y - radius,
                                                        width: radius * 2, height: radius * 2))
                    context.stroke(circle, with: .color(.red.opacity(1 - phase)), lineWidth: 2)
                }
            }
        }
        .allowsHitTesting(false)
        .accessibilityHidden(true)
    }
}

struct NoteRow: View {
    let note: Note

    var body: some View {
        HStack {
            Text(note.title)
            Spacer()
            Image(systemName: "pin.fill")
                .foregroundStyle(.orange)
                .scaleEffect(note.isPinned ? 1 : 0.01)
                .opacity(note.isPinned ? 1 : 0)
                .animation(.snappy, value: note.isPinned)
        }
    }
}

struct NoteDetailToolbar: View {
    @Environment(NoteStore.self) private var store
    let note: Note
    @State private var showsSavedBanner = false

    var body: some View {
        Button(note.isPinned ? "Unpin" : "Pin", systemImage: "pin") {
            withAnimation(.bouncy) {
                store.togglePin(note)
            } completion: {
                showsSavedBanner = true
            }
        }
    }
}

extension Animation {
    /// FieldNotes' standard motion tokens, used everywhere instead of ad-hoc curves.
    static let fnQuick = Animation.snappy(duration: 0.25)
    static let fnCard = Animation.spring(duration: 0.45, bounce: 0.25)
    static let fnFade = Animation.easeInOut(duration: 0.2)
}

let cardSpring = Spring(duration: 0.45, bounce: 0.25)
let settleTime = cardSpring.settlingDuration          // seconds until motion is imperceptible

struct SavedBannerHost<Content: View>: View {
    @Binding var showsBanner: Bool
    @ViewBuilder var content: Content

    var body: some View {
        content
            .overlay(alignment: .bottom) {
                if showsBanner {
                    Label("Saved", systemImage: "checkmark.circle.fill")
                        .padding()
                        .transition(.asymmetric(insertion: .move(edge: .bottom).combined(with: .opacity),
                                                removal: .opacity))
                        .task {
                            try? await Task.sleep(for: .seconds(2))
                            withAnimation(.fnFade) { showsBanner = false }
                        }
                }
            }
            .animation(.fnCard, value: showsBanner)
    }
}

struct PeelTransition: Transition {
    func body(content: Content, phase: TransitionPhase) -> some View {
        content
            .rotation3DEffect(.degrees(phase.isIdentity ? 0 : 70), axis: (x: 0, y: 1, z: 0),
                              anchor: .leading, perspective: 0.6)
            .opacity(phase.isIdentity ? 1 : 0)
    }
}

extension Transition where Self == PeelTransition {
    static var peel: PeelTransition { PeelTransition() }
}

// Usage: NoteCard(note: note).transition(.peel)

struct TagFilterBar: View {
    let tags: [String]
    @Binding var selectedTag: String?
    @Namespace private var selection

    var body: some View {
        ScrollView(.horizontal) {
            HStack(spacing: 8) {
                ForEach(tags, id: \.self) { tag in
                    Text(tag)
                        .padding(.horizontal, 12).padding(.vertical, 6)
                        .background {
                            if selectedTag == tag {
                                Capsule()
                                    .fill(.tint.opacity(0.2))
                                    .matchedGeometryEffect(id: "highlight", in: selection)
                            }
                        }
                        .onTapGesture {
                            withAnimation(.fnQuick) { selectedTag = (selectedTag == tag) ? nil : tag }
                        }
                }
            }
        }
        .scrollIndicators(.hidden)
    }
}

enum SyncPulse: CaseIterable {
    case rest, lift, settle
}

struct SyncStatusIcon: View {
    var lastSync: Date?

    var body: some View {
        Image(systemName: "checkmark.icloud")
            .phaseAnimator(SyncPulse.allCases, trigger: lastSync) { content, phase in
                content
                    .scaleEffect(phase == .lift ? 1.3 : 1)
                    .offset(y: phase == .lift ? -4 : 0)
                    .foregroundStyle(phase == .rest ? Color.secondary : Color.green)
            } animation: { phase in
                switch phase {
                case .rest: .smooth
                case .lift: .snappy(duration: 0.2)
                case .settle: .bouncy
                }
            }
    }
}

struct ShakeValues {
    var offsetX: CGFloat = 0
    var tilt: Angle = .zero
}

struct TitleField: View {
    @Binding var title: String
    var failedSaveAttempts: Int

    var body: some View {
        TextField("Title", text: $title)
            .keyframeAnimator(initialValue: ShakeValues(), trigger: failedSaveAttempts) { content, value in
                content
                    .offset(x: value.offsetX)
                    .rotationEffect(value.tilt)
            } keyframes: { _ in
                KeyframeTrack(\.offsetX) {
                    LinearKeyframe(12, duration: 0.06)
                    LinearKeyframe(-10, duration: 0.08)
                    LinearKeyframe(6, duration: 0.08)
                    SpringKeyframe(0, duration: 0.3, spring: .bouncy)
                }
                KeyframeTrack(\.tilt) {
                    CubicKeyframe(.degrees(2), duration: 0.1)
                    CubicKeyframe(.zero, duration: 0.3)
                }
            }
    }
}

#if canImport(UIKit)
import UIKit
import SwiftUI

final class MapPinCalloutController: UIViewController {
    private let callout = UIView()

    func showCallout() {
        UIView.animate(.fnCard) {
            callout.transform = .identity
            callout.alpha = 1
        } completion: {
            UIAccessibility.post(notification: .layoutChanged, argument: self.callout)
        }
    }
}
#elseif canImport(AppKit)
import AppKit
import SwiftUI

final class InspectorPanelController: NSViewController {
    func revealPanel(_ panel: NSView) {
        NSAnimationContext.animate(.fnCard) {
            panel.animator().alphaValue = 1
        }
    }
}
#endif

struct CompassView: UIViewRepresentable {
    var heading: Angle

    func makeUIView(context: Context) -> UIImageView {
        UIImageView(image: UIImage(systemName: "location.north.line"))
    }

    func updateUIView(_ view: UIImageView, context: Context) {
        context.animate {
            view.transform = CGAffineTransform(rotationAngle: heading.radians)
        }
    }
}

struct PinnableNoteRow: View {
    @Environment(NoteStore.self) private var store
    let note: Note
    @State private var showsQuickActions = false

    var body: some View {
        NoteRow(note: note)
            .onTapGesture(count: 2) {
                withAnimation(.bouncy) { store.togglePin(note) }
            }
            .onLongPressGesture(minimumDuration: 0.4) {
                showsQuickActions = true
            }
            .sensoryFeedback(.impact, trigger: note.isPinned)
            .accessibilityAction(named: note.isPinned ? "Unpin" : "Pin") { store.togglePin(note) }
    }
}

struct SwipeToArchiveCard: View {
    @Environment(NoteStore.self) private var store
    let note: Note
    @State private var offset: CGFloat = 0

    var body: some View {
        NoteCard(note: note)
            .offset(x: offset)
            .gesture(
                DragGesture(minimumDistance: 12)
                    .onChanged { value in offset = value.translation.width }
                    .onEnded { value in
                        if abs(value.predictedEndTranslation.width) > 240 {
                            withAnimation(.fnCard) { offset = value.predictedEndTranslation.width }
                            store.delete(note)
                        } else {
                            withAnimation(.fnCard) { offset = 0 }
                        }
                    }
            )
    }
}

// FieldNotes/Views/NotebookSidebarRow.swift
import SwiftUI
import FieldNotesModel
import FieldNotesServices

struct NotebookSidebarRow: View {
    @Environment(NoteStore.self) private var store
    let notebook: Notebook

    var body: some View {
        Label(notebook.name, systemImage: notebook.symbolName)
            // The payload is an autoclosure, built only when a drag actually starts.
            .draggable(NoteFileFormat.Envelope(
                notebookName: notebook.name,
                notes: store.notes.filter { $0.notebookID == notebook.id }))
    }
}

// FieldNotes/Views/NotebookDropZone.swift
struct NotebookDropZone<Content: View>: View {
    @Environment(NoteStore.self) private var store
    @ViewBuilder let content: Content
    @State private var isTargeted = false

    var body: some View {
        content
            .overlay {
                if isTargeted {
                    RoundedRectangle(cornerRadius: 12).stroke(.tint, lineWidth: 3)
                }
            }
            .dropDestination(for: NoteFileFormat.Envelope.self) { envelopes, _ in
                for envelope in envelopes {
                    let notebook = Notebook(name: envelope.notebookName)
                    store.notebooks.append(notebook)
                    envelope.notes.map { $0.note(in: notebook.id) }.forEach(store.add)
                }
                return !envelopes.isEmpty
            } isTargeted: { isTargeted = $0 }
    }
}

struct AttachmentViewer: View {
    let image: Image

    @State private var scale: CGFloat = 1
    @State private var angle: Angle = .zero
    @GestureState private var liveScale: CGFloat = 1
    @GestureState private var liveAngle: Angle = .zero

    var body: some View {
        let magnify = MagnifyGesture()
            .updating($liveScale) { value, state, _ in state = value.magnification }
            .onEnded { value in scale = min(max(scale * value.magnification, 1), 6) }

        let rotate = RotateGesture()
            .updating($liveAngle) { value, state, _ in state = value.rotation }
            .onEnded { value in angle += value.rotation }

        image
            .resizable()
            .scaledToFit()
            .scaleEffect(scale * liveScale)
            .rotationEffect(angle + liveAngle)
            .gesture(magnify.simultaneously(with: rotate))
            .animation(.fnCard, value: scale)
            .accessibilityZoomAction { action in
                scale = action.direction == .zoomIn ? min(scale * 1.5, 6) : max(scale / 1.5, 1)
            }
    }
}

struct BoardNote: View {
    let note: Note
    @Binding var position: CGPoint

    enum DragState {
        case inactive, pressing, dragging(translation: CGSize)

        var translation: CGSize {
            if case .dragging(let translation) = self { translation } else { .zero }
        }
        var isActive: Bool {
            if case .inactive = self { false } else { true }
        }
    }

    @GestureState private var dragState = DragState.inactive

    var body: some View {
        let pickUpAndMove = LongPressGesture(minimumDuration: 0.3)
            .sequenced(before: DragGesture())
            .updating($dragState) { value, state, _ in
                switch value {
                case .first(true):
                    state = .pressing
                case .second(true, let drag):
                    state = .dragging(translation: drag?.translation ?? .zero)
                default:
                    state = .inactive
                }
            }
            .onEnded { value in
                guard case .second(true, let drag?) = value else { return }
                position.x += drag.translation.width
                position.y += drag.translation.height
            }

        NoteCard(note: note)
            .frame(width: 180)
            .scaleEffect(dragState.isActive ? 1.06 : 1)
            .shadow(radius: dragState.isActive ? 12 : 2)
            .position(x: position.x + dragState.translation.width,
                      y: position.y + dragState.translation.height)
            .animation(.fnQuick, value: dragState.isActive)
            .gesture(pickUpAndMove)
    }
}

struct SketchThumbnail: View {
    @Environment(NoteStore.self) private var store
    let note: Note
    var open: () -> Void

    var body: some View {
        let pinOrOpen = TapGesture(count: 2)
            .onEnded { store.togglePin(note) }
            .exclusively(before: TapGesture().onEnded { open() })

        NoteCard(note: note)
            .gesture(pinOrOpen)
    }
}

// Let a parent track a drag for analytics without blocking the ScrollView's own scrolling.
NoteList()
    .simultaneousGesture(DragGesture(minimumDistance: 30).onEnded { _ in didScrollManually = true })

// Make the whole card respond to a tap, even though it contains a tappable TagChip.
NoteCard(note: note)
    .highPriorityGesture(TapGesture().onEnded { openNote(note) }, including: .gesture)

struct SketchPad: View {
    @Binding var strokes: [InkStroke]
    @State private var current: [CGPoint] = []

    private var inkGesture: AnyGesture<DragGesture.Value> {
        if #available(iOS 27, macOS 27, watchOS 27, visionOS 27, *) {
            // New in 27: only the Pencil and the pointer draw; fingers keep scrolling the page.
            AnyGesture(DragGesture(minimumDistance: 0, inputKinds: [.pencil, .pointer]))
        } else {
            AnyGesture(DragGesture(minimumDistance: 0))
        }
    }

    var body: some View {
        SketchCanvas(strokes: strokes + [InkStroke(points: current)])
            .gesture(
                inkGesture
                    .onChanged { value in current.append(value.location) }
                    .onEnded { _ in
                        strokes.append(InkStroke(points: current))
                        current = []
                    }
            )
    }
}

struct NoteBoardBackground: View {
    var addNote: (CGPoint) -> Void

    var body: some View {
        if #available(iOS 27, macOS 27, visionOS 27, *) {
            Color.clear
                .contentShape(.rect)
                .onTapGesture(count: 1, coordinateSpace: .local, inputKinds: .pointer) { location in
                    addNote(location)
                }
        } else {
            Color.clear
        }
    }
}