rss-tools @ 71f9578bfe2969b6b22984c4264c8bf6c067e608

package weather

import (

	"context"

	"encoding/json"

	"errors"

	"fmt"

	"html"

	"math"

	"net/http"

	"net/url"

	"strconv"

	"strings"

	"time"

	"olexsmir.xyz/rss-tools/app"

	"olexsmir.xyz/rss-tools/app/atom"

)

const (

	forecastAPIURL   = "https://api.open-meteo.com/v1/forecast"

	airQualityAPIURL = "https://air-quality-api.open-meteo.com/v1/air-quality"

	geocodingAPIURL  = "https://nominatim.openstreetmap.org/reverse"

	clockLayout = "15:04"

	localLayout = "2006-01-02T15:04"

)

var timelineHours = []int{8, 12, 16, 20}

type weather struct {

	client        *http.Client

	forecastURL   string

	airQualityURL string

	geocodingURL  string

}

func Register(a *app.App) error {

	w := &weather{

		client:        a.Client,

		forecastURL:   forecastAPIURL,

		airQualityURL: airQualityAPIURL,

		geocodingURL:  geocodingAPIURL,

	}

	a.Route("GET /weather", w.handler)

	a.Logger.Info("weather source registered")

	return nil

}

func (w *weather) handler(rw http.ResponseWriter, r *http.Request) {

	lat, lon, err := parseCoordinates(r)

	if err != nil {

		http.Error(rw, "invalid latitude/longitude", http.StatusBadRequest)

		return

	}

	forecast, err := w.fetchForecast(r.Context(), lat, lon)

	if err != nil {

		http.Error(rw, "failed to fetch weather forecast", http.StatusBadGateway)

		return

	}

	air, err := w.fetchAirQuality(r.Context(), lat, lon)

	if err != nil {

		http.Error(rw, "failed to fetch air quality", http.StatusBadGateway)

		return

	}

	content, updated, err := buildWeatherBriefing(forecast, air)

	if err != nil {

		http.Error(rw, "failed to build weather briefing", http.StatusBadGateway)

		return

	}

	place := fmt.Sprintf("%.4f,%.4f", lat, lon)

	if town, err := w.fetchTownName(r.Context(), lat, lon); err == nil && town != "" {

		place = town

	}

	feedID := weatherFeedID(lat, lon)

	feed := atom.NewFeed(fmt.Sprintf("Weather forecast for %s", place), feedID).

		WithUpdated(updated)

	feed.Add(&atom.Entry{

		Title:   "Weather briefing",

		ID:      fmt.Sprintf("%s-%s", feedID, updated.Format("20060102")),

		Content: atom.NewText(formatBriefingXHTML(content), "xhtml"),

		Updated: atom.Time(updated),

	})

	if err := feed.Render(rw); err != nil {

		http.Error(rw, "failed to render feed", http.StatusInternalServerError)

	}

}

func parseCoordinates(r *http.Request) (float64, float64, error) {

	latRaw := strings.TrimSpace(r.URL.Query().Get("latitude"))

	lonRaw := strings.TrimSpace(r.URL.Query().Get("longitude"))

	if latRaw == "" || lonRaw == "" {

		return 0, 0, errors.New("latitude and longitude are required")

	}

	lat, err := strconv.ParseFloat(latRaw, 64)

	if err != nil {

		return 0, 0, fmt.Errorf("invalid latitude: %w", err)

	}

	lon, err := strconv.ParseFloat(lonRaw, 64)

	if err != nil {

		return 0, 0, fmt.Errorf("invalid longitude: %w", err)

	}

	if lat < -90 || lat > 90 {

		return 0, 0, errors.New("latitude is out of range")

	}

	if lon < -180 || lon > 180 {

		return 0, 0, errors.New("longitude is out of range")

	}

	return lat, lon, nil

}

