546 lines
19 KiB
Swift
546 lines
19 KiB
Swift
import SwiftUI
|
|
|
|
struct ProblemsView: View {
|
|
@EnvironmentObject var dataManager: ClimbingDataManager
|
|
@State private var showingAddProblem = false
|
|
@State private var selectedClimbType: ClimbType?
|
|
@State private var selectedGym: Gym?
|
|
@State private var searchText = ""
|
|
@State private var showingSearch = false
|
|
@FocusState private var isSearchFocused: Bool
|
|
|
|
private var filteredProblems: [Problem] {
|
|
var filtered = dataManager.problems
|
|
|
|
// Apply search filter
|
|
if !searchText.isEmpty {
|
|
filtered = filtered.filter { problem in
|
|
return problem.name?.localizedCaseInsensitiveContains(searchText) ?? false
|
|
|| (problem.description?.localizedCaseInsensitiveContains(searchText) ?? false)
|
|
|| (problem.location?.localizedCaseInsensitiveContains(searchText) ?? false)
|
|
|| problem.tags.contains { $0.localizedCaseInsensitiveContains(searchText) }
|
|
}
|
|
}
|
|
|
|
// Apply climb type filter
|
|
if let climbType = selectedClimbType {
|
|
filtered = filtered.filter { $0.climbType == climbType }
|
|
}
|
|
|
|
// Apply gym filter
|
|
if let gym = selectedGym {
|
|
filtered = filtered.filter { $0.gymId == gym.id }
|
|
}
|
|
|
|
// Separate active and inactive problems
|
|
let active = filtered.filter { $0.isActive }.sorted { $0.updatedAt > $1.updatedAt }
|
|
let inactive = filtered.filter { !$0.isActive }.sorted { $0.updatedAt > $1.updatedAt }
|
|
|
|
return active + inactive
|
|
}
|
|
|
|
var body: some View {
|
|
NavigationStack {
|
|
Group {
|
|
VStack(spacing: 0) {
|
|
if showingSearch {
|
|
HStack(spacing: 8) {
|
|
Image(systemName: "magnifyingglass")
|
|
.foregroundColor(.secondary)
|
|
.font(.system(size: 16, weight: .medium))
|
|
|
|
TextField("Search problems...", text: $searchText)
|
|
.textFieldStyle(.plain)
|
|
.font(.system(size: 16))
|
|
.focused($isSearchFocused)
|
|
.submitLabel(.search)
|
|
}
|
|
.padding(.horizontal, 12)
|
|
.padding(.vertical, 10)
|
|
.background {
|
|
if #available(iOS 18.0, *) {
|
|
RoundedRectangle(cornerRadius: 12)
|
|
.fill(.regularMaterial)
|
|
.overlay {
|
|
RoundedRectangle(cornerRadius: 12)
|
|
.stroke(.quaternary, lineWidth: 0.5)
|
|
}
|
|
} else {
|
|
RoundedRectangle(cornerRadius: 10)
|
|
.fill(Color(.systemGray6))
|
|
.overlay {
|
|
RoundedRectangle(cornerRadius: 10)
|
|
.stroke(Color(.systemGray4), lineWidth: 0.5)
|
|
}
|
|
}
|
|
}
|
|
.padding(.horizontal)
|
|
.padding(.top, 8)
|
|
.animation(.easeInOut(duration: 0.3), value: showingSearch)
|
|
}
|
|
|
|
if !dataManager.problems.isEmpty && !showingSearch {
|
|
FilterSection(
|
|
selectedClimbType: $selectedClimbType,
|
|
selectedGym: $selectedGym,
|
|
filteredProblems: filteredProblems
|
|
)
|
|
.padding()
|
|
.background(.regularMaterial)
|
|
}
|
|
|
|
if filteredProblems.isEmpty {
|
|
EmptyProblemsView(
|
|
isEmpty: dataManager.problems.isEmpty,
|
|
isFiltered: !dataManager.problems.isEmpty
|
|
)
|
|
} else {
|
|
ProblemsList(problems: filteredProblems)
|
|
}
|
|
}
|
|
}
|
|
.navigationTitle("Problems")
|
|
.navigationBarTitleDisplayMode(.automatic)
|
|
.toolbar {
|
|
ToolbarItemGroup(placement: .navigationBarTrailing) {
|
|
if dataManager.isSyncing {
|
|
HStack(spacing: 2) {
|
|
ProgressView()
|
|
.progressViewStyle(CircularProgressViewStyle(tint: .blue))
|
|
.scaleEffect(0.6)
|
|
}
|
|
.padding(.horizontal, 6)
|
|
.padding(.vertical, 3)
|
|
.background(
|
|
Circle()
|
|
.fill(.regularMaterial)
|
|
)
|
|
.transition(.scale.combined(with: .opacity))
|
|
.animation(
|
|
.easeInOut(duration: 0.2), value: dataManager.isSyncing
|
|
)
|
|
}
|
|
|
|
Button(action: {
|
|
withAnimation(.easeInOut(duration: 0.3)) {
|
|
showingSearch.toggle()
|
|
if showingSearch {
|
|
isSearchFocused = true
|
|
} else {
|
|
searchText = ""
|
|
isSearchFocused = false
|
|
}
|
|
}
|
|
}) {
|
|
Image(systemName: showingSearch ? "xmark.circle.fill" : "magnifyingglass")
|
|
.font(.system(size: 16, weight: .medium))
|
|
.foregroundColor(showingSearch ? .secondary : .blue)
|
|
}
|
|
|
|
if !dataManager.gyms.isEmpty {
|
|
Button("Add") {
|
|
showingAddProblem = true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
.sheet(isPresented: $showingAddProblem) {
|
|
AddEditProblemView()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
struct FilterSection: View {
|
|
@EnvironmentObject var dataManager: ClimbingDataManager
|
|
@Binding var selectedClimbType: ClimbType?
|
|
@Binding var selectedGym: Gym?
|
|
let filteredProblems: [Problem]
|
|
|
|
var body: some View {
|
|
VStack(spacing: 12) {
|
|
// Climb Type Filter
|
|
VStack(alignment: .leading, spacing: 8) {
|
|
Text("Climb Type")
|
|
.font(.subheadline)
|
|
.fontWeight(.medium)
|
|
|
|
ScrollView(.horizontal, showsIndicators: false) {
|
|
HStack(spacing: 8) {
|
|
FilterChip(
|
|
title: "All Types",
|
|
isSelected: selectedClimbType == nil
|
|
) {
|
|
selectedClimbType = nil
|
|
}
|
|
|
|
ForEach(ClimbType.allCases, id: \.self) { climbType in
|
|
FilterChip(
|
|
title: climbType.displayName,
|
|
isSelected: selectedClimbType == climbType
|
|
) {
|
|
selectedClimbType = climbType
|
|
}
|
|
}
|
|
}
|
|
.padding(.horizontal, 1)
|
|
}
|
|
}
|
|
|
|
// Gym Filter
|
|
VStack(alignment: .leading, spacing: 8) {
|
|
Text("Gym")
|
|
.font(.subheadline)
|
|
.fontWeight(.medium)
|
|
|
|
ScrollView(.horizontal, showsIndicators: false) {
|
|
HStack(spacing: 8) {
|
|
FilterChip(
|
|
title: "All Gyms",
|
|
isSelected: selectedGym == nil
|
|
) {
|
|
selectedGym = nil
|
|
}
|
|
|
|
ForEach(dataManager.gyms, id: \.id) { gym in
|
|
FilterChip(
|
|
title: gym.name,
|
|
isSelected: selectedGym?.id == gym.id
|
|
) {
|
|
selectedGym = gym
|
|
}
|
|
}
|
|
}
|
|
.padding(.horizontal, 1)
|
|
}
|
|
}
|
|
|
|
// Results count
|
|
if selectedClimbType != nil || selectedGym != nil {
|
|
HStack {
|
|
Text(
|
|
"Showing \(filteredProblems.count) of \(dataManager.problems.count) problems"
|
|
)
|
|
.font(.caption)
|
|
.foregroundColor(.secondary)
|
|
Spacer()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
struct FilterChip: View {
|
|
let title: String
|
|
let isSelected: Bool
|
|
let action: () -> Void
|
|
|
|
var body: some View {
|
|
Button(action: action) {
|
|
Text(title)
|
|
.font(.caption)
|
|
.fontWeight(.medium)
|
|
.padding(.horizontal, 12)
|
|
.padding(.vertical, 6)
|
|
.background(
|
|
RoundedRectangle(cornerRadius: 16)
|
|
.fill(isSelected ? .blue : .clear)
|
|
.stroke(.blue, lineWidth: 1)
|
|
)
|
|
.foregroundColor(isSelected ? .white : .blue)
|
|
}
|
|
.buttonStyle(.plain)
|
|
}
|
|
}
|
|
|
|
struct ProblemsList: View {
|
|
let problems: [Problem]
|
|
@EnvironmentObject var dataManager: ClimbingDataManager
|
|
@State private var problemToDelete: Problem?
|
|
@State private var problemToEdit: Problem?
|
|
|
|
var body: some View {
|
|
List(problems) { problem in
|
|
NavigationLink(destination: ProblemDetailView(problemId: problem.id)) {
|
|
ProblemRow(problem: problem)
|
|
}
|
|
.swipeActions(edge: .trailing, allowsFullSwipe: false) {
|
|
Button(role: .destructive) {
|
|
problemToDelete = problem
|
|
} label: {
|
|
Label("Delete", systemImage: "trash")
|
|
}
|
|
|
|
Button {
|
|
let updatedProblem = problem.updated(isActive: !problem.isActive)
|
|
dataManager.updateProblem(updatedProblem)
|
|
} label: {
|
|
Label(
|
|
problem.isActive ? "Mark as Reset" : "Mark as Active",
|
|
systemImage: problem.isActive ? "xmark.circle" : "checkmark.circle")
|
|
}
|
|
.tint(.orange)
|
|
|
|
Button {
|
|
problemToEdit = problem
|
|
} label: {
|
|
HStack {
|
|
Image(systemName: "pencil")
|
|
Text("Edit")
|
|
}
|
|
}
|
|
.tint(.blue)
|
|
}
|
|
}
|
|
.alert("Delete Problem", isPresented: .constant(problemToDelete != nil)) {
|
|
Button("Cancel", role: .cancel) {
|
|
problemToDelete = nil
|
|
}
|
|
Button("Delete", role: .destructive) {
|
|
if let problem = problemToDelete {
|
|
dataManager.deleteProblem(problem)
|
|
problemToDelete = nil
|
|
}
|
|
}
|
|
} message: {
|
|
Text(
|
|
"Are you sure you want to delete this problem? This will also delete all associated attempts."
|
|
)
|
|
}
|
|
.sheet(item: $problemToEdit) { problem in
|
|
AddEditProblemView(problemId: problem.id)
|
|
}
|
|
}
|
|
}
|
|
|
|
struct ProblemRow: View {
|
|
let problem: Problem
|
|
@EnvironmentObject var dataManager: ClimbingDataManager
|
|
|
|
private var gym: Gym? {
|
|
dataManager.gym(withId: problem.gymId)
|
|
}
|
|
|
|
var body: some View {
|
|
VStack(alignment: .leading, spacing: 8) {
|
|
HStack {
|
|
VStack(alignment: .leading, spacing: 4) {
|
|
Text(problem.name ?? "Unnamed Problem")
|
|
.font(.headline)
|
|
.fontWeight(.semibold)
|
|
.foregroundColor(problem.isActive ? .primary : .secondary)
|
|
|
|
Text(gym?.name ?? "Unknown Gym")
|
|
.font(.subheadline)
|
|
.foregroundColor(.secondary)
|
|
}
|
|
|
|
Spacer()
|
|
|
|
VStack(alignment: .trailing, spacing: 4) {
|
|
Text(problem.difficulty.grade)
|
|
.font(.title2)
|
|
.fontWeight(.bold)
|
|
.foregroundColor(.blue)
|
|
|
|
Text(problem.climbType.displayName)
|
|
.font(.caption)
|
|
.foregroundColor(.secondary)
|
|
}
|
|
}
|
|
|
|
if let location = problem.location {
|
|
Text("Location: \(location)")
|
|
.font(.caption)
|
|
.foregroundColor(.secondary)
|
|
}
|
|
|
|
if !problem.tags.isEmpty {
|
|
ScrollView(.horizontal, showsIndicators: false) {
|
|
HStack(spacing: 6) {
|
|
ForEach(problem.tags.prefix(3), id: \.self) { tag in
|
|
Text(tag)
|
|
.font(.caption2)
|
|
.padding(.horizontal, 6)
|
|
.padding(.vertical, 2)
|
|
.background(
|
|
RoundedRectangle(cornerRadius: 4)
|
|
.fill(.blue.opacity(0.1))
|
|
)
|
|
.foregroundColor(.blue)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if !problem.imagePaths.isEmpty {
|
|
ScrollView(.horizontal, showsIndicators: false) {
|
|
LazyHStack(spacing: 8) {
|
|
ForEach(problem.imagePaths.prefix(3), id: \.self) { imagePath in
|
|
ProblemImageView(imagePath: imagePath)
|
|
}
|
|
}
|
|
.padding(.horizontal, 4)
|
|
}
|
|
}
|
|
|
|
if !problem.isActive {
|
|
Text("Reset / No Longer Set")
|
|
.font(.caption)
|
|
.foregroundColor(.orange)
|
|
.fontWeight(.medium)
|
|
}
|
|
}
|
|
.padding(.vertical, 8)
|
|
}
|
|
}
|
|
|
|
struct EmptyProblemsView: View {
|
|
let isEmpty: Bool
|
|
let isFiltered: Bool
|
|
@EnvironmentObject var dataManager: ClimbingDataManager
|
|
@State private var showingAddProblem = false
|
|
|
|
var body: some View {
|
|
VStack(spacing: 20) {
|
|
Spacer()
|
|
|
|
Image(systemName: "star.fill")
|
|
.font(.system(size: 60))
|
|
.foregroundColor(.secondary)
|
|
|
|
VStack(spacing: 8) {
|
|
Text(title)
|
|
.font(.title2)
|
|
.fontWeight(.bold)
|
|
|
|
Text(subtitle)
|
|
.font(.body)
|
|
.foregroundColor(.secondary)
|
|
.multilineTextAlignment(.center)
|
|
.padding(.horizontal)
|
|
}
|
|
|
|
if isEmpty && !dataManager.gyms.isEmpty {
|
|
Button("Add Problem") {
|
|
showingAddProblem = true
|
|
}
|
|
.buttonStyle(.borderedProminent)
|
|
.controlSize(.large)
|
|
}
|
|
|
|
Spacer()
|
|
}
|
|
.sheet(isPresented: $showingAddProblem) {
|
|
AddEditProblemView()
|
|
}
|
|
}
|
|
|
|
private var title: String {
|
|
if isEmpty {
|
|
return dataManager.gyms.isEmpty ? "No Gyms Available" : "No Problems Yet"
|
|
} else {
|
|
return "No Problems Match Filters"
|
|
}
|
|
}
|
|
|
|
private var subtitle: String {
|
|
if isEmpty {
|
|
return dataManager.gyms.isEmpty
|
|
? "Add a gym first to start tracking problems and routes!"
|
|
: "Start tracking your favorite problems and routes!"
|
|
} else {
|
|
return "Try adjusting your filters to see more problems."
|
|
}
|
|
}
|
|
}
|
|
|
|
struct ProblemImageView: View {
|
|
let imagePath: String
|
|
@State private var uiImage: UIImage?
|
|
@State private var isLoading = true
|
|
@State private var hasFailed = false
|
|
|
|
private static var imageCache: NSCache<NSString, UIImage> = {
|
|
let cache = NSCache<NSString, UIImage>()
|
|
cache.countLimit = 100
|
|
cache.totalCostLimit = 50 * 1024 * 1024 // 50MB
|
|
return cache
|
|
}()
|
|
|
|
var body: some View {
|
|
Group {
|
|
if let uiImage = uiImage {
|
|
Image(uiImage: uiImage)
|
|
.resizable()
|
|
.aspectRatio(contentMode: .fill)
|
|
.frame(width: 60, height: 60)
|
|
.clipped()
|
|
.cornerRadius(8)
|
|
} else if hasFailed {
|
|
RoundedRectangle(cornerRadius: 8)
|
|
.fill(.gray.opacity(0.2))
|
|
.frame(width: 60, height: 60)
|
|
.overlay {
|
|
Image(systemName: "photo")
|
|
.foregroundColor(.gray)
|
|
.font(.title3)
|
|
}
|
|
} else {
|
|
RoundedRectangle(cornerRadius: 8)
|
|
.fill(.gray.opacity(0.3))
|
|
.frame(width: 60, height: 60)
|
|
.overlay {
|
|
ProgressView()
|
|
.scaleEffect(0.8)
|
|
}
|
|
}
|
|
}
|
|
.onAppear {
|
|
loadImage()
|
|
}
|
|
}
|
|
|
|
private func loadImage() {
|
|
guard !imagePath.isEmpty else {
|
|
hasFailed = true
|
|
isLoading = false
|
|
return
|
|
}
|
|
|
|
let cacheKey = NSString(string: imagePath)
|
|
|
|
// Check cache first
|
|
if let cachedImage = Self.imageCache.object(forKey: cacheKey) {
|
|
self.uiImage = cachedImage
|
|
self.isLoading = false
|
|
return
|
|
}
|
|
|
|
DispatchQueue.global(qos: .userInitiated).async {
|
|
if let data = ImageManager.shared.loadImageData(fromPath: imagePath),
|
|
let image = UIImage(data: data)
|
|
{
|
|
// Cache the image
|
|
Self.imageCache.setObject(image, forKey: cacheKey)
|
|
|
|
DispatchQueue.main.async {
|
|
self.uiImage = image
|
|
self.isLoading = false
|
|
}
|
|
} else {
|
|
DispatchQueue.main.async {
|
|
self.hasFailed = true
|
|
self.isLoading = false
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#Preview {
|
|
ProblemsView()
|
|
.environmentObject(ClimbingDataManager.preview)
|
|
}
|