Add current weather metrics to header

Author: cfdshark

README.md

@@ -173,6 +173,56 @@ In that model:
 
 The current implementation does not include that settings page or persistence layer yet. It is a presentation-only improvement that makes the displayed unit match the phone setting without introducing additional app configuration UI.
 
+## Current Weather Metrics
+
+The forecast header now shows a compact current-conditions summary in addition to the icon and temperature. The added values are:
+
+- wind speed in `km/h`
+- humidity as a percentage
+- precipitation as a percentage
+
+These values are derived from the first forecast entry returned by OpenWeather, which is the same entry the app already uses as the source of truth for the current primary condition and current displayed temperature.
+
+### OpenWeather Fields Used
+
+The app now reads the following additional fields from the OpenWeather 5-day / 3-hour forecast response:
+
+- `main.humidity`
+- `wind.speed`
+- `pop`
+
+How they are presented in the UI:
+
+- `main.humidity` -> displayed directly as `Humidity`
+- `wind.speed` -> converted from meters per second into kilometers per hour and displayed as `Wind`
+- `pop` -> converted into a percentage and displayed as `Precip`
+
+### Important Note About Precipitation
+
+The precipitation value currently shown in the app is **not** rainfall volume.
+
+It is OpenWeather's `pop` field, which represents the **probability of precipitation** for that forecast entry. In practical terms:
+
+- `20%` means a 20% chance of precipitation
+- it does **not** mean 20 mm of rain
+
+If the app later needs actual precipitation amount, that would require additional handling for fields such as:
+
+- `rain.3h`
+- `snow.3h`
+
+Those are separate from precipitation probability and should be treated as different weather metrics in the UI.
+
+### Current Limitation
+
+The current metrics row is intentionally lightweight:
+
+- it uses only the first/current forecast entry
+- it does not yet expose gusts, visibility, pressure, or actual rain/snow volume
+- precipitation is currently shown as chance-of-precipitation only
+
+This is a good lightweight summary for the current header, but a production-grade weather app would likely expand this into a dedicated details surface or conditions panel.
+
 ## Configuration
 
 The current testing configuration is defined in [AppConfiguration.swift](/Users/blessingmabunda/Documents/WeatherApp/WeatherApp/App/AppConfiguration.swift).
@@ -200,6 +250,7 @@ xcodebuild test -project WeatherApp.xcodeproj -scheme WeatherApp -destination 'p
 - Unit tests cover:
   - OpenWeather response mapping into app-owned models
   - OpenWeather condition-to-icon mapping for bundled weather assets
+  - current weather metric mapping for humidity, wind speed, and precipitation probability
   - theme/background mapping
   - forecast view-model state transitions
   - presentation formatting helpers, including Celsius/Fahrenheit display conversion

WeatherApp/Domain/Models/WeatherSnapshot.swift

