Как выглядит и ведёт себя Круг

    private func entryLine(_ e: DiaryEntry, current: Bool) -> some View {
        HStack(alignment: .firstTextBaseline, spacing: 16) {
            Text(e.line(lang: store.lang))
                .foregroundStyle(Palette.text)
                .frame(maxWidth: .infinity, alignment: .leading)
            if e.counted {
                Text(metric.value(e))
                    .monospacedDigit()
                    .foregroundStyle(metric.color)
                    .contentTransition(.numericText())
                    .accessibilityLabel("\(metric.fullName) \(metric.value(e))")
            } else {
                // No product yet: the numbers are a question, and a tap picks one.
                Text(verbatim: "?")
                    .font(.body.weight(.semibold))
                    .foregroundStyle(Palette.textSecondary)
                    .frame(minWidth: 30, minHeight: 30)
                    .background(Palette.surfaceMuted, in: Circle())
                    .accessibilityLabel(L("Не посчитано"))
                    .accessibilityIdentifier("uncounted")
            }
        }
        .font(.title3)
        .padding(.horizontal, 24)
        .padding(.vertical, 5)
        .contentShape(Rectangle())
        .accessibilityElement(children: .combine)
        .accessibilityHint(current ? L("Изменить") : "")
        .onTapGesture { if current { edit(e) } }
        .contextMenu {
            Button("Изменить", systemImage: "pencil") { edit(e) }
            Button("Удалить", systemImage: "trash", role: .destructive) { delete(e) }
        }
    }

import SwiftUI

/// The input line with one inline "ghost" completion, the way a browser's
/// address bar guesses the rest: `suggestion` is the whole line the app
/// expects ("Творог 5% 150 грамм"), and whatever of it lies past the typed
/// text is drawn grayed-out behind the real, system text field. Enter
/// (the Go key) is how the guess is taken.
struct GhostField: View {
    @Binding var text: String
    var suggestion: String?
    var focus: FocusState<Bool>.Binding
    /// Called with the line as submitted (the field's text may not have
    /// caught up within the same update).
    var onSubmit: (String) -> Void
    /// A tap on the grey text — "not this one?" — opens the other matches.
    var onGhostTap: (() -> Void)? = nil

    /// Where the typed text ends on its first line, in the field's
    /// coordinates: a tap to the right of it (or below the first line) is on
    /// the ghost, a tap on the typed text itself just moves the caret.
    @State private var typedWidth: CGFloat = 0
    @State private var lineHeight: CGFloat = 0

    /// What's drawn after the typed text: the rest of a continuation, or —
    /// for a guess that doesn't continue it (a typo, another case form, the
    /// other keyboard layout) — the whole line after an arrow, so Enter never
    /// logs a line the user didn't see.
    private var ghost: String? {
        guard let s = suggestion, !text.isEmpty else { return nil }
        if s.lowercased().hasPrefix(text.lowercased()) {
            return s.count > text.count ? String(s.dropFirst(text.count)) : nil
        }
        return "\(text.hasSuffix(" ") ? "" : " ")→ \(s)"
    }