type forecastResponse struct {

	Timezone string `json:"timezone"`

	Current  struct {

		Time                string   `json:"time"`

		Temperature2M       *float64 `json:"temperature_2m"`

		ApparentTemperature *float64 `json:"apparent_temperature"`

	} `json:"current"`

	Daily struct {

		Time                     []string  `json:"time"`

		TemperatureMin           []float64 `json:"temperature_2m_min"`

		TemperatureMax           []float64 `json:"temperature_2m_max"`

		WeatherCode              []int     `json:"weather_code"`

		PrecipitationProbability []float64 `json:"precipitation_probability_max"`

		PrecipitationSum         []float64 `json:"precipitation_sum"`

		RainSum                  []float64 `json:"rain_sum"`

		ShowersSum               []float64 `json:"showers_sum"`

		WindSpeedMax             []float64 `json:"wind_speed_10m_max"`

		WindDirectionDominant    []float64 `json:"wind_direction_10m_dominant"`

	} `json:"daily"`

	Hourly struct {

		Time                     []string  `json:"time"`

		Temperature              []float64 `json:"temperature_2m"`

		WeatherCode              []int     `json:"weather_code"`

		PrecipitationProbability []float64 `json:"precipitation_probability"`

		WindSpeed                []float64 `json:"wind_speed_10m"`

		Humidity                 []float64 `json:"relative_humidity_2m"`

	} `json:"hourly"`

}

type airQualityResponse struct {

	Current struct {

		USAQI           *float64 `json:"us_aqi"`

		PM2_5           *float64 `json:"pm2_5"`

		PM10            *float64 `json:"pm10"`

		Ozone           *float64 `json:"ozone"`

		NitrogenDioxide *float64 `json:"nitrogen_dioxide"`

	} `json:"current"`

}

type geocodingResponse struct {

	Name        string `json:"name"`

	DisplayName string `json:"display_name"`

	Address     struct {

		City         string `json:"city"`

		Town         string `json:"town"`

		Village      string `json:"village"`

		Municipality string `json:"municipality"`

		Hamlet       string `json:"hamlet"`

		County       string `json:"county"`

	} `json:"address"`

}

func (w *weather) fetchForecast(ctx context.Context, lat, lon float64) (forecastResponse, error) {

	var payload forecastResponse

	q := url.Values{}

	q.Set("latitude", strconv.FormatFloat(lat, 'f', 6, 64))

	q.Set("longitude", strconv.FormatFloat(lon, 'f', 6, 64))

	q.Set("timezone", "auto")

	q.Set("forecast_days", "1")

	q.Set("current", strings.Join([]string{

		"temperature_2m",

		"apparent_temperature",

	}, ","))

	q.Set("daily", strings.Join([]string{

		"temperature_2m_min",

		"temperature_2m_max",

		"weather_code",

		"precipitation_probability_max",

		"precipitation_sum",

		"rain_sum",

		"showers_sum",

		"wind_speed_10m_max",

		"wind_direction_10m_dominant",

	}, ","))

	q.Set("hourly", strings.Join([]string{

		"temperature_2m",

		"weather_code",

		"precipitation_probability",

		"wind_speed_10m",

		"relative_humidity_2m",

	}, ","))

	endpoint := w.forecastURL + "?" + q.Encode()

	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)

	if err != nil {

		return payload, err

	}

	res, err := w.client.Do(req)

	if err != nil {

		return payload, err

	}

	defer res.Body.Close()

	if res.StatusCode != http.StatusOK {

		return payload, fmt.Errorf("forecast API returned %s", res.Status)

	}

	if err := json.NewDecoder(res.Body).Decode(&payload); err != nil {

		return payload, err

	}

	if len(payload.Daily.Time) == 0 || len(payload.Daily.TemperatureMin) == 0 || len(payload.Daily.TemperatureMax) == 0 {

		return payload, errors.New("forecast payload missing daily data")

	}

	if len(payload.Hourly.Time) == 0 || len(payload.Hourly.Temperature) == 0 {

		return payload, errors.New("forecast payload missing hourly data")

	}

	return payload, nil

}

func (w *weather) fetchAirQuality(ctx context.Context, lat, lon float64) (airQualityResponse, error) {

	var payload airQualityResponse

	q := url.Values{}

	q.Set("latitude", strconv.FormatFloat(lat, 'f', 6, 64))

	q.Set("longitude", strconv.FormatFloat(lon, 'f', 6, 64))

	q.Set("timezone", "auto")

	q.Set("current", strings.Join([]string{

		"us_aqi",

		"pm2_5",

		"pm10",

		"ozone",

		"nitrogen_dioxide",

	}, ","))

	endpoint := w.airQualityURL + "?" + q.Encode()

	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)

	if err != nil {

		return payload, err

	}

	res, err := w.client.Do(req)

	if err != nil {

		return payload, err

	}

	defer res.Body.Close()

	if res.StatusCode != http.StatusOK {

		return payload, fmt.Errorf("air quality API returned %s", res.Status)

	}

	if err := json.NewDecoder(res.Body).Decode(&payload); err != nil {

		return payload, err

	}

	return payload, nil

}