@@ -4,6 +4,10 @@ struct WeatherSnapshot: Equatable {
     let locationName: String
     let coordinate: LocationCoordinate
     let currentTemperatureCelsius: Int
+    let primaryDescription: String
+    let humidityPercentage: Int
+    let windSpeedKilometersPerHour: Int
+    let precipitationProbabilityPercentage: Int
     let primaryCondition: WeatherConditionCategory
     let primaryIcon: WeatherIconAsset
     let forecastDays: [ForecastDay]

WeatherApp/Features/Forecast/Views/ForecastHeaderView.swift

@@ -17,6 +17,18 @@ struct ForecastHeaderView: View {
                     .font(.headline.weight(.semibold))
                     .foregroundStyle(.white)
 
+                if snapshot.primaryDescription.isEmpty == false {
+                    Text(snapshot.primaryDescription)
+                        .font(.custom("Poppins-Medium", size: 14))
+                        .foregroundStyle(.white.opacity(0.9))
+                }
+
+                HStack(spacing: 12) {
+                    metricLabel("Wind", value: "\(snapshot.windSpeedKilometersPerHour) km/h")
+                    metricLabel("Humidity", value: "\(snapshot.humidityPercentage)%")
+                    metricLabel("Precip", value: "\(snapshot.precipitationProbabilityPercentage)%")
+                }
+
                 HStack(alignment: .center, spacing: 16) {
                     headerIcon
 
@@ -33,6 +45,18 @@ struct ForecastHeaderView: View {
         .frame(maxWidth: .infinity, alignment: .leading)
     }
 
+    private func metricLabel(_ title: String, value: String) -> some View {
+        VStack(alignment: .leading, spacing: 2) {
+            Text(title.uppercased())
+                .font(.custom("Poppins-SemiBold", size: 10))
+                .foregroundStyle(.white.opacity(0.72))
+
+            Text(value)
+                .font(.custom("Poppins-Medium", size: 12))
+                .foregroundStyle(.white)
+        }
+    }
+
     @ViewBuilder
     private var headerIcon: some View {
         if UIImage(named: snapshot.primaryIcon.assetName) != nil {

WeatherApp/Features/Forecast/Views/ForecastScreen.swift

@@ -107,6 +107,10 @@ private struct PreviewWeatherProvider: WeatherProviding {
             locationName: "Johannesburg",
             coordinate: coordinate,
             currentTemperatureCelsius: 23,
+            primaryDescription: "Broken Clouds",
+            humidityPercentage: 62,
+            windSpeedKilometersPerHour: 18,
+            precipitationProbabilityPercentage: 35,
             primaryCondition: .cloudy,
             primaryIcon: .cloud,
             forecastDays: [

WeatherApp/Services/Weather/OpenWeatherForecastMapper.swift

@@ -11,6 +11,10 @@ struct OpenWeatherForecastMapper {
                 date: Date(timeIntervalSince1970: entry.timestamp),
                 temperature: Int(entry.main.temperature.rounded()),
                 maxTemperature: Int(entry.main.maximumTemperature.rounded()),
+                description: formattedDescription(from: primaryWeather),
+                humidity: entry.main.humidity,
+                windSpeedKilometersPerHour: Int(((entry.wind?.speed ?? 0) * 3.6).rounded()),
+                precipitationProbabilityPercentage: Int(((entry.precipitationProbability ?? 0) * 100).rounded()),
                 condition: WeatherConditionCategory(openWeatherCondition: primaryWeather?.main ?? ""),
                 icon: iconMapper.icon(for: primaryWeather)
             )
@@ -23,6 +27,10 @@ struct OpenWeatherForecastMapper {
             locationName: response.city.name,
             coordinate: coordinate,
             currentTemperatureCelsius: currentEntry?.temperature ?? 0,
+            primaryDescription: currentEntry?.description ?? "",
+            humidityPercentage: currentEntry?.humidity ?? 0,
+            windSpeedKilometersPerHour: currentEntry?.windSpeedKilometersPerHour ?? 0,
+            precipitationProbabilityPercentage: currentEntry?.precipitationProbabilityPercentage ?? 0,
             primaryCondition: currentEntry?.condition ?? .cloudy,
             primaryIcon: currentEntry?.icon ?? .cloud,
             forecastDays: forecastDays
@@ -85,12 +93,21 @@ struct OpenWeatherForecastMapper {
     ) -> MappedEntry? {
         entries.first { $0.condition == dominantCondition } ?? entries.first
     }
+
+    private func formattedDescription(from weather: OpenWeatherResponse.Weather?) -> String {
+        let source = (weather?.description.isEmpty == false ? weather?.description : weather?.main) ?? ""
+        return source.localizedCapitalized
+    }
 }
 
 private struct MappedEntry {
     let date: Date
     let temperature: Int
     let maxTemperature: Int
+    let description: String
+    let humidity: Int
+    let windSpeedKilometersPerHour: Int
+    let precipitationProbabilityPercentage: Int
     let condition: WeatherConditionCategory
     let icon: WeatherIconAsset
 }

WeatherApp/Services/Weather/OpenWeatherResponse.swift

@@ -8,21 +8,27 @@ struct OpenWeatherResponse: Decodable {
         let timestamp: TimeInterval
         let main: Main
         let weather: [Weather]
+        let wind: Wind?
+        let precipitationProbability: Double?
 
         enum CodingKeys: String, CodingKey {
             case timestamp = "dt"
             case main
             case weather
+            case wind
+            case precipitationProbability = "pop"
         }
     }
 
     struct Main: Decodable {
         let temperature: Double
         let maximumTemperature: Double
+        let humidity: Int
 
         enum CodingKeys: String, CodingKey {
             case temperature = "temp"
             case maximumTemperature = "temp_max"
+            case humidity
         }
     }
 
@@ -32,6 +38,10 @@ struct OpenWeatherResponse: Decodable {
         let description: String
     }
 
+    struct Wind: Decodable {
+        let speed: Double
+    }
+
     struct City: Decodable {
         let name: String
         let timezone: Int

WeatherAppTests/ForecastScreenViewModelTests.swift

@@ -8,6 +8,10 @@ final class ForecastScreenViewModelTests: XCTestCase {
             locationName: "Cape Town",
             coordinate: LocationCoordinate(latitude: -33.9249, longitude: 18.4241),
             currentTemperatureCelsius: 18,
+            primaryDescription: "Clouds",
+            humidityPercentage: 61,
+            windSpeedKilometersPerHour: 12,
+            precipitationProbabilityPercentage: 30,
             primaryCondition: .cloudy,
             primaryIcon: .cloud,
             forecastDays: [
@@ -65,6 +69,10 @@ final class ForecastScreenViewModelTests: XCTestCase {
             locationName: "Durban",
             coordinate: LocationCoordinate(latitude: -29.8587, longitude: 31.0218),
             currentTemperatureCelsius: 25,
+            primaryDescription: "Clear Sky",
+            humidityPercentage: 48,
+            windSpeedKilometersPerHour: 16,
+            precipitationProbabilityPercentage: 10,
             primaryCondition: .sunny,
             primaryIcon: .sun,
             forecastDays: [

WeatherAppTests/OpenWeatherForecastMapperTests.swift

@@ -21,6 +21,10 @@ final class OpenWeatherForecastMapperTests: XCTestCase {
         )
 
         XCTAssertEqual(snapshot.locationName, "Pretoria")
+        XCTAssertEqual(snapshot.primaryDescription, "Clouds")
+        XCTAssertEqual(snapshot.humidityPercentage, 56)
+        XCTAssertEqual(snapshot.windSpeedKilometersPerHour, 14)
+        XCTAssertEqual(snapshot.precipitationProbabilityPercentage, 20)
         XCTAssertEqual(snapshot.primaryCondition, .cloudy)
         XCTAssertEqual(snapshot.primaryIcon, .cloud)
         XCTAssertEqual(snapshot.forecastDays.count, 5)
@@ -32,8 +36,10 @@ final class OpenWeatherForecastMapperTests: XCTestCase {
     private func makeEntry(timestamp: TimeInterval, temp: Double, max: Double, code: Int, main: String) -> OpenWeatherResponse.ForecastEntry {
         OpenWeatherResponse.ForecastEntry(
             timestamp: timestamp,
-            main: .init(temperature: temp, maximumTemperature: max),
-            weather: [.init(id: code, main: main, description: main)]
+            main: .init(temperature: temp, maximumTemperature: max, humidity: 56),
+            weather: [.init(id: code, main: main, description: main)],
+            wind: .init(speed: 4),
+            precipitationProbability: 0.2
         )
     }
 }