A!leys Galerie

import SwiftUI
import CoreHaptics

struct BreathingSession: Identifiable, Codable {
    let id: UUID
    var duration: TimeInterval
    var completedCycles: Int
    var date: Date

    init() {
        self.id = UUID()
        self.duration = 0
        self.completedCycles = 0
        self.date = Date()
    }
}

class HapticEngine {
    private var engine: CHHapticEngine?
    private let intensity = CHHapticEventParameter(parameterID: .hapticIntensity, value: 0.5)

    func start() {
        guard CHHapticEngine.capabilitiesForHardware().supportsHaptics else { return }

        do {
            engine = try CHHapticEngine()
            try engine?.start()
        } catch {
            print("Haptic engine error: \(error.localizedDescription)")
        }
    }

    func triggerImpact() {
        guard engine != nil else { return }

        let pattern = try? CHHapticPattern(events: [CHHapticEvent(eventType: .hapticContinuous, parameters: [intensity], relativeTime: 0)])

        let player = try? engine?.makePlayer(with: pattern)
        player?.scheduleParameters(.init(relativeTime: 0, parameterValues: [0.1]))
    }

    func stop() {
        engine?.stop(completionHandler: { _ in
            self.engine = nil
        })
    }
}

class SessionStore: ObservableObject {
    @Published var sessions: [BreathingSession] = []
    @Published var bestStreak: Int = 0

    private let key = "breathingSessions"
    private let bestStreakKey = "bestStreak"

    init() {
        load()
    }

    func save() {
        if let encoded = try? JSONEncoder().encode(sessions) {
            UserDefaults.standard.set(encoded, forKey: key)
        }

        UserDefaults.standard.set(bestStreak, forKey: bestStreakKey)
    }

    func load() {
        if let data = UserDefaults.standard.data(forKey: key),
           let decoded = try? JSONDecoder().decode([BreathingSession].self, from: data) {
            sessions = decoded
        }

        bestStreak = UserDefaults.standard.integer(forKey: bestStreakKey)
    }

    func addSession(_ session: BreathingSession) {
        sessions.append(session)
        updateBestStreak()
        save()
    }

    func updateBestStreak() {
        guard !sessions.isEmpty else { bestStreak = 0; return }

        let todaySessions = sessions.filter { Calendar.current.isDate($0.date, inSameDayAs: Date()) }
        let todayCount = todaySessions.count

        if todayCount > bestStreak {
            bestStreak = todayCount
        }

        save()
    }
}

struct BreathingView: View {
    @StateObject private var sessionStore = SessionStore()
    @State private var timer: Timer?
    @State private var secondsRemaining: Int = 300
    @State private var currentPhase: Int = 0
    @State private var isRunning = false
    @State private var hapticEngine = HapticEngine()

    private let phases = ["Inhale (4)", "Hold (7)", "Exhale (8)"]
    private let phaseDurations = [4.0, 7.0, 8.0]
    private let totalDuration = 4.0 + 7.0 + 8.0

    private var progress: Double {
        (totalDuration - Double(secondsRemaining)) / totalDuration
    }