    var body: some View {
        ZStack(alignment: .topLeading) {
            if let ghost {
                Text(ghostText(ghost))
                    .frame(maxWidth: .infinity, alignment: .leading)
                    .allowsHitTesting(false)
                    .accessibilityHidden(true)
                    .background {
                        // The typed text alone, unwrapped, to measure where it
                        // ends; never drawn.
                        Text(text)
                            .fixedSize()
                            .hidden()
                            .background(GeometryReader { g in
                                Color.clear.preference(key: TypedSizeKey.self, value: g.size)
                            })
                    }
                    .onPreferenceChange(TypedSizeKey.self) { size in
                        typedWidth = size.width
                        lineHeight = size.height
                    }
            }
            // Vertical axis: a long line wraps like the logged lines do. Its
            // Return key would insert a newline, so a newline means "submit".
            // A pasted list ("курица 100⏎рис 50") keeps one food per line,
            // as "; " — the separator that always splits (see splitLine).
            TextField("Введите продукт…", text: $text, axis: .vertical)
                .focused(focus)
                .accessibilityIdentifier("line")
                .submitLabel(.go)
                .autocorrectionDisabled()
                .foregroundStyle(Palette.text)
                .onChange(of: text) { old, new in
                    let breaks = new.filter(\.isNewline).count
                    guard breaks > 0 else { return }
                    let line = new.filter { !$0.isNewline }
                    // Return: one newline, at the end or just put in where the
                    // caret was. Anything else came pasted.
                    let isReturn = breaks == 1 && (new.last?.isNewline == true || line == old)
                    if !isReturn {
                        text = new.split(whereSeparator: \.isNewline)
                            .map { $0.trimmingCharacters(in: .whitespaces) }
                            .filter { !$0.isEmpty }
                            .joined(separator: "; ")
                        return
                    }
                    text = line
                    if line.trimmingCharacters(in: .whitespaces).isEmpty {
                        focus.wrappedValue = false
                    } else {
                        onSubmit(line)
                    }
                }
                .accessibilityHint(suggestion.map { L("Подсказка: \($0)") } ?? "")
            // Over the field, a tap target where the grey text is: to the
            // right of the typed text on its line, and anything below it.
            // The typed text itself stays the field's (caret, selection).
            if ghost != nil, let onGhostTap {
                GeometryReader { g in
                    // Typed text that wraps has no measurable end: no target.
                    if typedWidth < g.size.width {
                        Color.clear
                            .contentShape(Rectangle())
                            .frame(width: g.size.width - typedWidth, height: lineHeight)
                            .offset(x: typedWidth)
                            .onTapGesture(perform: onGhostTap)
                            .accessibilityElement()
                            .accessibilityLabel(L("Другие варианты"))
                            .accessibilityIdentifier("ghost")
                        if g.size.height > lineHeight {
                            Color.clear
                                .contentShape(Rectangle())
                                .frame(width: g.size.width, height: g.size.height - lineHeight)
                                .offset(y: lineHeight)
                                .onTapGesture(perform: onGhostTap)
                        }
                    }
                }
            }
        }
        .font(.title3)
    }

    private struct TypedSizeKey: PreferenceKey {
        static let defaultValue = CGSize.zero
        static func reduce(value: inout CGSize, nextValue: () -> CGSize) { value = nextValue() }
    }

    private func ghostText(_ ghost: String) -> AttributedString {
        var typed = AttributedString(text)
        typed.foregroundColor = .clear
        var rest = AttributedString(ghost)
        rest.foregroundColor = Palette.textTertiary
        return typed + rest
    }
}

    private var matchList: some View {
        MatchList(items: matches) { f in
            closeList()
            pick(f)
        }
    }

import SwiftUI

struct StadiumRing {
    /// eaten / target, not clamped: past 1 the ring goes round a second lap
    /// over itself, Apple-Fitness style, so an overshoot reads as "how much over".
    var progress: Double
    var color: Color
}

/// Nested progress tracks in a capsule shape, outer to inner — the diary's
/// pinned summary. Each ring fills clockwise from the top center; `content`
/// sits in the empty middle. Progress changes animate from the previous
/// values, so flipping Д/Н/М or adding an entry reads as the rings moving.
struct StadiumRings<Content: View>: View {
    var rings: [StadiumRing]
    var strokeWidth: CGFloat = 13
    var gap: CGFloat = 3
    @ViewBuilder var content: Content
    @Environment(\.colorScheme) private var scheme