func (w *weather) fetchTownName(ctx context.Context, lat, lon float64) (string, error) {

	var payload geocodingResponse

	geocodingURL := w.geocodingURL

	if geocodingURL == "" {

		geocodingURL = geocodingAPIURL

	}

	q := url.Values{}

	q.Set("lat", strconv.FormatFloat(lat, 'f', 6, 64))

	q.Set("lon", strconv.FormatFloat(lon, 'f', 6, 64))

	q.Set("format", "jsonv2")

	q.Set("accept-language", "en")

	q.Set("zoom", "12")

	q.Set("addressdetails", "1")

	endpoint := geocodingURL + "?" + q.Encode()

	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)

	if err != nil {

		return "", err

	}

	req.Header.Set("User-Agent", "rss-tools/1.0 (+https://github.com/olexsmir/rss-tools)")

	res, err := w.client.Do(req)

	if err != nil {

		return "", err

	}

	defer res.Body.Close()

	if res.StatusCode != http.StatusOK {

		return "", fmt.Errorf("geocoding API returned %s", res.Status)

	}

	if err := json.NewDecoder(res.Body).Decode(&payload); err != nil {

		return "", err

	}

	for _, candidate := range []string{

		payload.Address.City,

		payload.Address.Town,

		payload.Address.Village,

		payload.Address.Municipality,

		payload.Address.Hamlet,

		payload.Address.County,

		payload.Name,

		firstDisplayNamePart(payload.DisplayName),

	} {

		if town := strings.TrimSpace(candidate); town != "" {

			return town, nil

		}

	}

	return "", errors.New("town name not found")

}

func firstDisplayNamePart(displayName string) string {

	part, _, _ := strings.Cut(displayName, ",")

	return strings.TrimSpace(part)

}

func formatBriefingXHTML(content string) string {

	blocks := strings.Split(content, "\n\n")

	overview := []string{}

	timeline := []string{}

	meta := []string{}

	if len(blocks) > 0 {

		overview = nonEmptyLines(blocks[0])

	}

	if len(blocks) > 1 {

		timeline = nonEmptyLines(blocks[1])

	}

	if len(blocks) > 2 {

		meta = nonEmptyLines(strings.Join(blocks[2:], "\n\n"))

	}

	var b strings.Builder

	b.WriteString("<article>")

	if len(overview) > 0 {

		b.WriteString("<section><h2>Overview</h2>")

		b.WriteString("<p>" + html.EscapeString(overview[0]) + "</p>")

		if len(overview) > 1 {

			b.WriteString("<ul>")

			for _, line := range overview[1:] {

				b.WriteString("<li>" + html.EscapeString(line) + "</li>")

			}

			b.WriteString("</ul>")

		}

		b.WriteString("</section>")

	}

	if len(timeline) > 0 {

		b.WriteString("<section><h2>Timeline</h2><ul>")

		for _, line := range timeline {

			timestamp, rest, ok := strings.Cut(strings.TrimSpace(line), "  ")

			if ok {

				b.WriteString("<li><strong>" + html.EscapeString(strings.TrimSpace(timestamp)) + "</strong> " + html.EscapeString(strings.TrimSpace(rest)) + "</li>")

				continue

			}

			b.WriteString("<li>" + html.EscapeString(line) + "</li>")

		}

		b.WriteString("</ul></section>")

	}

	if len(meta) > 0 {

		b.WriteString("<section><h2>Source</h2>")

		for _, line := range meta {

			b.WriteString("<p>" + html.EscapeString(line) + "</p>")

		}

		b.WriteString("</section>")

	}

	b.WriteString("</article>")

	return b.String()

}

func nonEmptyLines(block string) []string {

	lines := strings.Split(block, "\n")

	out := make([]string, 0, len(lines))

	for _, line := range lines {

		line = strings.TrimSpace(line)

		if line == "" {

			continue

		}

		out = append(out, line)

	}

	return out

}

