1338 lines
46 KiB
Swift
1338 lines
46 KiB
Swift
import PhotosUI
|
|
import SwiftUI
|
|
|
|
struct AddAttemptView: View {
|
|
let session: ClimbSession
|
|
let gym: Gym
|
|
@EnvironmentObject var dataManager: ClimbingDataManager
|
|
@EnvironmentObject var themeManager: ThemeManager
|
|
@Environment(\.dismiss) private var dismiss
|
|
|
|
@State private var selectedProblem: Problem?
|
|
@State private var selectedResult: AttemptResult = .fall
|
|
@State private var highestHold = ""
|
|
@State private var notes = ""
|
|
@State private var duration: Int = 0
|
|
@State private var restTime: Int = 0
|
|
@State private var showingCreateProblem = false
|
|
|
|
// New problem creation state
|
|
@State private var newProblemName = ""
|
|
@State private var newProblemGrade = ""
|
|
@State private var selectedClimbType: ClimbType = .boulder
|
|
@State private var selectedDifficultySystem: DifficultySystem = .vScale
|
|
@State private var selectedPhotos: [PhotosPickerItem] = []
|
|
@State private var imageData: [Data] = []
|
|
|
|
enum SheetType: Identifiable {
|
|
case photoOptions
|
|
|
|
var id: Int {
|
|
switch self {
|
|
case .photoOptions: return 0
|
|
}
|
|
}
|
|
}
|
|
|
|
@State private var activeSheet: SheetType?
|
|
@State private var showCamera = false
|
|
@State private var showPhotoPicker = false
|
|
@State private var isPhotoPickerActionPending = false
|
|
@State private var isCameraActionPending = false
|
|
|
|
private var activeProblems: [Problem] {
|
|
dataManager.activeProblems(forGym: gym.id)
|
|
}
|
|
|
|
private var availableClimbTypes: [ClimbType] {
|
|
gym.supportedClimbTypes
|
|
}
|
|
|
|
private var availableDifficultySystems: [DifficultySystem] {
|
|
DifficultySystem.systemsForClimbType(selectedClimbType).filter { system in
|
|
gym.difficultySystems.contains(system)
|
|
}
|
|
}
|
|
|
|
private var availableGrades: [String] {
|
|
selectedDifficultySystem.availableGrades
|
|
}
|
|
|
|
var body: some View {
|
|
NavigationStack {
|
|
Form {
|
|
if !showingCreateProblem {
|
|
ProblemSelectionSection()
|
|
} else {
|
|
CreateProblemSection()
|
|
}
|
|
|
|
AttemptDetailsSection()
|
|
}
|
|
.navigationTitle("Add Attempt")
|
|
.navigationBarTitleDisplayMode(.inline)
|
|
.toolbar {
|
|
ToolbarItem(placement: .navigationBarLeading) {
|
|
Button("Cancel") {
|
|
dismiss()
|
|
}
|
|
}
|
|
|
|
ToolbarItem(placement: .navigationBarTrailing) {
|
|
Button("Add") {
|
|
saveAttempt()
|
|
}
|
|
.disabled(!canSave)
|
|
}
|
|
}
|
|
}
|
|
.onAppear {
|
|
setupInitialValues()
|
|
}
|
|
.onChange(of: selectedClimbType) {
|
|
updateDifficultySystem()
|
|
}
|
|
.onChange(of: selectedDifficultySystem) {
|
|
resetGradeIfNeeded()
|
|
}
|
|
.onChange(of: selectedPhotos) {
|
|
Task {
|
|
await loadSelectedPhotos()
|
|
}
|
|
}
|
|
|
|
.photosPicker(
|
|
isPresented: $showPhotoPicker,
|
|
selection: $selectedPhotos,
|
|
maxSelectionCount: 5 - imageData.count,
|
|
matching: .images
|
|
)
|
|
.sheet(
|
|
item: $activeSheet,
|
|
onDismiss: {
|
|
if isCameraActionPending {
|
|
showCamera = true
|
|
isCameraActionPending = false
|
|
return
|
|
}
|
|
if isPhotoPickerActionPending {
|
|
showPhotoPicker = true
|
|
isPhotoPickerActionPending = false
|
|
}
|
|
}
|
|
) { sheetType in
|
|
switch sheetType {
|
|
case .photoOptions:
|
|
PhotoOptionSheet(
|
|
selectedPhotos: $selectedPhotos,
|
|
imageData: $imageData,
|
|
maxImages: 5,
|
|
onCameraSelected: {
|
|
isCameraActionPending = true
|
|
activeSheet = nil
|
|
},
|
|
onPhotoLibrarySelected: {
|
|
isPhotoPickerActionPending = true
|
|
},
|
|
onDismiss: {
|
|
activeSheet = nil
|
|
}
|
|
)
|
|
}
|
|
}
|
|
.fullScreenCover(isPresented: $showCamera) {
|
|
CameraImagePicker { capturedImage in
|
|
if let jpegData = capturedImage.jpegData(compressionQuality: 0.8) {
|
|
imageData.append(jpegData)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@ViewBuilder
|
|
private func ProblemSelectionSection() -> some View {
|
|
Section("Select Problem") {
|
|
if activeProblems.isEmpty {
|
|
VStack(alignment: .leading, spacing: 12) {
|
|
Text("No active problems in this gym")
|
|
.foregroundColor(.secondary)
|
|
|
|
Button("Create New Problem") {
|
|
showingCreateProblem = true
|
|
}
|
|
.buttonStyle(.borderedProminent)
|
|
.tint(themeManager.accentColor)
|
|
}
|
|
.padding(.vertical, 8)
|
|
} else {
|
|
LazyVGrid(
|
|
columns: Array(repeating: GridItem(.flexible(), spacing: 8), count: 2),
|
|
spacing: 8
|
|
) {
|
|
ForEach(activeProblems, id: \.id) { problem in
|
|
ProblemSelectionCard(
|
|
problem: problem,
|
|
isSelected: selectedProblem?.id == problem.id
|
|
) {
|
|
selectedProblem = problem
|
|
}
|
|
}
|
|
}
|
|
.padding(.vertical, 8)
|
|
|
|
Button("Create New Problem") {
|
|
showingCreateProblem = true
|
|
}
|
|
.foregroundColor(themeManager.accentColor)
|
|
}
|
|
}
|
|
}
|
|
|
|
@ViewBuilder
|
|
private func CreateProblemSection() -> some View {
|
|
Section {
|
|
HStack {
|
|
Text("Create New Problem")
|
|
.font(.headline)
|
|
|
|
Spacer()
|
|
|
|
Button("Back") {
|
|
showingCreateProblem = false
|
|
selectedPhotos = []
|
|
imageData = []
|
|
}
|
|
.foregroundColor(themeManager.accentColor)
|
|
}
|
|
}
|
|
|
|
Section("Problem Details") {
|
|
TextField("Problem Name", text: $newProblemName)
|
|
}
|
|
|
|
Section("Climb Type") {
|
|
ForEach(availableClimbTypes, id: \.self) { climbType in
|
|
HStack {
|
|
Text(climbType.displayName)
|
|
Spacer()
|
|
if selectedClimbType == climbType {
|
|
Image(systemName: "checkmark.circle.fill")
|
|
.foregroundColor(themeManager.accentColor)
|
|
} else {
|
|
Image(systemName: "circle")
|
|
.foregroundColor(.gray)
|
|
}
|
|
}
|
|
.contentShape(Rectangle())
|
|
.onTapGesture {
|
|
selectedClimbType = climbType
|
|
}
|
|
}
|
|
}
|
|
|
|
Section("Difficulty") {
|
|
VStack(alignment: .leading, spacing: 12) {
|
|
Text("Difficulty System")
|
|
.font(.subheadline)
|
|
.fontWeight(.medium)
|
|
|
|
ForEach(availableDifficultySystems, id: \.self) { system in
|
|
HStack {
|
|
Text(system.displayName)
|
|
Spacer()
|
|
if selectedDifficultySystem == system {
|
|
Image(systemName: "checkmark.circle.fill")
|
|
.foregroundColor(themeManager.accentColor)
|
|
} else {
|
|
Image(systemName: "circle")
|
|
.foregroundColor(.gray)
|
|
}
|
|
}
|
|
.contentShape(Rectangle())
|
|
.onTapGesture {
|
|
selectedDifficultySystem = system
|
|
}
|
|
}
|
|
}
|
|
|
|
if selectedDifficultySystem == .custom {
|
|
TextField("Grade (Required - numbers only)", text: $newProblemGrade)
|
|
.keyboardType(.numberPad)
|
|
.onChange(of: newProblemGrade) {
|
|
// Filter out non-numeric characters
|
|
newProblemGrade = newProblemGrade.filter { $0.isNumber }
|
|
}
|
|
} else {
|
|
VStack(alignment: .leading, spacing: 8) {
|
|
Text("Grade (Required)")
|
|
.font(.subheadline)
|
|
.fontWeight(.medium)
|
|
|
|
ScrollView(.horizontal, showsIndicators: false) {
|
|
LazyHStack(spacing: 8) {
|
|
ForEach(availableGrades, id: \.self) { grade in
|
|
Button(grade) {
|
|
newProblemGrade = grade
|
|
}
|
|
.buttonStyle(.bordered)
|
|
.controlSize(.small)
|
|
.tint(newProblemGrade == grade ? themeManager.accentColor : .gray)
|
|
}
|
|
}
|
|
.padding(.horizontal, 1)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Section("Photos (Optional)") {
|
|
Button(action: {
|
|
activeSheet = .photoOptions
|
|
}) {
|
|
HStack {
|
|
Image(systemName: "camera.fill")
|
|
.foregroundColor(themeManager.accentColor)
|
|
.font(.title2)
|
|
VStack(alignment: .leading, spacing: 2) {
|
|
Text("Add Photos")
|
|
.font(.headline)
|
|
.foregroundColor(themeManager.accentColor)
|
|
Text("\(imageData.count) of 5 photos added")
|
|
.font(.caption)
|
|
.foregroundColor(.secondary)
|
|
}
|
|
Spacer()
|
|
Image(systemName: "chevron.right")
|
|
.foregroundColor(.secondary)
|
|
.font(.caption)
|
|
}
|
|
.padding(.vertical, 4)
|
|
}
|
|
.disabled(imageData.count >= 5)
|
|
|
|
if !imageData.isEmpty {
|
|
ScrollView(.horizontal, showsIndicators: false) {
|
|
HStack(spacing: 12) {
|
|
ForEach(imageData.indices, id: \.self) { index in
|
|
if let uiImage = UIImage(data: imageData[index]) {
|
|
Image(uiImage: uiImage)
|
|
.resizable()
|
|
.aspectRatio(contentMode: .fill)
|
|
.frame(width: 80, height: 80)
|
|
.clipped()
|
|
.cornerRadius(8)
|
|
.overlay(alignment: .topTrailing) {
|
|
Button(action: {
|
|
imageData.remove(at: index)
|
|
}) {
|
|
Image(systemName: "xmark.circle.fill")
|
|
.foregroundColor(.red)
|
|
.background(Circle().fill(.white))
|
|
}
|
|
.offset(x: 8, y: -8)
|
|
}
|
|
} else {
|
|
RoundedRectangle(cornerRadius: 8)
|
|
.fill(.gray.opacity(0.3))
|
|
.frame(width: 80, height: 80)
|
|
.overlay {
|
|
Image(systemName: "photo")
|
|
.foregroundColor(.gray)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
.padding(.horizontal, 1)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@ViewBuilder
|
|
private func AttemptDetailsSection() -> some View {
|
|
Section("Attempt Result") {
|
|
ForEach(AttemptResult.allCases, id: \.self) { result in
|
|
HStack {
|
|
Text(result.displayName)
|
|
Spacer()
|
|
if selectedResult == result {
|
|
Image(systemName: "checkmark.circle.fill")
|
|
.foregroundColor(themeManager.accentColor)
|
|
} else {
|
|
Image(systemName: "circle")
|
|
.foregroundColor(.gray)
|
|
}
|
|
}
|
|
.contentShape(Rectangle())
|
|
.onTapGesture {
|
|
selectedResult = result
|
|
}
|
|
}
|
|
}
|
|
|
|
Section("Additional Details") {
|
|
TextField("Highest Hold (Optional)", text: $highestHold)
|
|
|
|
VStack(alignment: .leading, spacing: 8) {
|
|
Text("Notes (Optional)")
|
|
.font(.headline)
|
|
|
|
TextEditor(text: $notes)
|
|
.frame(minHeight: 80)
|
|
.padding(8)
|
|
.background(
|
|
RoundedRectangle(cornerRadius: 8)
|
|
.fill(.quaternary)
|
|
)
|
|
}
|
|
|
|
HStack {
|
|
Text("Duration (seconds)")
|
|
Spacer()
|
|
TextField("0", value: $duration, format: .number)
|
|
.keyboardType(.numberPad)
|
|
.textFieldStyle(.roundedBorder)
|
|
.frame(width: 80)
|
|
}
|
|
|
|
HStack {
|
|
Text("Rest Time (seconds)")
|
|
Spacer()
|
|
TextField("0", value: $restTime, format: .number)
|
|
.keyboardType(.numberPad)
|
|
.textFieldStyle(.roundedBorder)
|
|
.frame(width: 80)
|
|
}
|
|
}
|
|
}
|
|
|
|
private var canSave: Bool {
|
|
if showingCreateProblem {
|
|
return !newProblemGrade.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
|
|
} else {
|
|
return selectedProblem != nil
|
|
}
|
|
}
|
|
|
|
private func setupInitialValues() {
|
|
// Auto-select climb type if there's only one available
|
|
if gym.supportedClimbTypes.count == 1 {
|
|
selectedClimbType = gym.supportedClimbTypes.first!
|
|
}
|
|
|
|
updateDifficultySystem()
|
|
}
|
|
|
|
private func updateDifficultySystem() {
|
|
let available = availableDifficultySystems
|
|
|
|
if !available.contains(selectedDifficultySystem) {
|
|
selectedDifficultySystem = available.first ?? .custom
|
|
}
|
|
|
|
if available.count == 1 {
|
|
selectedDifficultySystem = available.first!
|
|
}
|
|
}
|
|
|
|
private func resetGradeIfNeeded() {
|
|
let availableGrades = selectedDifficultySystem.availableGrades
|
|
if !availableGrades.isEmpty && !availableGrades.contains(newProblemGrade) {
|
|
newProblemGrade = ""
|
|
}
|
|
}
|
|
|
|
private func loadSelectedPhotos() async {
|
|
var newImageData: [Data] = []
|
|
|
|
for item in selectedPhotos {
|
|
if let data = try? await item.loadTransferable(type: Data.self) {
|
|
newImageData.append(data)
|
|
}
|
|
}
|
|
|
|
await MainActor.run {
|
|
imageData.append(contentsOf: newImageData)
|
|
selectedPhotos.removeAll()
|
|
}
|
|
}
|
|
|
|
private func saveAttempt() {
|
|
if showingCreateProblem {
|
|
let difficulty = DifficultyGrade(
|
|
system: selectedDifficultySystem, grade: newProblemGrade)
|
|
|
|
let newProblem = Problem(
|
|
gymId: gym.id,
|
|
name: newProblemName.isEmpty ? nil : newProblemName,
|
|
climbType: selectedClimbType,
|
|
difficulty: difficulty,
|
|
imagePaths: []
|
|
)
|
|
|
|
dataManager.addProblem(newProblem)
|
|
|
|
if !imageData.isEmpty {
|
|
var imagePaths: [String] = []
|
|
|
|
for (index, data) in imageData.enumerated() {
|
|
let deterministicName = ImageNamingUtils.generateImageFilename(
|
|
problemId: newProblem.id.uuidString, imageIndex: index)
|
|
|
|
if let relativePath = ImageManager.shared.saveImageData(
|
|
data, withName: deterministicName)
|
|
{
|
|
imagePaths.append(relativePath)
|
|
}
|
|
}
|
|
|
|
if !imagePaths.isEmpty {
|
|
let updatedProblem = newProblem.updated(imagePaths: imagePaths)
|
|
dataManager.updateProblem(updatedProblem)
|
|
}
|
|
}
|
|
|
|
let attempt = Attempt(
|
|
sessionId: session.id,
|
|
problemId: newProblem.id,
|
|
result: selectedResult,
|
|
highestHold: highestHold.isEmpty ? nil : highestHold,
|
|
notes: notes.isEmpty ? nil : notes,
|
|
duration: duration == 0 ? nil : duration,
|
|
restTime: restTime == 0 ? nil : restTime,
|
|
timestamp: Date()
|
|
)
|
|
|
|
dataManager.addAttempt(attempt)
|
|
} else {
|
|
guard let problem = selectedProblem else { return }
|
|
|
|
let attempt = Attempt(
|
|
sessionId: session.id,
|
|
problemId: problem.id,
|
|
result: selectedResult,
|
|
highestHold: highestHold.isEmpty ? nil : highestHold,
|
|
notes: notes.isEmpty ? nil : notes,
|
|
duration: duration > 0 ? duration : nil,
|
|
restTime: restTime > 0 ? restTime : nil
|
|
)
|
|
|
|
dataManager.addAttempt(attempt)
|
|
}
|
|
|
|
// Clear photo states after saving
|
|
selectedPhotos = []
|
|
imageData = []
|
|
|
|
dismiss()
|
|
}
|
|
|
|
}
|
|
|
|
struct ProblemSelectionRow: View {
|
|
let problem: Problem
|
|
let isSelected: Bool
|
|
let action: () -> Void
|
|
@EnvironmentObject var themeManager: ThemeManager
|
|
|
|
var body: some View {
|
|
HStack {
|
|
VStack(alignment: .leading, spacing: 4) {
|
|
Text(problem.name ?? "Unnamed Problem")
|
|
.font(.headline)
|
|
.fontWeight(.medium)
|
|
|
|
Text("\(problem.difficulty.system.displayName): \(problem.difficulty.grade)")
|
|
.font(.subheadline)
|
|
.foregroundColor(themeManager.accentColor)
|
|
|
|
if let location = problem.location {
|
|
Text(location)
|
|
.font(.caption)
|
|
.foregroundColor(.secondary)
|
|
}
|
|
}
|
|
|
|
Spacer()
|
|
|
|
if isSelected {
|
|
Image(systemName: "checkmark.circle.fill")
|
|
.foregroundColor(themeManager.accentColor)
|
|
} else {
|
|
Image(systemName: "circle")
|
|
.foregroundColor(.gray)
|
|
}
|
|
}
|
|
.contentShape(Rectangle())
|
|
.onTapGesture(perform: action)
|
|
.padding(.vertical, 4)
|
|
}
|
|
}
|
|
|
|
struct ProblemSelectionCard: View {
|
|
let problem: Problem
|
|
let isSelected: Bool
|
|
let action: () -> Void
|
|
@State private var showingExpandedView = false
|
|
@EnvironmentObject var themeManager: ThemeManager
|
|
|
|
var body: some View {
|
|
VStack(spacing: 8) {
|
|
// Image section
|
|
ZStack {
|
|
if let firstImagePath = problem.imagePaths.first {
|
|
ProblemSelectionImageView(imagePath: firstImagePath)
|
|
} else {
|
|
RoundedRectangle(cornerRadius: 8)
|
|
.fill(.gray.opacity(0.2))
|
|
.frame(height: 80)
|
|
.overlay {
|
|
Image(systemName: "mountain.2.fill")
|
|
.foregroundColor(.gray)
|
|
.font(.title2)
|
|
}
|
|
}
|
|
|
|
// Selection indicator
|
|
VStack {
|
|
HStack {
|
|
Spacer()
|
|
if isSelected {
|
|
Image(systemName: "checkmark.circle.fill")
|
|
.foregroundColor(.white)
|
|
.background(Circle().fill(themeManager.accentColor))
|
|
.font(.title3)
|
|
}
|
|
}
|
|
Spacer()
|
|
}
|
|
.padding(6)
|
|
|
|
// Multiple images indicator
|
|
if problem.imagePaths.count > 1 {
|
|
VStack {
|
|
Spacer()
|
|
HStack {
|
|
Spacer()
|
|
Text("+\(problem.imagePaths.count - 1)")
|
|
.font(.caption2)
|
|
.fontWeight(.bold)
|
|
.foregroundColor(.white)
|
|
.padding(.horizontal, 6)
|
|
.padding(.vertical, 2)
|
|
.background(
|
|
RoundedRectangle(cornerRadius: 4)
|
|
.fill(.black.opacity(0.6))
|
|
)
|
|
}
|
|
}
|
|
.padding(6)
|
|
}
|
|
}
|
|
|
|
// Problem info
|
|
VStack(alignment: .leading, spacing: 4) {
|
|
Text(problem.name ?? "Unnamed")
|
|
.font(.caption)
|
|
.fontWeight(.medium)
|
|
.lineLimit(1)
|
|
|
|
Text(problem.difficulty.grade)
|
|
.font(.caption2)
|
|
.fontWeight(.bold)
|
|
.foregroundColor(themeManager.accentColor)
|
|
|
|
if let location = problem.location {
|
|
Text(location)
|
|
.font(.caption2)
|
|
.foregroundColor(.secondary)
|
|
.lineLimit(1)
|
|
}
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
}
|
|
.padding(8)
|
|
.background(
|
|
RoundedRectangle(cornerRadius: 12)
|
|
.fill(isSelected ? themeManager.accentColor.opacity(0.1) : .gray.opacity(0.05))
|
|
.stroke(isSelected ? themeManager.accentColor : .clear, lineWidth: 2)
|
|
)
|
|
.contentShape(Rectangle())
|
|
.onTapGesture {
|
|
if isSelected {
|
|
showingExpandedView = true
|
|
} else {
|
|
action()
|
|
}
|
|
}
|
|
.sheet(isPresented: $showingExpandedView) {
|
|
ProblemExpandedView(problem: problem)
|
|
}
|
|
}
|
|
}
|
|
|
|
struct ProblemExpandedView: View {
|
|
let problem: Problem
|
|
@Environment(\.dismiss) private var dismiss
|
|
@EnvironmentObject var themeManager: ThemeManager
|
|
@State private var selectedImageIndex = 0
|
|
|
|
var body: some View {
|
|
NavigationStack {
|
|
ScrollView {
|
|
VStack(alignment: .leading, spacing: 16) {
|
|
// Images
|
|
if !problem.imagePaths.isEmpty {
|
|
TabView(selection: $selectedImageIndex) {
|
|
ForEach(problem.imagePaths.indices, id: \.self) { index in
|
|
ProblemSelectionImageFullView(imagePath: problem.imagePaths[index])
|
|
.tag(index)
|
|
}
|
|
}
|
|
.frame(height: 250)
|
|
.tabViewStyle(.page(indexDisplayMode: .always))
|
|
}
|
|
|
|
// Problem details
|
|
VStack(alignment: .leading, spacing: 12) {
|
|
Text(problem.name ?? "Unnamed Problem")
|
|
.font(.title2)
|
|
.fontWeight(.bold)
|
|
|
|
HStack {
|
|
Text(problem.difficulty.grade)
|
|
.font(.title3)
|
|
.fontWeight(.bold)
|
|
.foregroundColor(themeManager.accentColor)
|
|
|
|
Text(problem.climbType.displayName)
|
|
.font(.subheadline)
|
|
.foregroundColor(.secondary)
|
|
}
|
|
|
|
if let location = problem.location, !location.isEmpty {
|
|
Label(location, systemImage: "location")
|
|
.font(.subheadline)
|
|
.foregroundColor(.secondary)
|
|
}
|
|
|
|
if let description = problem.description, !description.isEmpty {
|
|
Text(description)
|
|
.font(.body)
|
|
}
|
|
|
|
if !problem.tags.isEmpty {
|
|
ScrollView(.horizontal, showsIndicators: false) {
|
|
HStack(spacing: 8) {
|
|
ForEach(problem.tags, id: \.self) { tag in
|
|
Text(tag)
|
|
.font(.caption)
|
|
.padding(.horizontal, 8)
|
|
.padding(.vertical, 4)
|
|
.background(
|
|
RoundedRectangle(cornerRadius: 8)
|
|
.fill(themeManager.accentColor.opacity(0.1))
|
|
)
|
|
.foregroundColor(themeManager.accentColor)
|
|
}
|
|
}
|
|
.padding(.horizontal)
|
|
}
|
|
}
|
|
}
|
|
.padding(.horizontal)
|
|
}
|
|
}
|
|
.navigationTitle("Problem Details")
|
|
.navigationBarTitleDisplayMode(.inline)
|
|
.toolbar {
|
|
ToolbarItem(placement: .navigationBarTrailing) {
|
|
Button("Done") {
|
|
dismiss()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
struct EditAttemptView: View {
|
|
let attempt: Attempt
|
|
@EnvironmentObject var dataManager: ClimbingDataManager
|
|
@EnvironmentObject var themeManager: ThemeManager
|
|
@Environment(\.dismiss) private var dismiss
|
|
|
|
@State private var selectedProblem: Problem?
|
|
@State private var selectedResult: AttemptResult
|
|
@State private var highestHold: String
|
|
@State private var notes: String
|
|
@State private var duration: Int
|
|
@State private var restTime: Int
|
|
@State private var showingCreateProblem = false
|
|
|
|
// New problem creation state
|
|
@State private var newProblemName = ""
|
|
@State private var newProblemGrade = ""
|
|
@State private var selectedClimbType: ClimbType = .boulder
|
|
@State private var selectedDifficultySystem: DifficultySystem = .vScale
|
|
@State private var selectedPhotos: [PhotosPickerItem] = []
|
|
@State private var imageData: [Data] = []
|
|
|
|
enum SheetType: Identifiable {
|
|
case photoOptions
|
|
|
|
var id: Int {
|
|
switch self {
|
|
case .photoOptions: return 0
|
|
}
|
|
}
|
|
}
|
|
|
|
@State private var activeSheet: SheetType?
|
|
@State private var showCamera = false
|
|
@State private var showPhotoPicker = false
|
|
@State private var isPhotoPickerActionPending = false
|
|
@State private var isCameraActionPending = false
|
|
|
|
private var availableProblems: [Problem] {
|
|
guard let session = dataManager.session(withId: attempt.sessionId) else {
|
|
return []
|
|
}
|
|
return dataManager.problems.filter { $0.isActive && $0.gymId == session.gymId }
|
|
}
|
|
|
|
private var gym: Gym? {
|
|
guard let session = dataManager.session(withId: attempt.sessionId) else {
|
|
return nil
|
|
}
|
|
return dataManager.gym(withId: session.gymId)
|
|
}
|
|
|
|
private var availableClimbTypes: [ClimbType] {
|
|
gym?.supportedClimbTypes ?? []
|
|
}
|
|
|
|
private var availableDifficultySystems: [DifficultySystem] {
|
|
guard let gym = gym else { return [] }
|
|
return DifficultySystem.systemsForClimbType(selectedClimbType).filter { system in
|
|
gym.difficultySystems.contains(system)
|
|
}
|
|
}
|
|
|
|
private var availableGrades: [String] {
|
|
selectedDifficultySystem.availableGrades
|
|
}
|
|
|
|
init(attempt: Attempt) {
|
|
self.attempt = attempt
|
|
self._selectedResult = State(initialValue: attempt.result)
|
|
self._highestHold = State(initialValue: attempt.highestHold ?? "")
|
|
self._notes = State(initialValue: attempt.notes ?? "")
|
|
self._duration = State(initialValue: attempt.duration ?? 0)
|
|
self._restTime = State(initialValue: attempt.restTime ?? 0)
|
|
}
|
|
|
|
var body: some View {
|
|
NavigationStack {
|
|
Form {
|
|
if !showingCreateProblem {
|
|
ProblemSelectionSection()
|
|
} else {
|
|
CreateProblemSection()
|
|
}
|
|
|
|
AttemptDetailsSection()
|
|
}
|
|
.navigationTitle("Edit Attempt")
|
|
.navigationBarTitleDisplayMode(.inline)
|
|
.toolbar {
|
|
ToolbarItem(placement: .navigationBarLeading) {
|
|
Button("Cancel") {
|
|
dismiss()
|
|
}
|
|
}
|
|
|
|
ToolbarItem(placement: .navigationBarTrailing) {
|
|
Button("Update") {
|
|
updateAttempt()
|
|
}
|
|
.disabled(!canSave)
|
|
}
|
|
}
|
|
}
|
|
.onAppear {
|
|
selectedProblem = dataManager.problem(withId: attempt.problemId)
|
|
setupInitialValues()
|
|
}
|
|
.onChange(of: selectedClimbType) {
|
|
updateDifficultySystem()
|
|
}
|
|
.onChange(of: selectedDifficultySystem) {
|
|
resetGradeIfNeeded()
|
|
}
|
|
.onChange(of: selectedPhotos) {
|
|
Task {
|
|
await loadSelectedPhotos()
|
|
}
|
|
}
|
|
|
|
.photosPicker(
|
|
isPresented: $showPhotoPicker,
|
|
selection: $selectedPhotos,
|
|
maxSelectionCount: 5 - imageData.count,
|
|
matching: .images
|
|
)
|
|
.sheet(
|
|
item: $activeSheet,
|
|
onDismiss: {
|
|
if isCameraActionPending {
|
|
showCamera = true
|
|
isCameraActionPending = false
|
|
return
|
|
}
|
|
if isPhotoPickerActionPending {
|
|
showPhotoPicker = true
|
|
isPhotoPickerActionPending = false
|
|
}
|
|
}
|
|
) { sheetType in
|
|
switch sheetType {
|
|
case .photoOptions:
|
|
PhotoOptionSheet(
|
|
selectedPhotos: $selectedPhotos,
|
|
imageData: $imageData,
|
|
maxImages: 5,
|
|
onCameraSelected: {
|
|
isCameraActionPending = true
|
|
activeSheet = nil
|
|
},
|
|
onPhotoLibrarySelected: {
|
|
isPhotoPickerActionPending = true
|
|
},
|
|
onDismiss: {
|
|
activeSheet = nil
|
|
}
|
|
)
|
|
}
|
|
}
|
|
.fullScreenCover(isPresented: $showCamera) {
|
|
CameraImagePicker { capturedImage in
|
|
if let jpegData = capturedImage.jpegData(compressionQuality: 0.8) {
|
|
imageData.append(jpegData)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@ViewBuilder
|
|
private func ProblemSelectionSection() -> some View {
|
|
Section("Select Problem") {
|
|
if availableProblems.isEmpty {
|
|
VStack(alignment: .leading, spacing: 12) {
|
|
Text("No active problems in this gym")
|
|
.foregroundColor(.secondary)
|
|
|
|
Button("Create New Problem") {
|
|
showingCreateProblem = true
|
|
}
|
|
.buttonStyle(.borderedProminent)
|
|
.tint(themeManager.accentColor)
|
|
}
|
|
.padding(.vertical, 8)
|
|
} else {
|
|
LazyVGrid(
|
|
columns: Array(repeating: GridItem(.flexible(), spacing: 8), count: 2),
|
|
spacing: 8
|
|
) {
|
|
ForEach(availableProblems, id: \.id) { problem in
|
|
ProblemSelectionCard(
|
|
problem: problem,
|
|
isSelected: selectedProblem?.id == problem.id
|
|
) {
|
|
selectedProblem = problem
|
|
}
|
|
}
|
|
}
|
|
.padding(.vertical, 8)
|
|
|
|
Button("Create New Problem") {
|
|
showingCreateProblem = true
|
|
}
|
|
.foregroundColor(themeManager.accentColor)
|
|
}
|
|
}
|
|
}
|
|
|
|
@ViewBuilder
|
|
private func CreateProblemSection() -> some View {
|
|
Section {
|
|
HStack {
|
|
Text("Create New Problem")
|
|
.font(.headline)
|
|
|
|
Spacer()
|
|
|
|
Button("Back") {
|
|
showingCreateProblem = false
|
|
selectedPhotos = []
|
|
imageData = []
|
|
}
|
|
.foregroundColor(themeManager.accentColor)
|
|
}
|
|
}
|
|
|
|
Section("Problem Details") {
|
|
TextField("Problem Name", text: $newProblemName)
|
|
}
|
|
|
|
Section("Climb Type") {
|
|
ForEach(availableClimbTypes, id: \.self) { climbType in
|
|
HStack {
|
|
Text(climbType.displayName)
|
|
Spacer()
|
|
if selectedClimbType == climbType {
|
|
Image(systemName: "checkmark.circle.fill")
|
|
.foregroundColor(themeManager.accentColor)
|
|
} else {
|
|
Image(systemName: "circle")
|
|
.foregroundColor(.gray)
|
|
}
|
|
}
|
|
.contentShape(Rectangle())
|
|
.onTapGesture {
|
|
selectedClimbType = climbType
|
|
}
|
|
}
|
|
}
|
|
|
|
Section("Difficulty") {
|
|
VStack(alignment: .leading, spacing: 12) {
|
|
Text("Difficulty System")
|
|
.font(.subheadline)
|
|
.fontWeight(.medium)
|
|
|
|
ForEach(availableDifficultySystems, id: \.self) { system in
|
|
HStack {
|
|
Text(system.displayName)
|
|
Spacer()
|
|
if selectedDifficultySystem == system {
|
|
Image(systemName: "checkmark.circle.fill")
|
|
.foregroundColor(themeManager.accentColor)
|
|
} else {
|
|
Image(systemName: "circle")
|
|
.foregroundColor(.gray)
|
|
}
|
|
}
|
|
.contentShape(Rectangle())
|
|
.onTapGesture {
|
|
selectedDifficultySystem = system
|
|
}
|
|
}
|
|
}
|
|
|
|
if selectedDifficultySystem == .custom {
|
|
TextField("Grade (Required - numbers only)", text: $newProblemGrade)
|
|
.keyboardType(.numberPad)
|
|
.onChange(of: newProblemGrade) {
|
|
// Filter out non-numeric characters
|
|
newProblemGrade = newProblemGrade.filter { $0.isNumber }
|
|
}
|
|
} else {
|
|
VStack(alignment: .leading, spacing: 8) {
|
|
Text("Grade (Required)")
|
|
.font(.subheadline)
|
|
.fontWeight(.medium)
|
|
|
|
ScrollView(.horizontal, showsIndicators: false) {
|
|
LazyHStack(spacing: 8) {
|
|
ForEach(availableGrades, id: \.self) { grade in
|
|
Button(grade) {
|
|
newProblemGrade = grade
|
|
}
|
|
.buttonStyle(.bordered)
|
|
.controlSize(.small)
|
|
.tint(newProblemGrade == grade ? themeManager.accentColor : .gray)
|
|
}
|
|
}
|
|
.padding(.horizontal, 1)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Section("Photos (Optional)") {
|
|
Button(action: {
|
|
activeSheet = .photoOptions
|
|
}) {
|
|
HStack {
|
|
Image(systemName: "camera.fill")
|
|
.foregroundColor(themeManager.accentColor)
|
|
.font(.title2)
|
|
VStack(alignment: .leading, spacing: 2) {
|
|
Text("Add Photos")
|
|
.font(.headline)
|
|
.foregroundColor(themeManager.accentColor)
|
|
Text("\(imageData.count) of 5 photos added")
|
|
.font(.caption)
|
|
.foregroundColor(.secondary)
|
|
}
|
|
Spacer()
|
|
Image(systemName: "chevron.right")
|
|
.foregroundColor(.secondary)
|
|
.font(.caption)
|
|
}
|
|
.padding(.vertical, 4)
|
|
}
|
|
.disabled(imageData.count >= 5)
|
|
|
|
if !imageData.isEmpty {
|
|
ScrollView(.horizontal, showsIndicators: false) {
|
|
HStack(spacing: 12) {
|
|
ForEach(imageData.indices, id: \.self) { index in
|
|
if let uiImage = UIImage(data: imageData[index]) {
|
|
Image(uiImage: uiImage)
|
|
.resizable()
|
|
.aspectRatio(contentMode: .fill)
|
|
.frame(width: 80, height: 80)
|
|
.clipped()
|
|
.cornerRadius(8)
|
|
.overlay(alignment: .topTrailing) {
|
|
Button(action: {
|
|
imageData.remove(at: index)
|
|
}) {
|
|
Image(systemName: "xmark.circle.fill")
|
|
.foregroundColor(.red)
|
|
.background(Circle().fill(.white))
|
|
}
|
|
.offset(x: 8, y: -8)
|
|
}
|
|
} else {
|
|
RoundedRectangle(cornerRadius: 8)
|
|
.fill(.gray.opacity(0.3))
|
|
.frame(width: 80, height: 80)
|
|
.overlay {
|
|
Image(systemName: "photo")
|
|
.foregroundColor(.gray)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
.padding(.horizontal, 1)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@ViewBuilder
|
|
private func AttemptDetailsSection() -> some View {
|
|
Section("Attempt Result") {
|
|
ForEach(AttemptResult.allCases, id: \.self) { result in
|
|
HStack {
|
|
Text(result.displayName)
|
|
Spacer()
|
|
if selectedResult == result {
|
|
Image(systemName: "checkmark.circle.fill")
|
|
.foregroundColor(themeManager.accentColor)
|
|
} else {
|
|
Image(systemName: "circle")
|
|
.foregroundColor(.gray)
|
|
}
|
|
}
|
|
.contentShape(Rectangle())
|
|
.onTapGesture {
|
|
selectedResult = result
|
|
}
|
|
}
|
|
}
|
|
|
|
Section("Additional Details") {
|
|
TextField("Highest Hold (Optional)", text: $highestHold)
|
|
|
|
VStack(alignment: .leading, spacing: 8) {
|
|
Text("Notes (Optional)")
|
|
.font(.headline)
|
|
|
|
TextEditor(text: $notes)
|
|
.frame(minHeight: 80)
|
|
.padding(8)
|
|
.background(
|
|
RoundedRectangle(cornerRadius: 8)
|
|
.fill(.quaternary)
|
|
)
|
|
}
|
|
|
|
HStack {
|
|
Text("Duration (seconds)")
|
|
Spacer()
|
|
TextField("0", value: $duration, format: .number)
|
|
.keyboardType(.numberPad)
|
|
.textFieldStyle(.roundedBorder)
|
|
.frame(width: 80)
|
|
}
|
|
|
|
HStack {
|
|
Text("Rest Time (seconds)")
|
|
Spacer()
|
|
TextField("0", value: $restTime, format: .number)
|
|
.keyboardType(.numberPad)
|
|
.textFieldStyle(.roundedBorder)
|
|
.frame(width: 80)
|
|
}
|
|
}
|
|
}
|
|
|
|
private var canSave: Bool {
|
|
if showingCreateProblem {
|
|
return !newProblemGrade.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
|
|
} else {
|
|
return selectedProblem != nil
|
|
}
|
|
}
|
|
|
|
private func setupInitialValues() {
|
|
guard let gym = gym else { return }
|
|
|
|
// Auto-select climb type if there's only one available
|
|
if gym.supportedClimbTypes.count == 1 {
|
|
selectedClimbType = gym.supportedClimbTypes.first!
|
|
}
|
|
|
|
updateDifficultySystem()
|
|
}
|
|
|
|
private func updateDifficultySystem() {
|
|
let available = availableDifficultySystems
|
|
|
|
if !available.contains(selectedDifficultySystem) {
|
|
selectedDifficultySystem = available.first ?? .custom
|
|
}
|
|
|
|
if available.count == 1 {
|
|
selectedDifficultySystem = available.first!
|
|
}
|
|
}
|
|
|
|
private func resetGradeIfNeeded() {
|
|
let availableGrades = selectedDifficultySystem.availableGrades
|
|
if !availableGrades.isEmpty && !availableGrades.contains(newProblemGrade) {
|
|
newProblemGrade = ""
|
|
}
|
|
}
|
|
|
|
private func loadSelectedPhotos() async {
|
|
var newImageData: [Data] = []
|
|
|
|
for item in selectedPhotos {
|
|
if let data = try? await item.loadTransferable(type: Data.self) {
|
|
newImageData.append(data)
|
|
}
|
|
}
|
|
|
|
await MainActor.run {
|
|
imageData.append(contentsOf: newImageData)
|
|
selectedPhotos.removeAll()
|
|
}
|
|
}
|
|
|
|
private func updateAttempt() {
|
|
if showingCreateProblem {
|
|
guard let gym = gym else { return }
|
|
|
|
let difficulty = DifficultyGrade(
|
|
system: selectedDifficultySystem, grade: newProblemGrade)
|
|
|
|
let newProblem = Problem(
|
|
gymId: gym.id,
|
|
name: newProblemName.isEmpty ? nil : newProblemName,
|
|
climbType: selectedClimbType,
|
|
difficulty: difficulty,
|
|
imagePaths: []
|
|
)
|
|
|
|
dataManager.addProblem(newProblem)
|
|
|
|
if !imageData.isEmpty {
|
|
var imagePaths: [String] = []
|
|
|
|
for (index, data) in imageData.enumerated() {
|
|
let deterministicName = ImageNamingUtils.generateImageFilename(
|
|
problemId: newProblem.id.uuidString, imageIndex: index)
|
|
|
|
if let relativePath = ImageManager.shared.saveImageData(
|
|
data, withName: deterministicName)
|
|
{
|
|
imagePaths.append(relativePath)
|
|
}
|
|
}
|
|
|
|
if !imagePaths.isEmpty {
|
|
let updatedProblem = newProblem.updated(imagePaths: imagePaths)
|
|
dataManager.updateProblem(updatedProblem)
|
|
}
|
|
}
|
|
|
|
let updatedAttempt = attempt.updated(
|
|
problemId: newProblem.id,
|
|
result: selectedResult,
|
|
highestHold: highestHold.isEmpty ? nil : highestHold,
|
|
notes: notes.isEmpty ? nil : notes,
|
|
duration: duration > 0 ? duration : nil,
|
|
restTime: restTime > 0 ? restTime : nil
|
|
)
|
|
|
|
dataManager.updateAttempt(updatedAttempt)
|
|
} else {
|
|
guard selectedProblem != nil else { return }
|
|
|
|
let updatedAttempt = attempt.updated(
|
|
problemId: selectedProblem?.id,
|
|
result: selectedResult,
|
|
highestHold: highestHold.isEmpty ? nil : highestHold,
|
|
notes: notes.isEmpty ? nil : notes,
|
|
duration: duration > 0 ? duration : nil,
|
|
restTime: restTime > 0 ? restTime : nil
|
|
)
|
|
|
|
dataManager.updateAttempt(updatedAttempt)
|
|
}
|
|
|
|
// Clear photo states after saving
|
|
selectedPhotos = []
|
|
imageData = []
|
|
|
|
dismiss()
|
|
}
|
|
|
|
}
|
|
|
|
#Preview {
|
|
AddAttemptView(
|
|
session: ClimbSession(gymId: UUID()),
|
|
gym: Gym(
|
|
name: "Sample Gym",
|
|
supportedClimbTypes: [.boulder],
|
|
difficultySystems: [.vScale]
|
|
)
|
|
)
|
|
.environmentObject(ClimbingDataManager.preview)
|
|
}
|
|
|
|
struct ProblemSelectionImageView: View {
|
|
let imagePath: String
|
|
|
|
var body: some View {
|
|
OrientationAwareImage.fill(imagePath: imagePath)
|
|
.frame(height: 80)
|
|
.clipped()
|
|
.cornerRadius(8)
|
|
}
|
|
}
|
|
|
|
struct ProblemSelectionImageFullView: View {
|
|
let imagePath: String
|
|
|
|
var body: some View {
|
|
OrientationAwareImage.fit(imagePath: imagePath)
|
|
}
|
|
}
|