    var body: some View {
        ZStack {
            // Background with breathing gradient
            LinearGradient(gradient: Gradient(colors: [.blue.opacity(0.1), .purple.opacity(0.1)]),
                          startPoint: .top,
                          endPoint: .bottom)
                .edgesIgnoringSafeArea(.all)

            VStack(spacing: 0) {
                // Stats header
                HStack(spacing: 20) {
                    StatsCard(icon: "flame", title: "Today", value: "\(sessionStore.sessions.filter { Calendar.current.isDate($0.date, inSameDayAs: Date()) }.count) sessions")
                    StatsCard(icon: "trophy", title: "Streak", value: "\(sessionStore.bestStreak) days")

                    Spacer()

                    StatsCard(icon: "clock", title: "Best", value: "\(formatTime(sessionStore.sessions.max(by: { $0.duration < $1.duration })?.duration ?? 0))")
                }
                .padding()

                Spacer()

                // Main timer
                VStack(spacing: 20) {
                    // Phase label
                    Text(phases[currentPhase])
                        .font(.system(size: 24, weight: .semibold, design: .rounded))
                        .foregroundColor(.secondary)

                    // Progress ring
                    ZStack {
                        Circle()
                            .stroke(.secondary, lineWidth: 4)
                            .opacity(0.3)

                        Circle()
                            .trim(from: 0, to: CGFloat(progress))
                            .stroke(.blue, style: StrokeStyle(lineWidth: 4, lineCap: .round))
                            .rotationEffect(.degrees(-90))
                            .animation(.easeInOut(duration: 1.0), value: progress)

                        // Center timer
                        Text(formatTime(TimeInterval(secondsRemaining)))
                            .font(.system(size: 48, weight: .bold))
                            .monospacedDigit()
                            .contentTransition(.numericText())
                    }
                    .frame(width: 200, height: 200)
                    .overlay(
                        Circle()
                            .stroke(.blue, lineWidth: 2)
                            .scaleEffect(0.8)
                    )

                    // Progress bar
                    ProgressView(value: progress)
                        .progressViewStyle(LinearProgressViewStyle(tint: .blue))
                        .frame(height: 8)

                    // Controls
                    HStack(spacing: 20) {
                        Button(action: toggleTimer) {
                            Image(systemName: isRunning ? "stop.circle.fill" : "play.circle.fill")
                                .font(.system(size: 24))
                                .foregroundColor(isRunning ? .red : .green)
                        }

                        Button(action: resetTimer) {
                            Image(systemName: "arrow.clockwise")
                                .font(.system(size: 24))
                                .foregroundColor(.secondary)
                        }
                    }
                }

                Spacer()

                // Biofeedback
                HStack {
                    ForEach(0..<4) { index in
                        Rectangle()
                            .fill(index < currentPhase ? .blue : .secondary)
                            .opacity(0.5)
                            .frame(width: 12, height: 40)
                            .cornerRadius(6)
                    }
                }
                .padding(.bottom, 30)
            }
        }
        .onAppear {
            hapticEngine.start()
        }
        .onDisappear {
            hapticEngine.stop()
            timer?.invalidate()
        }
    }

    private func toggleTimer() {
        isRunning.toggle()

        if isRunning {
            timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { _ in
                if secondsRemaining > 0 {
                    secondsRemaining -= 1

                    if secondsRemaining == 0 {
                        hapticEngine.triggerImpact()
                        let session = BreathingSession()
                        session.duration = TimeInterval(300 - (300 - secondsRemaining))
                        session.completedCycles = 1
                        sessionStore.addSession(session)
                        resetTimer()
                    } else if secondsRemaining == Int(phaseDurations[currentPhase] * 2) {
                        currentPhase = (currentPhase + 1) % phases.count
                    }
                }
            }
        } else {
            timer?.invalidate()
        }
    }

    private func resetTimer() {
        isRunning = false
        secondsRemaining = 300
        currentPhase = 0
        timer?.invalidate()
        sessionStore.save()
    }

    private func formatTime(_ interval: TimeInterval) -> String {
        let minutes = Int(interval) / 60
        let seconds = Int(interval) % 60
        return String(format: "%02d:%02d", minutes, seconds)
    }
}

struct StatsCard: View {
    let icon: String
    let title: String
    let value: String

    var body: some View {
        VStack(spacing: 4) {
            Image(systemName: icon)
                .font(.system(size: 20))
                .foregroundColor(.blue)

            Text(title)
                .font(.caption)
                .foregroundColor(.secondary)

            Text(value)
                .font(.headline)
                .foregroundColor(.primary)
        }
        .frame(width: 80)
    }
}

#Preview {
    BreathingView()
}