func buildWeatherBriefing(forecast forecastResponse, air airQualityResponse) (string, time.Time, error) {

	loc := time.Local

	if tz := strings.TrimSpace(forecast.Timezone); tz != "" {

		zone, err := time.LoadLocation(tz)

		if err == nil {

			loc = zone

		}

	}

	day := firstEl(forecast.Daily.Time)

	if day == "" {

		return "", time.Time{}, errors.New("missing day")

	}

	updated := time.Now().In(loc)

	if parsed, err := time.ParseInLocation(localLayout, forecast.Current.Time, loc); err == nil {

		updated = parsed

	}

	minTemp := firstEl(forecast.Daily.TemperatureMin)

	maxTemp := firstEl(forecast.Daily.TemperatureMax)

	code := firstEl(forecast.Daily.WeatherCode)

	_, dayText := weatherCodeLabel(code)

	peakPrecipHour := peakPrecipitationHour(forecast, day, loc)

	if maxProbability := firstEl(forecast.Daily.PrecipitationProbability); maxProbability >= 50 {

		switch {

		case peakPrecipHour >= 12 && peakPrecipHour <= 18:

			dayText += " with showers in the afternoon"

		case peakPrecipHour >= 5 && peakPrecipHour < 12:

			dayText += " with rain in the morning"

		default:

			dayText += " with possible rain"

		}

	}

	rainLine := fmt.Sprintf(

		"☂ %d%% chance of rain (%s)",

		int(math.Round(firstEl(forecast.Daily.PrecipitationProbability))),

		rainAmount(forecast.Daily.PrecipitationSum, forecast.Daily.RainSum, forecast.Daily.ShowersSum),

	)

	windMin, windMax := minMaxForDay(forecast.Hourly.Time, forecast.Hourly.WindSpeed, day)

	if windMin == 0 && windMax == 0 {

		windMax = firstEl(forecast.Daily.WindSpeedMax)

		windMin = windMax

	}

	windDirection := windDirectionFromDegrees(firstEl(forecast.Daily.WindDirectionDominant))

	windLine := formatWindLine(windMin, windMax, windDirection)

	lowTemp, lowTime, highTemp, highTime, ok := dayExtremes(forecast.Hourly.Time, forecast.Hourly.Temperature, day, loc)

	extremesLine := ""

	if ok {

		extremesLine = fmt.Sprintf(

			"📈 High: %s at %s  •  📉 Low: %s at %s",

			formatSignedTemperature(highTemp),

			highTime.Format(clockLayout),

			formatSignedTemperature(lowTemp),

			lowTime.Format(clockLayout),

		)

	}

	nowLine := ""

	if forecast.Current.Temperature2M != nil && forecast.Current.ApparentTemperature != nil {

		nowLine = fmt.Sprintf(

			"🌡 Now: %s (feels like %s)",

			formatSignedTemperature(*forecast.Current.Temperature2M),

			formatSignedTemperature(*forecast.Current.ApparentTemperature),

		)

	}

	humidityMin, humidityMax := minMaxForDay(forecast.Hourly.Time, forecast.Hourly.Humidity, day)

	humidityLine := ""

	if humidityMin != 0 || humidityMax != 0 {

		humidityLine = fmt.Sprintf("💧 Humidity: %d-%d%%", int(math.Round(humidityMin)), int(math.Round(humidityMax)))

	}

	airLine := formatAirQualityLine(air)

	timelineLines := timelineSummary(forecast, day, loc)

	if len(timelineLines) == 0 {

		return "", time.Time{}, errors.New("missing timeline data")

	}

	lines := []string{

		fmt.Sprintf("%s / %s  |  %s", formatSignedTemperature(minTemp), formatSignedTemperature(maxTemp), dayText),

		rainLine,

		windLine,

	}

	if extremesLine != "" {

		lines = append(lines, extremesLine)

	}

	if nowLine != "" {

		lines = append(lines, nowLine)

	}

	if humidityLine != "" {

		lines = append(lines, humidityLine)

	}

	if airLine != "" {

		lines = append(lines, airLine)

	}

	lines = append(lines, "")

	lines = append(lines, timelineLines...)

	lines = append(lines, "", "Data: Open-Meteo")

	return strings.Join(lines, "\n"), updated, nil

}