    var body: some View {
        ZStack {
            ZStack {
                ForEach(rings.indices, id: \.self) { i in
                    let ring = rings[i]
                    let inset = strokeWidth / 2 + CGFloat(i) * (strokeWidth + gap)
                    let p = max(0, ring.progress)
                    let style = StrokeStyle(lineWidth: strokeWidth, lineCap: .round)
                    let shape = StadiumShape(inset: inset)
                    ZStack {
                        shape.stroke(Palette.track(ring.color, dark: scheme == .dark), style: style)
                        shape.trim(from: 0, to: min(p, 1)).stroke(ring.color, style: style)
                        // Second lap over the full ring. The lap's end would
                        // vanish against the same colour underneath, so a
                        // short blurred dark stretch of the path sits just
                        // ahead of its tip — only there, never along the
                        // ring. Both are always present and trimmed, so they
                        // sweep along the path as the value animates.
                        let over = min(max(p - 1, 0), 0.999)
                        shape.trim(from: over, to: min(over + 0.012, 1))
                            .stroke(Palette.ringShadow.opacity(p > 1 ? 1 : 0), style: style)
                            .blur(radius: strokeWidth * 0.3)
                        shape.trim(from: 0, to: over).stroke(ring.color, style: style)
                    }
                    .animation(Motion.stadium, value: p)
                }
            }
            content
                .padding(CGFloat(rings.count) * (strokeWidth + gap) + 4)
        }
    }
}

/// A capsule path that starts at the top center and runs clockwise — the
/// same origin and direction as a clock-face ring.
struct StadiumShape: Shape {
    var inset: CGFloat

    func path(in bounds: CGRect) -> Path {
        let r = bounds.insetBy(dx: inset, dy: inset)
        guard r.width > 0, r.height > 0 else { return Path() }
        let radius = min(r.width, r.height) / 2
        var p = Path()
        p.move(to: CGPoint(x: r.midX, y: r.minY))
        p.addLine(to: CGPoint(x: r.maxX - radius, y: r.minY))
        p.addArc(center: CGPoint(x: r.maxX - radius, y: r.midY), radius: radius, startAngle: .degrees(-90), endAngle: .degrees(90), clockwise: false)
        p.addLine(to: CGPoint(x: r.minX + radius, y: r.maxY))
        p.addArc(center: CGPoint(x: r.minX + radius, y: r.midY), radius: radius, startAngle: .degrees(90), endAngle: .degrees(270), clockwise: false)
        p.addLine(to: CGPoint(x: r.midX, y: r.minY))
        return p
    }
}

struct SummaryPanel: View {
    @Environment(DiaryStore.self) private var store
    let dayKey: String
    @Binding var period: SummaryPeriod

    var body: some View {
        let targets = store.profile.targets
        let total = switch period {
        case .day: store.summary(dayKey...dayKey, average: false)
        case .week: store.summary(DayKeys.weekRange(dayKey), average: true)
        case .month: store.summary(DayKeys.monthRange(dayKey), average: true)
        }
        VStack(spacing: 14) {
            PeriodToggle(period: $period)
            StadiumRings(rings: [
                StadiumRing(progress: ratio(total.kcal, targets.kcal), color: Palette.kcal),
                StadiumRing(progress: ratio(total.protein, targets.protein), color: Palette.protein),
                StadiumRing(progress: ratio(total.fat, targets.fat), color: Palette.fat),
                StadiumRing(progress: ratio(total.carbs, targets.carbs), color: Palette.carbs),
            ]) {
                VStack(spacing: 2) {
                    Text("\(Text("Ккал").foregroundStyle(Palette.kcalInk)) \(formatKcal(total.kcal))")
                    Text("\(Text("Б").foregroundStyle(Palette.proteinInk)) \(formatGrams(total.protein))   \(Text("Ж").foregroundStyle(Palette.fatInk)) \(formatGrams(total.fat))   \(Text("У").foregroundStyle(Palette.carbsInk)) \(formatGrams(total.carbs))")
                }
                .font(.title2.weight(.medium))
                .monospacedDigit()
                .foregroundStyle(Palette.text)
                .contentTransition(.numericText())
                .animation(Motion.number, value: total)
                .lineLimit(1)
                .minimumScaleFactor(0.5)
            }
            .frame(height: 212)
            .accessibilityElement(children: .ignore)
            .accessibilityLabel("\(L("Калории")) \(formatKcal(total.kcal)), \(L("Белки")) \(formatGrams(total.protein)), \(L("Жиры")) \(formatGrams(total.fat)), \(L("Углеводы")) \(formatGrams(total.carbs))")
        }
        .padding(.horizontal, 12)
        .padding(.vertical, 8)
    }
}

