workouts/Workouts/Views/WorkoutLogs/PlanEditView.swift

//
// PlanEditView.swift
// Workouts
//
// Copyright 2025 Rouslan Zenetl. All Rights Reserved.
//

import SwiftUI
import SwiftData

struct PlanEditView: View {
    @Environment(SyncEngine.self) private var sync
    @Environment(\.modelContext) private var modelContext
    @Environment(\.dismiss) private var dismiss

    let workout: Workout
    let logID: String

    @State private var sets: Int = 3
    @State private var reps: Int = 12
    @State private var weight: Int = 0
    @State private var durationMinutes: Int = 0
    @State private var durationSeconds: Int = 0
    @State private var selectedLoadType: LoadType = .weight
    @AppStorage("weightUnit") private var weightUnit: WeightUnit = .lb

    var body: some View {
        NavigationStack {
            Form {
                // Sets and Reps side by side
                Section {
                    HStack(spacing: 20) {
                        VStack {
                            Text("Sets")
                                .font(.headline)
                                .foregroundColor(.secondary)
                            Picker("Sets", selection: $sets) {
                                ForEach(1...7, id: \.self) { num in
                                    Text("\(num)").tag(num)
                                }
                            }
                            .pickerStyle(.wheel)
                            .frame(height: 120)
                        }
                        .frame(maxWidth: .infinity)

                        VStack {
                            Text("Reps")
                                .font(.headline)
                                .foregroundColor(.secondary)
                            Picker("Reps", selection: $reps) {
                                ForEach(1...40, id: \.self) { num in
                                    Text("\(num)").tag(num)
                                }
                            }
                            .pickerStyle(.wheel)
                            .frame(height: 120)
                        }
                        .frame(maxWidth: .infinity)
                    }
                }

                // Load Type Picker
                Section {
                    Picker("Load Type", selection: $selectedLoadType) {
                        Text("Weight").tag(LoadType.weight)
                        Text("Time").tag(LoadType.duration)
                    }
                    .pickerStyle(.segmented)
                }

                // Weight or Time picker based on load type
                Section {
                    if selectedLoadType == .weight {
                        VStack {
                            Text("Weight")
                                .font(.headline)
                                .foregroundColor(.secondary)
                            Picker("Weight", selection: $weight) {
                                ForEach(0...300, id: \.self) { num in
                                    Text(weightUnit.format(num)).tag(num)
                                }
                            }
                            .pickerStyle(.wheel)
                            .frame(height: 150)
                        }
                    } else {
                        HStack(spacing: 20) {
                            VStack {
                                Text("Mins")
                                    .font(.headline)
                                    .foregroundColor(.secondary)
                                Picker("Minutes", selection: $durationMinutes) {
                                    ForEach(0...60, id: \.self) { num in
                                        Text("\(num)").tag(num)
                                    }
                                }
                                .pickerStyle(.wheel)
                                .frame(height: 120)
                            }
                            .frame(maxWidth: .infinity)

                            VStack {
                                Text("Secs")
                                    .font(.headline)
                                    .foregroundColor(.secondary)
                                Picker("Seconds", selection: $durationSeconds) {
                                    ForEach(0...59, id: \.self) { num in
                                        Text("\(num)").tag(num)
                                    }
                                }
                                .pickerStyle(.wheel)
                                .frame(height: 120)
                            }
                            .frame(maxWidth: .infinity)
                        }
                    }
                }
            }
            .navigationTitle("Edit Plan")
            .navigationBarTitleDisplayMode(.inline)
            .toolbar {
                ToolbarItem(placement: .cancellationAction) {
                    Button("Cancel") {
                        dismiss()
                    }
                }
                ToolbarItem(placement: .confirmationAction) {
                    Button("Save") {
                        saveChanges()
                        dismiss()
                    }
                }
            }
            .onAppear {
                if let log = WorkoutDocument(from: workout).logs.first(where: { $0.id == logID }) {
                    sets = log.sets
                    reps = log.reps
                    // The picker steps whole values; a fractional stored weight
                    // shows (and saves back) its whole part until UX #3's UI lands.
                    weight = Int(log.weight)
                    durationMinutes = log.durationSeconds / 60
                    durationSeconds = log.durationSeconds % 60
                    selectedLoadType = LoadType(rawValue: log.loadType) ?? .weight
                }
            }
        }
    }

    private func saveChanges() {
        let totalSeconds = durationMinutes * 60 + durationSeconds

        // 1) Update the log within the parent workout document.
        var doc = WorkoutDocument(from: workout)
        guard let i = doc.logs.firstIndex(where: { $0.id == logID }) else { return }
        doc.logs[i].sets = sets
        doc.logs[i].reps = reps
        doc.logs[i].weight = Double(weight)
        doc.logs[i].durationSeconds = totalSeconds
        doc.logs[i].loadType = selectedLoadType.rawValue
        doc.logs[i].touch()
        doc.updatedAt = Date()
        let exerciseName = doc.logs[i].exerciseName
        let workoutDoc = doc

        // 2) Mirror the plan onto the matching exercise in the routine template,
        // following the seed clone-on-edit redirect so a prior fork doesn't
        // silently break the mirror.
        var routineDoc: RoutineDocument?
        if let routineID = doc.routineID,
           let routine = CacheMapper.fetchRoutine(id: sync.currentRoutineID(for: routineID), in: modelContext) {
            var sDoc = RoutineDocument(from: routine)
            if let ei = sDoc.exercises.firstIndex(where: { $0.name == exerciseName }) {
                sDoc.exercises[ei].sets = sets
                sDoc.exercises[ei].reps = reps
                sDoc.exercises[ei].weight = Double(weight)
                sDoc.exercises[ei].durationSeconds = totalSeconds
                sDoc.exercises[ei].loadType = selectedLoadType.rawValue
                sDoc.updatedAt = Date()
                routineDoc = sDoc
            }
        }

        Task {
            await sync.save(workout: workoutDoc)
            if let routineDoc {
                await sync.save(routine: routineDoc)
            }
        }
    }
}