func peakPrecipitationHour(forecast forecastResponse, day string, loc *time.Location) int {

	peakHour := -1

	maxProb := -1.0

	for i, raw := range forecast.Hourly.Time {

		if i >= len(forecast.Hourly.PrecipitationProbability) || !strings.HasPrefix(raw, day+"T") {

			continue

		}

		t, err := time.ParseInLocation(localLayout, raw, loc)

		if err != nil {

			continue

		}

		prob := forecast.Hourly.PrecipitationProbability[i]

		if prob > maxProb {

			maxProb = prob

			peakHour = t.Hour()

		}

	}

	return peakHour

}

func dayExtremes(times []string, values []float64, day string, loc *time.Location) (float64, time.Time, float64, time.Time, bool) {

	if len(times) == 0 || len(values) == 0 {

		return 0, time.Time{}, 0, time.Time{}, false

	}

	minVal, maxVal := 0.0, 0.0

	var minTime, maxTime time.Time

	found := false

	for i, raw := range times {

		if i >= len(values) || !strings.HasPrefix(raw, day+"T") {

			continue

		}

		t, err := time.ParseInLocation(localLayout, raw, loc)

		if err != nil {

			continue

		}

		v := values[i]

		if !found {

			minVal, maxVal = v, v

			minTime, maxTime = t, t

			found = true

			continue

		}

		if v < minVal {

			minVal = v

			minTime = t

		}

		if v > maxVal {

			maxVal = v

			maxTime = t

		}

	}

	return minVal, minTime, maxVal, maxTime, found

}

func minMaxForDay(times []string, values []float64, day string) (float64, float64) {

	if len(times) == 0 || len(values) == 0 {

		return 0, 0

	}

	minV, maxV := 0.0, 0.0

	found := false

	for i, raw := range times {

		if i >= len(values) || !strings.HasPrefix(raw, day+"T") {

			continue

		}

		v := values[i]

		if !found {

			minV, maxV = v, v

			found = true

			continue

		}

		if v < minV {

			minV = v

		}

		if v > maxV {

			maxV = v

		}

	}

	if !found {

		return 0, 0

	}

	return minV, maxV

}

func timelineSummary(forecast forecastResponse, day string, loc *time.Location) []string {

	out := make([]string, 0, len(timelineHours))

	type point struct {

		time  time.Time

		temp  float64

		code  int

		valid bool

	}

	points := make([]point, 0, len(forecast.Hourly.Time))

	for i, raw := range forecast.Hourly.Time {

		if i >= len(forecast.Hourly.Temperature) || !strings.HasPrefix(raw, day+"T") {

			continue

		}

		t, err := time.ParseInLocation(localLayout, raw, loc)

		if err != nil {

			continue

		}

		code := 0

		if i < len(forecast.Hourly.WeatherCode) {

			code = forecast.Hourly.WeatherCode[i]

		}

		points = append(points, point{

			time:  t,

			temp:  forecast.Hourly.Temperature[i],

			code:  code,

			valid: true,

		})

	}

	if len(points) == 0 {

		return nil

	}

	for _, targetHour := range timelineHours {

		bestIdx := -1

		bestDelta := 24

		for i, p := range points {

			delta := p.time.Hour() - targetHour

			if delta < 0 {

				delta = -delta

			}

			if delta < bestDelta {

				bestDelta = delta

				bestIdx = i

			}

		}

		if bestIdx < 0 {

			continue

		}

		icon, text := weatherCodeLabel(points[bestIdx].code)

		out = append(out, fmt.Sprintf("%02d:00  %s  %s %s", targetHour, formatSignedTemperature(points[bestIdx].temp), icon, text))

	}

	return out

}

func weatherCodeLabel(code int) (string, string) {

	switch code {

	case 0:

		return "☀", "Clear sky"

	case 1:

		return "⛅", "Mostly clear"

	case 2:

		return "🌥", "Partly cloudy"

	case 3:

		return "☁", "Cloudy"

	case 45, 48:

		return "🌫", "Fog"

	case 51, 53, 55, 56, 57:

		return "🌦", "Drizzle"

	case 61, 63, 65, 66, 67:

		return "🌧", "Rain"

	case 71, 73, 75, 77:

		return "🌨", "Snow"

	case 80, 81, 82:

		return "🌧", "Rain showers"

	case 85, 86:

		return "🌨", "Snow showers"

	case 95, 96, 99:

		return "⛈", "Thunderstorm"

	default:

		return "🌤", "Variable clouds"

	}

}