/// iOS-style segmented pill: a thumb that slides under the chosen letter.
struct PeriodToggle: View {
    @Binding var period: SummaryPeriod
    @Namespace private var thumb

    var body: some View {
        HStack(spacing: 0) {
            ForEach(SummaryPeriod.allCases) { p in
                Text(p.letter)
                    .font(.body.weight(.semibold))
                    .foregroundStyle(p == period ? Palette.bg : Palette.textSecondary)
                    .padding(.horizontal, 8)
                    .frame(minWidth: 46, minHeight: 32)
                    .background {
                        if p == period {
                            Capsule().fill(Palette.text).matchedGeometryEffect(id: "thumb", in: thumb)
                        }
                    }
                    .contentShape(Rectangle())
                    .onTapGesture { withAnimation(Motion.pill) { period = p } }
                    .accessibilityLabel(p.fullName)
                    .accessibilityAddTraits(p == period ? [.isButton, .isSelected] : .isButton)
            }
        }
        .padding(2)
        .background(Capsule().fill(Palette.surfaceMuted))
        .sensoryFeedback(.selection, trigger: period)
    }
}

import SwiftUI

/// Nested circular progress rings, outer to inner, Apple-Fitness style —
/// the statistics screen's picture of a period. Each fills clockwise from
/// the top; a ring past its target stays full (the diary's stadium rings
/// show the overshoot, here the numbers do).
struct ActivityRings<Content: View>: View {
    var rings: [StadiumRing]
    var strokeWidth: CGFloat = 8
    var gap: CGFloat = 3
    @ViewBuilder var content: Content
    @Environment(\.colorScheme) private var scheme

    init(rings: [StadiumRing], strokeWidth: CGFloat = 8, gap: CGFloat = 3, @ViewBuilder content: () -> Content = { EmptyView() }) {
        self.rings = rings
        self.strokeWidth = strokeWidth
        self.gap = gap
        self.content = content()
    }

    var body: some View {
        ZStack {
            ForEach(rings.indices, id: \.self) { i in
                let ring = rings[i]
                let inset = strokeWidth / 2 + CGFloat(i) * (strokeWidth + gap)
                let p = min(max(ring.progress, 0), 1)
                Circle()
                    .inset(by: inset)
                    .stroke(Palette.track(ring.color, dark: scheme == .dark), lineWidth: strokeWidth)
                Circle()
                    .inset(by: inset)
                    .trim(from: 0, to: p)
                    .stroke(ring.color, style: StrokeStyle(lineWidth: strokeWidth, lineCap: .round))
                    .rotationEffect(.degrees(-90))
                    .animation(Motion.rings, value: p)
            }
            content
        }
        .aspectRatio(1, contentMode: .fit)
    }
}

/// The four rings for a total against the day's targets.
func ringsFor(_ n: Nutrition, targets: Nutrition) -> [StadiumRing] {
    func ratio(_ v: Double, _ t: Double) -> Double { t > 0 ? v / t : 0 }
    return [
        StadiumRing(progress: ratio(n.kcal, targets.kcal), color: Palette.kcal),
        StadiumRing(progress: ratio(n.protein, targets.protein), color: Palette.protein),
        StadiumRing(progress: ratio(n.fat, targets.fat), color: Palette.fat),
        StadiumRing(progress: ratio(n.carbs, targets.carbs), color: Palette.carbs),
    ]
}

    private func tile(_ label: String, _ value: String, color: Color) -> some View {
        VStack(alignment: .leading, spacing: 2) {
            Text(label).font(.subheadline).foregroundStyle(Palette.textSecondary)
            Text(value).font(.title.weight(.medium)).monospacedDigit().foregroundStyle(color)
                .contentTransition(.numericText())
        }
        .frame(maxWidth: .infinity, alignment: .leading)
        .padding(.horizontal, 16)
        .padding(.vertical, 14)
        .background(Palette.surface, in: RoundedRectangle(cornerRadius: Radius.card, style: .continuous))
        .accessibilityElement(children: .combine)
    }

