559 lines
18 KiB
Swift
559 lines
18 KiB
Swift
//
|
|
// AddAttemptView.swift
|
|
// OpenClimb
|
|
//
|
|
// Created by OpenClimb on 2025-01-17.
|
|
//
|
|
|
|
import SwiftUI
|
|
|
|
struct AddAttemptView: View {
|
|
let session: ClimbSession
|
|
let gym: Gym
|
|
@EnvironmentObject var dataManager: ClimbingDataManager
|
|
@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
|
|
|
|
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 {
|
|
NavigationView {
|
|
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()
|
|
}
|
|
}
|
|
|
|
@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)
|
|
}
|
|
.padding(.vertical, 8)
|
|
} else {
|
|
ForEach(activeProblems, id: \.id) { problem in
|
|
ProblemSelectionRow(
|
|
problem: problem,
|
|
isSelected: selectedProblem?.id == problem.id
|
|
) {
|
|
selectedProblem = problem
|
|
}
|
|
}
|
|
|
|
Button("Create New Problem") {
|
|
showingCreateProblem = true
|
|
}
|
|
.foregroundColor(.blue)
|
|
}
|
|
}
|
|
}
|
|
|
|
@ViewBuilder
|
|
private func CreateProblemSection() -> some View {
|
|
Section {
|
|
HStack {
|
|
Text("Create New Problem")
|
|
.font(.headline)
|
|
|
|
Spacer()
|
|
|
|
Button("Back") {
|
|
showingCreateProblem = false
|
|
}
|
|
.foregroundColor(.blue)
|
|
}
|
|
}
|
|
|
|
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(.blue)
|
|
} 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(.blue)
|
|
} 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 ? .blue : .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(.blue)
|
|
} 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 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
|
|
)
|
|
|
|
dataManager.addProblem(newProblem)
|
|
|
|
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)
|
|
}
|
|
|
|
dismiss()
|
|
}
|
|
}
|
|
|
|
struct ProblemSelectionRow: View {
|
|
let problem: Problem
|
|
let isSelected: Bool
|
|
let action: () -> Void
|
|
|
|
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(.blue)
|
|
|
|
if let location = problem.location {
|
|
Text(location)
|
|
.font(.caption)
|
|
.foregroundColor(.secondary)
|
|
}
|
|
}
|
|
|
|
Spacer()
|
|
|
|
if isSelected {
|
|
Image(systemName: "checkmark.circle.fill")
|
|
.foregroundColor(.blue)
|
|
} else {
|
|
Image(systemName: "circle")
|
|
.foregroundColor(.gray)
|
|
}
|
|
}
|
|
.contentShape(Rectangle())
|
|
.onTapGesture(perform: action)
|
|
.padding(.vertical, 4)
|
|
}
|
|
}
|
|
|
|
struct EditAttemptView: View {
|
|
let attempt: Attempt
|
|
@EnvironmentObject var dataManager: ClimbingDataManager
|
|
@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
|
|
|
|
private var availableProblems: [Problem] {
|
|
dataManager.problems.filter { $0.isActive }
|
|
}
|
|
|
|
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 {
|
|
NavigationView {
|
|
Form {
|
|
Section("Problem") {
|
|
if availableProblems.isEmpty {
|
|
Text("No problems available")
|
|
.foregroundColor(.secondary)
|
|
} else {
|
|
ForEach(availableProblems, id: \.id) { problem in
|
|
HStack {
|
|
VStack(alignment: .leading, spacing: 4) {
|
|
Text(problem.name ?? "Unnamed Problem")
|
|
.font(.headline)
|
|
|
|
Text(
|
|
"\(problem.difficulty.system.displayName): \(problem.difficulty.grade)"
|
|
)
|
|
.font(.subheadline)
|
|
.foregroundColor(.blue)
|
|
}
|
|
|
|
Spacer()
|
|
|
|
if selectedProblem?.id == problem.id {
|
|
Image(systemName: "checkmark.circle.fill")
|
|
.foregroundColor(.blue)
|
|
}
|
|
}
|
|
.contentShape(Rectangle())
|
|
.onTapGesture {
|
|
selectedProblem = problem
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Section("Result") {
|
|
ForEach(AttemptResult.allCases, id: \.self) { result in
|
|
HStack {
|
|
Text(result.displayName)
|
|
Spacer()
|
|
if selectedResult == result {
|
|
Image(systemName: "checkmark.circle.fill")
|
|
.foregroundColor(.blue)
|
|
} else {
|
|
Image(systemName: "circle")
|
|
.foregroundColor(.gray)
|
|
}
|
|
}
|
|
.contentShape(Rectangle())
|
|
.onTapGesture {
|
|
selectedResult = result
|
|
}
|
|
}
|
|
}
|
|
|
|
Section("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)
|
|
}
|
|
}
|
|
}
|
|
.navigationTitle("Edit Attempt")
|
|
.navigationBarTitleDisplayMode(.inline)
|
|
.toolbar {
|
|
ToolbarItem(placement: .navigationBarLeading) {
|
|
Button("Cancel") {
|
|
dismiss()
|
|
}
|
|
}
|
|
|
|
ToolbarItem(placement: .navigationBarTrailing) {
|
|
Button("Update") {
|
|
updateAttempt()
|
|
}
|
|
.disabled(selectedProblem == nil)
|
|
}
|
|
}
|
|
}
|
|
.onAppear {
|
|
selectedProblem = dataManager.problem(withId: attempt.problemId)
|
|
}
|
|
}
|
|
|
|
private func updateAttempt() {
|
|
guard selectedProblem != nil else { return }
|
|
|
|
let updatedAttempt = attempt.updated(
|
|
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)
|
|
dismiss()
|
|
}
|
|
}
|
|
|
|
#Preview {
|
|
AddAttemptView(
|
|
session: ClimbSession(gymId: UUID()),
|
|
gym: Gym(
|
|
name: "Sample Gym",
|
|
supportedClimbTypes: [.boulder],
|
|
difficultySystems: [.vScale]
|
|
)
|
|
)
|
|
.environmentObject(ClimbingDataManager.preview)
|
|
}
|