func windDirectionFromDegrees(degrees float64) string {

	directions := []string{

		"N", "NNE", "NE", "ENE",

		"E", "ESE", "SE", "SSE",

		"S", "SSW", "SW", "WSW",

		"W", "WNW", "NW", "NNW",

	}

	normalized := math.Mod(degrees, 360)

	if normalized < 0 {

		normalized += 360

	}

	idx := int(math.Round(normalized/22.5)) % len(directions)

	return directions[idx]

}

func rainAmount(precipitationSum, rainSum, showersSum []float64) string {

	precip := firstEl(precipitationSum)

	rain := firstEl(rainSum)

	showers := firstEl(showersSum)

	low := rain

	if low <= 0 {

		low = precip

	}

	high := precip

	if showers > 0 && rain > 0 {

		high = math.Max(high, rain+showers)

	}

	if high < low {

		high = low

	}

	if high <= 0 {

		return "0 mm"

	}

	lowMM := int(math.Round(low))

	highMM := int(math.Round(high))

	if lowMM == highMM {

		return fmt.Sprintf("%d mm", highMM)

	}

	return fmt.Sprintf("%d-%d mm", lowMM, highMM)

}

func formatAirQualityLine(air airQualityResponse) string {

	if air.Current.USAQI == nil && air.Current.PM2_5 == nil && air.Current.PM10 == nil {

		return ""

	}

	parts := make([]string, 0, 4)

	if air.Current.USAQI != nil {

		aqi := int(math.Round(*air.Current.USAQI))

		parts = append(parts, fmt.Sprintf("AQI %d (%s)", aqi, usAQILevel(aqi)))

	}

	if air.Current.PM2_5 != nil {

		parts = append(parts, fmt.Sprintf("PM2.5 %.1f", *air.Current.PM2_5))

	}

	if air.Current.PM10 != nil {

		parts = append(parts, fmt.Sprintf("PM10 %.1f", *air.Current.PM10))

	}

	if air.Current.Ozone != nil {

		parts = append(parts, fmt.Sprintf("O3 %.1f", *air.Current.Ozone))

	}

	if air.Current.NitrogenDioxide != nil {

		parts = append(parts, fmt.Sprintf("NO2 %.1f", *air.Current.NitrogenDioxide))

	}

	return "🌫 Air: " + strings.Join(parts, ", ")

}

func usAQILevel(v int) string {

	switch {

	case v <= 50:

		return "Good"

	case v <= 100:

		return "Moderate"

	case v <= 150:

		return "Unhealthy for sensitive groups"

	case v <= 200:

		return "Unhealthy"

	case v <= 300:

		return "Very unhealthy"

	default:

		return "Hazardous"

	}

}

func weatherFeedID(lat, lon float64) string {

	return fmt.Sprintf("weather-lat-%s-lon-%s", normalizeCoord(lat), normalizeCoord(lon))

}

func normalizeCoord(v float64) string {

	s := strconv.FormatFloat(v, 'f', 4, 64)

	s = strings.ReplaceAll(s, "-", "m")

	return strings.ReplaceAll(s, ".", "_")

}

func formatSignedTemperature(v float64) string {

	n := int(math.Round(v))

	if n > 0 {

		return fmt.Sprintf("+%d°", n)

	}

	return fmt.Sprintf("%d°", n)

}

func formatWindLine(minWind, maxWind float64, direction string) string {

	minV := int(math.Round(minWind))

	maxV := int(math.Round(maxWind))

	if maxV < minV {

		minV, maxV = maxV, minV

	}

	if minV == maxV {

		return fmt.Sprintf("🌬 Wind: %d km/h from %s", minV, direction)

	}

	return fmt.Sprintf("🌬 Wind: %d-%d km/h from %s", minV, maxV, direction)

}

func firstEl[T comparable](values []T) T {

	if len(values) == 0 {

		var zero T

		return zero

	}

	return values[0]

}