import SwiftUI

/// What was just deleted, kept for a few seconds so "Вернуть" can put it
/// back. Several deletes in a row stack up; one tap restores them all —
/// nothing deleted while the bar is up is ever lost.
@MainActor
@Observable
final class PendingUndo<Item> {
    private(set) var items: [Item] = []
    private var expiry: Task<Void, Never>?

    static var window: Duration { .seconds(4) }

    func add(_ item: Item) {
        withAnimation { items.append(item) }
        expiry?.cancel()
        expiry = Task { [weak self] in
            try? await Task.sleep(for: Self.window)
            guard !Task.isCancelled else { return }
            withAnimation { self?.items = [] }
        }
    }

    /// Everything pending, most recent last; the bar goes down.
    func take() -> [Item] {
        expiry?.cancel()
        let all = items
        withAnimation { items = [] }
        return all
    }
}

/// "Удалено — Вернуть" at the bottom of a screen while something can still
/// be brought back.
struct UndoBar: View {
    var shown: Bool
    var restore: () -> Void

    var body: some View {
        if shown {
            HStack {
                Text("Удалено").foregroundStyle(Palette.text)
                Spacer()
                Button("Вернуть", action: restore)
                    .fontWeight(.semibold)
                    .foregroundStyle(Palette.accent)
            }
            .padding(.horizontal, 20)
            .padding(.vertical, 14)
            .background(.regularMaterial, in: Capsule())
            .padding(.horizontal, 16)
            .padding(.bottom, 8)
            .transition(.move(edge: .bottom).combined(with: .opacity))
        }
    }
}

/// A form row with a number at the right, saved when editing ends — or
/// when the screen goes away mid-edit. Text that isn't a number leaves the
/// stored value alone, and the row shows it again.
private struct NumberRow: View {
    let label: String
    let stored: String
    let unit: String
    let decimal: Bool
    let color: Color
    let save: (String) -> Void
    @State private var text = ""
    @FocusState private var focused: Bool

    var body: some View {
        HStack {
            Text(label).foregroundStyle(color)
            Spacer()
            TextField("—", text: $text)
                .accessibilityIdentifier("field.\(label)")
                .keyboardType(decimal ? .decimalPad : .numberPad)
                .multilineTextAlignment(.trailing)
                .frame(width: 90)
                .focused($focused)
                .onAppear { text = stored }
                .onChange(of: stored) { if !focused { text = stored } }
                .onChange(of: focused) { if !focused { commit() } }
                .onDisappear { if focused { commit() } }
            Text(unit).foregroundStyle(Palette.textSecondary)
        }
    }

    private func commit() {
        save(text)
        // Whatever was stored after the save (the new number, or the old
        // one when the text wasn't a number) is what the row shows.
        DispatchQueue.main.async { text = stored }
    }
}

/// The system share sheet.
private struct ActivityView: UIViewControllerRepresentable {
    let items: [Any]
    func makeUIViewController(context: Context) -> UIActivityViewController {
        UIActivityViewController(activityItems: items, applicationActivities: nil)
    }
    func updateUIViewController(_ vc: UIActivityViewController, context: Context) {}
}

    private func numberField(_ value: Binding<String>, _ label: String, _ color: Color, _ field: Field) -> some View {
        VStack(alignment: .leading, spacing: 2) {
            TextField("0", text: value)
                .font(.largeTitle)
                .monospacedDigit()
                .keyboardType(.decimalPad)
                .focused($focus, equals: field)
            Text(label)
                .font(.subheadline)
                .foregroundStyle(color)
        }
        .frame(maxWidth: .infinity, alignment: .leading)
    }