add the ability to move time slots

PadelClub/PadelClubApp.swift

@@ -102,7 +102,7 @@ print("Running in Release mode")
                     //try? Tips.resetDatastore()
 
                     try? Tips.configure([
-                        .displayFrequency(.daily),
+                        .displayFrequency(.immediate),
                         .datastoreLocation(.applicationDefault)
                     ])
                 }

PadelClub/Utils/Tips.swift

@@ -549,29 +549,36 @@ struct TeamsExportTip: Tip {
     }
 }
 
-struct PlayerTournamentSearchTip: Tip {
+struct TimeSlotMoveTip: Tip {
     var title: Text {
-        Text("Cherchez un tournoi autour de vous !")
+        Text("Réorganisez vos créneaux horaires !")
     }
 
     var message: Text? {
-        Text("Padel Club facilite la recherche de tournois et l'inscription !")
+        Text("Vous pouvez déplacer les créneaux horaires dans la liste en glissant-déposant.")
     }
     
     var image: Image? {
-        Image(systemName: "trophy.circle")
+        Image(systemName: "arrow.up.arrow.down.circle")
+    }
 }
 
-    var actions: [Action] {
+struct TimeSlotMoveOptionTip: Tip {
-        Action(id: ActionKey.selectAction.rawValue, title: "Éssayer")
+    var title: Text {
+        Text("Réorganisez vos créneaux horaires !")
     }
 
-    enum ActionKey: String {
+    var message: Text? {
-        case selectAction = "selectAction"
+        Text("En cliquant ici, vous pouvez déplacer les créneaux horaires dans la liste en glissant-déposant.")
     }
     
+    var image: Image? {
+        Image(systemName: "sparkles")
+    }
 }
 
+
+
 struct TipStyleModifier: ViewModifier {
     @Environment(\.colorScheme) var colorScheme
     var tint: Color?

PadelClub/Views/Planning/PlanningView.swift

@@ -6,16 +6,21 @@
 //
 
 import SwiftUI
+import LeStorage
+import TipKit
 
 struct PlanningView: View {
+    
     @EnvironmentObject var dataStore: DataStore
     @Environment(Tournament.self) var tournament: Tournament
     @State private var selectedDay: Date?
     @Binding var selectedScheduleDestination: ScheduleDestination?
     @State private var filterOption: PlanningFilterOption = .byDefault
     @State private var showFinishedMatches: Bool = false
+    @State private var enableMove: Bool = false
     
     let allMatches: [Match]
+    let timeSlotMoveOptionTip = TimeSlotMoveOptionTip()
     
     init(matches: [Match], selectedScheduleDestination: Binding<ScheduleDestination?>) {
         self.allMatches = matches
@@ -38,22 +43,6 @@ struct PlanningView: View {
         timeSlots.keys.sorted()
     }
         
-    enum PlanningFilterOption: Int, CaseIterable, Identifiable {
-        var id: Int { self.rawValue }
-        
-        case byDefault
-        case byCourt
-        
-        func localizedPlanningLabel() -> String {
-            switch self {
-            case .byCourt:
-                return "Par terrain"
-            case .byDefault:
-                return "Par ordre des matchs"
-            }
-        }
-    }
-    
     private func _computedTitle(days: [Date]) -> String {
         if let selectedDay {
             return selectedDay.formatted(.dateTime.day().weekday().month())
@@ -71,8 +60,13 @@ struct PlanningView: View {
         let keys = self.keys(timeSlots: timeSlots)
         let days = self.days(timeSlots: timeSlots)
         let matches = matches
-        BySlotView(days: days, keys: keys, timeSlots: timeSlots, matches: matches, selectedDay: selectedDay, filterOption: filterOption, showFinishedMatches: showFinishedMatches)
+        let notSlots = matches.allSatisfy({ $0.startDate == nil })
+        BySlotView(days: days, keys: keys, timeSlots: timeSlots, matches: matches, selectedDay: selectedDay)
+            .environment(\.filterOption, filterOption)
+            .environment(\.showFinishedMatches, showFinishedMatches)
+            .environment(\.enableMove, enableMove)
             .navigationTitle(Text(_computedTitle(days: days)))
+            .navigationBarBackButtonHidden(enableMove)
             .toolbar(content: {
                 if days.count > 1 {
                     ToolbarTitleMenu {
@@ -89,11 +83,41 @@ struct PlanningView: View {
                             Text("Jour")
                         }
                         .pickerStyle(.automatic)
+                        .disabled(enableMove)
                     }
                 }
                 
+                if enableMove {
+                    ToolbarItem(placement: .topBarLeading) {
+                        Button("Annuler") {
+                            enableMove = false
+                        }
+                    }
+                    
+                    ToolbarItem(placement: .topBarTrailing) {
+                        Button("Sauver") {
+                            do {
+                                try self.tournament.tournamentStore.matches.addOrUpdate(contentOfs: allMatches)
+                            } catch {
+                                Logger.error(error)
+                            }
+
+                            enableMove = false
+                        }
+                    }
+
+                } else {
+                    
                     ToolbarItemGroup(placement: .topBarTrailing) {
+                        if notSlots == false {
+                            Toggle(isOn: $enableMove) {
+                                Label("Déplacer", systemImage: "rectangle.2.swap")
+                            }
+                            .popoverTip(timeSlotMoveOptionTip)
+                        }
+                        
                         Menu {
+                            Section {
                                 Picker(selection: $showFinishedMatches) {
                                     Text("Afficher tous les matchs").tag(true)
                                     Text("Masquer les matchs terminés").tag(false)
@@ -102,11 +126,13 @@ struct PlanningView: View {
                                 }
                                 .labelsHidden()
                                 .pickerStyle(.inline)
-                    } label: {
+                            } header: {
-                        Label("Filtrer", systemImage: "clock.badge.checkmark")
+                                Text("Option de filtrage")
-                            .symbolVariant(showFinishedMatches ? .fill : .none)
                             }
-                    Menu {
+                            
+                            Divider()
+                            
+                            Section {
                                 Picker(selection: $filterOption) {
                                     ForEach(PlanningFilterOption.allCases) {
                                         Text($0.localizedPlanningLabel()).tag($0)
@@ -116,15 +142,20 @@ struct PlanningView: View {
                                 }
                                 .labelsHidden()
                                 .pickerStyle(.inline)
+                            } header: {
+                                Text("Option de triage")
+                                
+                            }
                         } label: {
                             Label("Trier", systemImage: "line.3.horizontal.decrease.circle")
-                            .symbolVariant(filterOption == .byCourt ? .fill : .none)
+                                .symbolVariant(filterOption == .byCourt || showFinishedMatches ? .fill : .none)
                         }
                         
                     }
+                }
             })
             .overlay {
-                if matches.allSatisfy({ $0.startDate == nil }) {
+                if notSlots {
                     ContentUnavailableView {
                         Label("Aucun horaire défini", systemImage: "clock.badge.questionmark")
                     } description: {
@@ -140,28 +171,146 @@ struct PlanningView: View {
     
     struct BySlotView: View {
         @Environment(Tournament.self) var tournament: Tournament
+        @Environment(\.filterOption) private var filterOption
+        @Environment(\.showFinishedMatches) private var showFinishedMatches
+        @Environment(\.enableMove) private var enableMove
+
         let days: [Date]
         let keys: [Date]
         let timeSlots: [Date: [Match]]
         let matches: [Match]
         let selectedDay: Date?
-        let filterOption: PlanningFilterOption
+        let timeSlotMoveTip = TimeSlotMoveTip()
-        let showFinishedMatches: Bool
 
         var body: some View {
             List {
-                if matches.allSatisfy({ $0.startDate == nil }) == false {
+                
+                if enableMove {
+                    TipView(timeSlotMoveTip)
+                        .tipStyle(tint: .logoYellow, asSection: true)
+                }
+                
+                if !matches.allSatisfy({ $0.startDate == nil }) {
                     ForEach(days.filter({ selectedDay == nil || selectedDay == $0 }), id: \.self) { day in
+                        DaySectionView(
+                            day: day,
+                            keys: keys.filter({ $0.dayInt == day.dayInt }),
+                            timeSlots: timeSlots,
+                            selectedDay: selectedDay
+                        )
+                    }
+                }
+            }
+        }
+    }
+
+
+    struct DaySectionView: View {
+        @Environment(Tournament.self) var tournament: Tournament
+        @Environment(\.filterOption) private var filterOption
+        @Environment(\.showFinishedMatches) private var showFinishedMatches
+        @Environment(\.enableMove) private var enableMove
+
+        let day: Date
+        let keys: [Date]
+        let timeSlots: [Date: [Match]]
+        let selectedDay: Date?
+
+        var body: some View {
             Section {
-                            ForEach(keys.filter({ $0.dayInt == day.dayInt }), id: \.self) { key in
+                ForEach(keys, id: \.self) { key in
-                                if let _matches = timeSlots[key]?.sorted(by: filterOption == .byDefault ? \.computedOrder : \.courtIndexForSorting) {
+                    TimeSlotSectionView(
+                        key: key,
+                        matches: timeSlots[key]?.sorted(by: filterOption == .byDefault ? \.computedOrder : \.courtIndexForSorting) ?? []
+                    )
+                }
+                .onMove(perform: enableMove ? moveSection : nil)
+            } header: {
+                HeaderView(day: day, timeSlots: timeSlots)
+            } footer: {
+                if day.monthYearFormatted == Date.distantFuture.monthYearFormatted {
+                    Text("Il s'agit des matchs qui n'ont pas réussi à être placé par Padel Club. Peut-être à cause de créneaux indisponibles, d'autres tournois ou des réglages.")
+                }
+            }
+        }
+        
+        func moveSection(from source: IndexSet, to destination: Int) {
+            let daySlots = keys.filter { $0.dayInt == day.dayInt }.sorted()
+             
+            guard let sourceIdx = source.first,
+                sourceIdx < daySlots.count,
+                destination <= daySlots.count else {
+                return
+            }
+             
+             // Create a mutable copy of the time slots for this day
+            var slotsToUpdate = daySlots
+             
+            let updateRange = min(sourceIdx, destination)...max(sourceIdx, destination)
+
+            // Perform the move in the array
+            let sourceTime = slotsToUpdate.remove(at: sourceIdx)
+            if sourceIdx < destination {
+                slotsToUpdate.insert(sourceTime, at: destination - 1)
+            } else {
+                slotsToUpdate.insert(sourceTime, at: destination)
+            }
+                                     
+            // Update matches by swapping their startDates
+            for index in updateRange {
+                // Find the new time slot for these matches
+                let oldStartTime = slotsToUpdate[index]
+                let newStartTime = daySlots[index]
+                guard let matchesToUpdate = timeSlots[oldStartTime] else { continue }
+
+                 // Update each match with the new start time
+                for match in matchesToUpdate {
+                    match.startDate = newStartTime
+                }
+            }
+        }
+    }
+
+
+    struct TimeSlotSectionView: View {
+        @Environment(\.enableMove) private var enableMove
+        let key: Date
+        let matches: [Match]
+
+        var body: some View {
+            if !matches.isEmpty {
+                if enableMove {
+                    TimeSlotHeaderView(key: key, matches: matches)
+                } else {
                     DisclosureGroup {
-                                        ForEach(_matches) { match in
+                        MatchListView(matches: matches)
+                    } label: {
+                        TimeSlotHeaderView(key: key, matches: matches)
+                    }
+                }
+            }
+        }
+    }
+
+    struct MatchListView: View {
+        let matches: [Match]
+
+        var body: some View {
+            ForEach(matches) { match in
                 NavigationLink {
                     MatchDetailView(match: match)
                         .matchViewStyle(.sectionedStandardStyle)
-
                 } label: {
+                    MatchRowView(match: match)
+                }
+            }
+        }
+    }
+
+    struct MatchRowView: View {
+        let match: Match
+
+        var body: some View {
             LabeledContent {
                 if let courtName = match.courtName() {
                     Text(courtName)
@@ -176,12 +325,17 @@ struct PlanningView: View {
             }
         }
     }
-                                    } label: {
+
-                                        _timeSlotView(key: key, matches: _matches)
+
-                                    }
+    struct HeaderView: View {
-                                }
+        @Environment(\.filterOption) private var filterOption
-                            }
+        @Environment(\.showFinishedMatches) private var showFinishedMatches
-                        } header: {
+        @Environment(\.enableMove) private var enableMove
+
+        let day: Date
+        let timeSlots: [Date: [Match]]
+
+        var body: some View {
             HStack {
                 if day.monthYearFormatted == Date.distantFuture.monthYearFormatted {
                     Text("Sans horaire")
@@ -191,18 +345,9 @@ struct PlanningView: View {
                 Spacer()
                 let count = _matchesCount(inDayInt: day.dayInt, timeSlots: timeSlots)
                 if showFinishedMatches {
-                                    Text(self._formattedMatchCount(count))
+                    Text(_formattedMatchCount(count))
                 } else {
-                                    Text(self._formattedMatchCount(count) + " restant\(count.pluralSuffix)")
+                    Text("\(_formattedMatchCount(count)) restant\(count.pluralSuffix)")
-                                }
-                            }
-                        } footer: {
-                            if day.monthYearFormatted == Date.distantFuture.monthYearFormatted {
-                                Text("Il s'agit des matchs qui n'ont pas réussi à être placé par Padel Club. Peut-être à cause de créneaux indisponibles, d'autres tournois ou des réglages.")
-                            }
-                        }
-                        .headerProminence(.increased)
-                    }
                 }
             }
         }
@@ -211,15 +356,28 @@ struct PlanningView: View {
             timeSlots.filter { $0.key.dayInt == dayInt }.flatMap({ $0.value }).count
         }
 
-        private func _timeSlotView(key: Date, matches: [Match]) -> some View {
+        private func _formattedMatchCount(_ count: Int) -> String {
+            return "\(count.formatted()) match\(count.pluralSuffix)"
+        }
+    }
+
+    struct TimeSlotHeaderView: View {
+        let key: Date
+        let matches: [Match]
+        @Environment(Tournament.self) var tournament: Tournament
+
+        var body: some View {
             LabeledContent {
-                Text(self._formattedMatchCount(matches.count))
+                Text("\(matches.count.formatted()) match\(matches.count.pluralSuffix)")
             } label: {
                 if key.monthYearFormatted == Date.distantFuture.monthYearFormatted {
                     Text("Aucun horaire")
                 } else {
-                    Text(key.formatted(date: .omitted, time: .shortened)).font(.title).fontWeight(.semibold)
+                    Text(key.formatted(date: .omitted, time: .shortened))
+                        .font(.title)
+                        .fontWeight(.semibold)
                 }
+                
                 if matches.count <= tournament.courtCount {
                     let names = matches.sorted(by: \.computedOrder)
                         .compactMap({ $0.roundTitle() })
@@ -232,15 +390,203 @@ struct PlanningView: View {
                 } else {
                     Text(matches.count.formatted().appending(" matchs"))
                 }
+
+            }
         }
     }
 
-        fileprivate func _formattedMatchCount(_ count: Int) -> String {
+    
-            return "\(count.formatted()) match\(count.pluralSuffix)"
+//    struct BySlotView: View {
+//        @Environment(Tournament.self) var tournament: Tournament
+//        let days: [Date]
+//        let keys: [Date]
+//        let timeSlots: [Date:[Match]]
+//        let matches: [Match]
+//        let selectedDay: Date?
+//        let filterOption: PlanningFilterOption
+//        let showFinishedMatches: Bool
+//
+//        var body: some View {
+//            List {
+//                if matches.allSatisfy({ $0.startDate == nil }) == false {
+//                    ForEach(days.filter({ selectedDay == nil || selectedDay == $0 }), id: \.self) { day in
+//                        Section {
+//                            ForEach(keys.filter({ $0.dayInt == day.dayInt }), id: \.self) { key in
+//                                if let _matches = timeSlots[key]?.sorted(by: filterOption == .byDefault ? \.computedOrder : \.courtIndexForSorting) {
+//                                    DisclosureGroup {
+//                                        ForEach(_matches) { match in
+//                                            NavigationLink {
+//                                                MatchDetailView(match: match)
+//                                                    .matchViewStyle(.sectionedStandardStyle)
+//
+//                                            } label: {
+//                                                LabeledContent {
+//                                                    if let courtName = match.courtName() {
+//                                                        Text(courtName)
+//                                                    }
+//                                                } label: {
+//                                                    if let groupStage = match.groupStageObject {
+//                                                        Text(groupStage.groupStageTitle(.title))
+//                                                    } else if let round = match.roundObject {
+//                                                        Text(round.roundTitle())
+//                                                    }
+//                                                    Text(match.matchTitle())
+//                                                }
+//                                            }
+//                                        }
+//                                    } label: {
+//                                        _timeSlotView(key: key, matches: _matches)
+//                                    }
+//                                }
+//                            }
+//                            .onMove(perform: moveSection)
+//                        } header: {
+//                            HStack {
+//                                if day.monthYearFormatted == Date.distantFuture.monthYearFormatted {
+//                                    Text("Sans horaire")
+//                                } else {
+//                                    Text(day.formatted(.dateTime.day().weekday().month()))
+//                                }
+//                                Spacer()
+//                                let count = _matchesCount(inDayInt: day.dayInt, timeSlots: timeSlots)
+//                                if showFinishedMatches {
+//                                    Text(self._formattedMatchCount(count))
+//                                } else {
+//                                    Text(self._formattedMatchCount(count) + " restant\(count.pluralSuffix)")
+//                                }
+//                            }
+//                        } footer: {
+//                            if day.monthYearFormatted == Date.distantFuture.monthYearFormatted {
+//                                Text("Il s'agit des matchs qui n'ont pas réussi à être placé par Padel Club. Peut-être à cause de créneaux indisponibles, d'autres tournois ou des réglages.")
+//                            }
+//                        }
+//                        .headerProminence(.increased)
+//                    }
+//                }
+//            }
+//        }
+//        
+//        func moveSection(from source: IndexSet, to destination: Int) {
+//            let daySlots = keys.filter { selectedDay == nil || $0.dayInt == selectedDay?.dayInt }.sorted()
+//             
+//            guard let sourceIdx = source.first,
+//                sourceIdx < daySlots.count,
+//                destination <= daySlots.count else {
+//                return
+//            }
+//             
+//             // Create a mutable copy of the time slots for this day
+//            var slotsToUpdate = daySlots
+//             
+//            let updateRange = min(sourceIdx, destination)...max(sourceIdx, destination) - 1
+//            print(updateRange)
+//
+//            // Perform the move in the array
+//            let sourceTime = slotsToUpdate.remove(at: sourceIdx)
+//            if sourceIdx < destination {
+//                slotsToUpdate.insert(sourceTime, at: destination - 1)
+//            } else {
+//                slotsToUpdate.insert(sourceTime, at: destination)
+//            }
+//                                     
+//            // Update matches by swapping their startDates
+//            for index in updateRange {
+//                // Find the new time slot for these matches
+//                let oldStartTime = slotsToUpdate[index]
+//                let newStartTime = daySlots[index]
+//                guard let matchesToUpdate = timeSlots[oldStartTime] else { continue }
+//                print("moving", oldStartTime, "to", newStartTime)
+//
+//                 // Update each match with the new start time
+//                for match in matchesToUpdate {
+//                    match.startDate = newStartTime
+//                }
+//            }
+//            
+//            try? self.tournament.tournamentStore.matches.addOrUpdate(contentOfs: matches)
+//        }
+//
+//        
+//        private func _matchesCount(inDayInt dayInt: Int, timeSlots: [Date:[Match]]) -> Int {
+//            timeSlots.filter { $0.key.dayInt == dayInt }.flatMap({ $0.value }).count
+//        }
+//        
+//        private func _timeSlotView(key: Date, matches: [Match]) -> some View {
+//            LabeledContent {
+//                Text(self._formattedMatchCount(matches.count))
+//            } label: {
+//                if key.monthYearFormatted == Date.distantFuture.monthYearFormatted {
+//                    Text("Aucun horaire")
+//                } else {
+//                    Text(key.formatted(date: .omitted, time: .shortened)).font(.title).fontWeight(.semibold)
+//                }
+//                if matches.count <= tournament.courtCount {
+//                    let names = matches.sorted(by: \.computedOrder)
+//                        .compactMap({ $0.roundTitle() })
+//                        .reduce(into: [String]()) { uniqueNames, name in
+//                            if !uniqueNames.contains(name) {
+//                                uniqueNames.append(name)
+//                            }
+//                        }
+//                    Text(names.joined(separator: ", ")).lineLimit(1).truncationMode(.tail)
+//                } else {
+//                    Text(matches.count.formatted().appending(" matchs"))
+//                }
+//            }
+//        }
+//        
+//        fileprivate func _formattedMatchCount(_ count: Int) -> String {
+//            return "\(count.formatted()) match\(count.pluralSuffix)"
+//        }
+//    }
+}
+
+enum PlanningFilterOption: Int, CaseIterable, Identifiable {
+    var id: Int { self.rawValue }
+    
+    case byDefault
+    case byCourt
+    
+    func localizedPlanningLabel() -> String {
+        switch self {
+        case .byCourt:
+            return "Par terrain"
+        case .byDefault:
+            return "Par ordre des matchs"
         }
     }
 }
 
-//#Preview {
+
-//    PlanningView(matches: [], selectedScheduleDestination: .constant(nil))
+struct FilterOptionKey: EnvironmentKey {
-//}
+    static let defaultValue: PlanningFilterOption = .byDefault
+}
+
+extension EnvironmentValues {
+    var filterOption: PlanningFilterOption {
+        get { self[FilterOptionKey.self] }
+        set { self[FilterOptionKey.self] = newValue }
+    }
+}
+
+struct ShowFinishedMatchesKey: EnvironmentKey {
+    static let defaultValue: Bool = false
+}
+
+extension EnvironmentValues {
+    var showFinishedMatches: Bool {
+        get { self[ShowFinishedMatchesKey.self] }
+        set { self[ShowFinishedMatchesKey.self] = newValue }
+    }
+}
+
+struct EnableMoveKey: EnvironmentKey {
+    static let defaultValue: Bool = false
+}
+
+extension EnvironmentValues {
+    var enableMove: Bool {
+        get { self[EnableMoveKey.self] }
+        set { self[EnableMoveKey.self] = newValue }
+    }
+}