366 lines
14 KiB
Swift
366 lines
14 KiB
Swift
import SwiftUI
|
|
import CoreLocation
|
|
import WidgetKit
|
|
|
|
struct ContentView: View {
|
|
@Environment(\.scenePhase) private var scenePhase
|
|
|
|
@State private var stations: [FuelStation] = FuelStore.loadStations()
|
|
@State private var selectedFuel: FuelType = FuelStore.loadSelectedFuel()
|
|
@State private var sortMode: SortMode = FuelStore.loadSortMode()
|
|
@State private var stationLimit: Int = FuelStore.loadStationLimit()
|
|
@State private var favourites: [FuelStation] = FuelStore.loadFavourites()
|
|
@State private var alertsEnabled: Bool = FuelStore.loadAlertsEnabled()
|
|
@State private var alertsRadius: Double = FuelStore.loadAlertsRadius()
|
|
@State private var location: Coordinate? = {
|
|
if let loc = FuelStore.loadLocation() { return Coordinate(lat: loc.lat, lng: loc.lng) }
|
|
return nil
|
|
}()
|
|
@State private var isLoading = false
|
|
@State private var statusMessage = ""
|
|
@State private var locationManager = LocationManager()
|
|
@StateObject private var monitor = ProximityMonitor()
|
|
|
|
/// Stations within the alert trigger radius of the current location, used
|
|
/// as the pool for "cheapest" (RAG reference, TOP, sorting). Falls back to
|
|
/// the full fetch when location is unknown or the radius pool is empty
|
|
/// (rural areas) so the list is never blank.
|
|
private var radiusScopedStations: [FuelStation] {
|
|
guard let location else { return stations }
|
|
let within = stations.filter {
|
|
$0.distanceKM(to: location.lat, lng2: location.lng) <= alertsRadius
|
|
}
|
|
return within.isEmpty ? stations : within
|
|
}
|
|
|
|
private var cheapestPrice: Double? {
|
|
radiusScopedStations.compactMap { $0.prices[selectedFuel] }.min()
|
|
}
|
|
|
|
private var displayedStations: [FuelStation] {
|
|
Array(sortedStations.prefix(stationLimit))
|
|
}
|
|
|
|
private var sortedStations: [FuelStation] {
|
|
let available = radiusScopedStations.filter { $0.prices[selectedFuel] != nil }
|
|
switch sortMode {
|
|
case .closest:
|
|
guard let location else { return available.sorted { $0.prices[selectedFuel]! < $1.prices[selectedFuel]! } }
|
|
return available.sorted { lhs, rhs in
|
|
// Closest first; price only breaks ties.
|
|
let lDist = lhs.distanceKM(to: location.lat, lng2: location.lng)
|
|
let rDist = rhs.distanceKM(to: location.lat, lng2: location.lng)
|
|
if lDist != rDist { return lDist < rDist }
|
|
return lhs.prices[selectedFuel]! < rhs.prices[selectedFuel]!
|
|
}
|
|
case .cheapest:
|
|
return available.sorted { lhs, rhs in
|
|
// Cheapest first; distance only breaks ties.
|
|
let lPrice = lhs.prices[selectedFuel]!
|
|
let rPrice = rhs.prices[selectedFuel]!
|
|
if lPrice != rPrice { return lPrice < rPrice }
|
|
guard let location else { return false }
|
|
return lhs.distanceKM(to: location.lat, lng2: location.lng) <
|
|
rhs.distanceKM(to: location.lat, lng2: location.lng)
|
|
}
|
|
}
|
|
}
|
|
|
|
private var favouriteIDs: Set<String> {
|
|
Set(favourites.map(\.id))
|
|
}
|
|
|
|
private var refreshedFavourites: [FuelStation] {
|
|
FuelStore.refreshedFavourites(favourites, from: stations)
|
|
}
|
|
|
|
var body: some View {
|
|
TabView {
|
|
StationsView(
|
|
stations: displayedStations,
|
|
totalCount: sortedStations.count,
|
|
isLoading: isLoading,
|
|
selectedFuel: $selectedFuel,
|
|
sortMode: $sortMode,
|
|
stationLimit: $stationLimit,
|
|
cheapestPrice: cheapestPrice,
|
|
location: location,
|
|
radiusKM: alertsRadius,
|
|
favouriteIDs: favouriteIDs,
|
|
onToggleFavourite: toggleFavourite
|
|
)
|
|
.tabItem { Label("Stations", systemImage: "fuelpump.fill") }
|
|
|
|
FavouritesView(
|
|
favourites: refreshedFavourites,
|
|
selectedFuel: selectedFuel,
|
|
location: location,
|
|
favouriteIDs: favouriteIDs,
|
|
onToggleFavourite: toggleFavourite
|
|
)
|
|
.tabItem { Label("Favourites", systemImage: "star.fill") }
|
|
|
|
AlertsView(
|
|
enabled: $alertsEnabled,
|
|
radius: $alertsRadius,
|
|
monitoredCount: monitor.monitoredStationIDs.count,
|
|
lastAlert: monitor.lastAlert
|
|
)
|
|
.tabItem { Label("Alerts", systemImage: "bell.fill") }
|
|
}
|
|
.onAppear {
|
|
locationManager.startForegroundTracking()
|
|
monitor.update(stations: stations, favourites: refreshedFavourites,
|
|
fuel: selectedFuel, radiusKM: alertsRadius)
|
|
monitor.setEnabled(alertsEnabled)
|
|
Task { await refresh() }
|
|
}
|
|
.onChange(of: scenePhase) { _, newPhase in
|
|
if newPhase == .active {
|
|
locationManager.startForegroundTracking()
|
|
monitor.update(stations: stations, favourites: refreshedFavourites,
|
|
fuel: selectedFuel, radiusKM: alertsRadius)
|
|
Task { await refresh() }
|
|
} else {
|
|
locationManager.stopForegroundTracking()
|
|
}
|
|
}
|
|
.onChange(of: locationManager.current) { _, newLocation in
|
|
if let newLocation {
|
|
location = newLocation
|
|
FuelStore.saveLocation(lat: newLocation.lat, lng: newLocation.lng)
|
|
WidgetCenter.shared.reloadAllTimelines()
|
|
Task { await refresh() }
|
|
}
|
|
}
|
|
.onChange(of: selectedFuel) { _, _ in
|
|
// Re-fetch so the station set matches the selected fuel (relay
|
|
// filters by grade); all prices still come back in one response.
|
|
Task { await refresh() }
|
|
}
|
|
.onChange(of: alertsEnabled) { _, newValue in
|
|
FuelStore.saveAlertsEnabled(newValue)
|
|
monitor.setEnabled(newValue)
|
|
monitor.update(stations: stations, favourites: refreshedFavourites,
|
|
fuel: selectedFuel, radiusKM: alertsRadius)
|
|
if newValue {
|
|
locationManager.startBackgroundTracking()
|
|
}
|
|
}
|
|
.onChange(of: alertsRadius) { _, newValue in
|
|
FuelStore.saveAlertsRadius(newValue)
|
|
monitor.update(stations: stations, favourites: refreshedFavourites,
|
|
fuel: selectedFuel, radiusKM: alertsRadius)
|
|
}
|
|
}
|
|
|
|
private func toggleFavourite(_ station: FuelStation) {
|
|
if favouriteIDs.contains(station.id) {
|
|
favourites.removeAll { $0.id == station.id }
|
|
} else {
|
|
favourites.append(station)
|
|
}
|
|
FuelStore.saveFavourites(favourites)
|
|
WidgetCenter.shared.reloadAllTimelines()
|
|
monitor.update(stations: stations, favourites: refreshedFavourites,
|
|
fuel: selectedFuel, radiusKM: alertsRadius)
|
|
}
|
|
|
|
private func refresh() async {
|
|
isLoading = true
|
|
defer { isLoading = false }
|
|
do {
|
|
let fetched = try await FuelPriceProvider.active.fetchStations(near: location?.lat, lng: location?.lng, fuel: selectedFuel)
|
|
stations = fetched
|
|
FuelStore.saveStations(fetched)
|
|
WidgetCenter.shared.reloadAllTimelines()
|
|
statusMessage = "Loaded \(fetched.count) stations · \(Date().formatted(date: .omitted, time: .shortened))"
|
|
} catch {
|
|
statusMessage = "Live fetch failed: \(error.localizedDescription). Showing cached/sample data."
|
|
stations = FuelStore.loadStations().isEmpty ? SampleFuelProvider.sampleStations : FuelStore.loadStations()
|
|
}
|
|
// Keep monitor geofences in sync with the freshest data.
|
|
monitor.update(stations: stations, favourites: refreshedFavourites,
|
|
fuel: selectedFuel, radiusKM: alertsRadius)
|
|
}
|
|
}
|
|
|
|
// MARK: - Station row (shared by Stations + Favourites tabs)
|
|
|
|
struct StationRow: View {
|
|
let station: FuelStation
|
|
let fuel: FuelType
|
|
let location: Coordinate?
|
|
let cheapestPrice: Double?
|
|
let isTopResult: Bool
|
|
let isFavourite: Bool
|
|
var onToggleFavourite: () -> Void = {}
|
|
|
|
private var ragColor: Color {
|
|
guard let price = station.prices[fuel], let cheapestPrice else { return .gray }
|
|
switch RAGRating.rating(price: price, cheapest: cheapestPrice) {
|
|
case .green: return .green
|
|
case .amber: return .orange
|
|
case .red: return .red
|
|
}
|
|
}
|
|
|
|
private var deltaText: String? {
|
|
guard let price = station.prices[fuel], let cheapestPrice else { return nil }
|
|
let delta = price - cheapestPrice
|
|
if delta <= 0.05 { return "best" }
|
|
return String(format: "+%.1fp", delta)
|
|
}
|
|
|
|
var body: some View {
|
|
HStack(spacing: 12) {
|
|
// Round brand logo (or generic fuel pump fallback)
|
|
Group {
|
|
if let asset = station.brandImageName {
|
|
Image(asset)
|
|
.resizable()
|
|
.scaledToFit()
|
|
.padding(5)
|
|
} else {
|
|
Image(systemName: "fuelpump.fill")
|
|
.font(.system(size: 22))
|
|
.foregroundStyle(.white)
|
|
}
|
|
}
|
|
.frame(width: 46, height: 46)
|
|
.background(Circle().fill(.white))
|
|
.clipShape(Circle())
|
|
.overlay(Circle().stroke(Color.primary.opacity(0.08), lineWidth: 1))
|
|
.shadow(color: .black.opacity(0.08), radius: 2, y: 1)
|
|
|
|
// Name fills the whole row width; price + details on the row below.
|
|
VStack(alignment: .leading, spacing: 3) {
|
|
HStack(alignment: .firstTextBaseline, spacing: 6) {
|
|
Text(station.name)
|
|
.font(.headline)
|
|
.lineLimit(2)
|
|
.layoutPriority(1)
|
|
if isTopResult {
|
|
Text("TOP")
|
|
.font(.caption2.bold())
|
|
.padding(.horizontal, 5)
|
|
.padding(.vertical, 1)
|
|
.background(Capsule().fill(.blue.opacity(0.15)))
|
|
.foregroundStyle(.blue)
|
|
}
|
|
Spacer(minLength: 6)
|
|
}
|
|
|
|
HStack(spacing: 5) {
|
|
Text("\(station.address), \(station.postcode)")
|
|
.font(.caption)
|
|
.foregroundStyle(.secondary)
|
|
.lineLimit(1)
|
|
Spacer(minLength: 8)
|
|
if let location {
|
|
Text(String(format: "%.1f km", station.distanceKM(to: location.lat, lng2: location.lng)))
|
|
.font(.caption2)
|
|
.foregroundStyle(.secondary)
|
|
.monospacedDigit()
|
|
}
|
|
if let price = station.prices[fuel] {
|
|
Circle()
|
|
.fill(ragColor)
|
|
.frame(width: 10, height: 10)
|
|
Text(String(format: "%.1fp", price))
|
|
.font(.title3.bold())
|
|
.monospacedDigit()
|
|
if let deltaText {
|
|
Text(deltaText)
|
|
.font(.caption2.bold())
|
|
.foregroundStyle(ragColor)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Button {
|
|
onToggleFavourite()
|
|
} label: {
|
|
Image(systemName: isFavourite ? "star.fill" : "star")
|
|
.foregroundStyle(isFavourite ? .yellow : .secondary)
|
|
}
|
|
.buttonStyle(.borderless)
|
|
}
|
|
.contentShape(Rectangle())
|
|
.onTapGesture {
|
|
if let url = station.mapsDirectionsURL {
|
|
UIApplication.shared.open(url)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Location manager
|
|
|
|
@MainActor
|
|
final class LocationManager: NSObject, ObservableObject, @preconcurrency CLLocationManagerDelegate {
|
|
@Published var current: Coordinate?
|
|
private let manager = CLLocationManager()
|
|
|
|
override init() {
|
|
super.init()
|
|
manager.delegate = self
|
|
manager.desiredAccuracy = kCLLocationAccuracyHundredMeters
|
|
manager.distanceFilter = 250 // metres — re-fires while driving
|
|
manager.pausesLocationUpdatesAutomatically = true
|
|
}
|
|
|
|
/// Continuous tracking while the app is in the foreground, so the list
|
|
/// re-fetches around the user's new position as they drive.
|
|
func startForegroundTracking() {
|
|
switch manager.authorizationStatus {
|
|
case .notDetermined:
|
|
manager.requestWhenInUseAuthorization()
|
|
manager.requestLocation()
|
|
case .authorizedWhenInUse, .authorizedAlways:
|
|
manager.startUpdatingLocation()
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
|
|
/// One-shot fix (first launch / after permission grant).
|
|
func requestUpdate() {
|
|
manager.requestLocation()
|
|
}
|
|
|
|
/// Background wake-ups on significant movement. Needs Always permission;
|
|
/// called once the user enables alerts so geofences + prices follow them.
|
|
func startBackgroundTracking() {
|
|
guard manager.authorizationStatus == .authorizedAlways else { return }
|
|
manager.startMonitoringSignificantLocationChanges()
|
|
}
|
|
|
|
func stopForegroundTracking() {
|
|
// Significant-change monitoring keeps running in the background.
|
|
manager.stopUpdatingLocation()
|
|
}
|
|
|
|
func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
|
|
switch manager.authorizationStatus {
|
|
case .authorizedAlways:
|
|
manager.startMonitoringSignificantLocationChanges()
|
|
manager.startUpdatingLocation()
|
|
case .authorizedWhenInUse:
|
|
manager.startUpdatingLocation()
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
|
|
func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
|
|
guard let loc = locations.last else { return }
|
|
current = Coordinate(lat: loc.coordinate.latitude, lng: loc.coordinate.longitude)
|
|
}
|
|
|
|
func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
|
|
// Ignore — the app still works price-sorted without location.
|
|
}
|
|
}
|