api.go

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"sort"
	"strconv"
	"strings"
	"time"
)

// Battery holds per-battery telemetry from a single battery_N/ topic family.
type Battery struct {
	Index         int     // 1, 2, …
	Voltage       float64 // V
	Current       float64 // A
	Power         float64 // W (negative = charging)
	StateOfCharge float64 // %
	Temperature   float64 // °C (0 if not reported)
}

// Stats holds the fetched values from Solar-Assistant.
type Stats struct {
	BatterySOC            float64 // percent (pre-aggregated total across all batteries)
	BatteryPower          float64 // watts (negative = discharging)
	BatteryVoltage        float64 // volts (inverter-side bus reading)
	LoadPower             float64 // watts
	PVPower               float64 // watts
	GridPower             float64 // watts (negative = exporting)
	GridVoltage           float64 // volts (0 = power cut)
	DeviceMode            string  // e.g. "Solar", "Battery", "Grid"
	InverterTemperature   float64 // °C
	OutputSourcePriority  string
	ChargerSourcePriority string
	Batteries             []Battery // sorted by Index
}

// metric is one entry in the /api/v1/metrics JSON array.
type metric struct {
	Topic string          `json:"topic"`
	Value json.RawMessage `json:"value"`
	Unit  string          `json:"unit"`
}

// FetchStats performs a single HTTP GET against the Solar-Assistant REST API
// and returns the populated Stats.
func FetchStats(host, username, password string, timeout time.Duration) (*Stats, error) {
	body, err := httpGet(buildURL(host, "/api/v1/metrics", nil), username, password, timeout)
	if err != nil {
		return nil, err
	}

	var metrics []metric
	if err := json.Unmarshal(body, &metrics); err != nil {
		return nil, fmt.Errorf("decode: %w", err)
	}

	stats := &Stats{}
	batteries := map[int]*Battery{}

	for _, m := range metrics {
		switch m.Topic {
		case "total/battery_state_of_charge":
			stats.BatterySOC = asFloat(m.Value)
		case "total/battery_power":
			stats.BatteryPower = asFloat(m.Value)
		case "inverter_1/battery_voltage":
			stats.BatteryVoltage = asFloat(m.Value)
		case "total/load_power":
			stats.LoadPower = asFloat(m.Value)
		case "total/pv_power":
			stats.PVPower = asFloat(m.Value)
		case "total/grid_power":
			stats.GridPower = asFloat(m.Value)
		case "inverter_1/grid_voltage":
			stats.GridVoltage = asFloat(m.Value)
		case "inverter_1/device_mode":
			stats.DeviceMode = asString(m.Value)
		case "inverter_1/temperature":
			stats.InverterTemperature = asFloat(m.Value)
		case "inverter_1/output_source_priority":
			stats.OutputSourcePriority = asString(m.Value)
		case "inverter_1/charger_source_priority":
			stats.ChargerSourcePriority = asString(m.Value)
		default:
			if idx, field, ok := parseBatteryTopic(m.Topic); ok {
				b := batteries[idx]
				if b == nil {
					b = &Battery{Index: idx}
					batteries[idx] = b
				}
				switch field {
				case "voltage":
					b.Voltage = asFloat(m.Value)
				case "current":
					b.Current = asFloat(m.Value)
				case "power":
					b.Power = asFloat(m.Value)
				case "state_of_charge":
					b.StateOfCharge = asFloat(m.Value)
				case "temperature":
					b.Temperature = asFloat(m.Value)
				}
			}
		}
	}

	if len(batteries) > 0 {
		stats.Batteries = make([]Battery, 0, len(batteries))
		for _, b := range batteries {
			stats.Batteries = append(stats.Batteries, *b)
		}
		sort.Slice(stats.Batteries, func(i, j int) bool {
			return stats.Batteries[i].Index < stats.Batteries[j].Index
		})
	}

	return stats, nil
}

// WatchStats polls the REST API every interval and calls onUpdate with each
// successful snapshot. It blocks until the caller cancels the process.
// Transient fetch errors are written to stderr and do not stop the loop.
func WatchStats(host, username, password string, interval time.Duration, onUpdate func(*Stats)) error {
	// Use a per-request timeout slightly shorter than the polling interval so
	// a slow response can't stack requests.
	reqTimeout := interval
	if reqTimeout < 2*time.Second {
		reqTimeout = 2 * time.Second
	}

	fetch := func() {
		s, err := FetchStats(host, username, password, reqTimeout)
		if err != nil {
			fmt.Fprintf(stderr, "fetch error: %v\n", err)
			return
		}
		onUpdate(s)
	}

	fetch()
	ticker := time.NewTicker(interval)
	defer ticker.Stop()
	for range ticker.C {
		fetch()
	}
	return nil
}

// FetchRaw returns the raw JSON body of GET /api/v1/metrics, suitable for
// piping through jq or similar tools.
func FetchRaw(host, username, password string, timeout time.Duration) ([]byte, error) {
	return httpGet(buildURL(host, "/api/v1/metrics", nil), username, password, timeout)
}

// FetchMetric returns the plain-text value of a single metric topic via the
// /api/v1/metrics?topic=<topic>&value=1 endpoint.
func FetchMetric(host, username, password string, timeout time.Duration, topic string) (string, error) {
	q := url.Values{}
	q.Set("topic", topic)
	q.Set("value", "1")
	body, err := httpGet(buildURL(host, "/api/v1/metrics", q), username, password, timeout)
	if err != nil {
		return "", err
	}
	return strings.TrimRight(string(body), "\r\n"), nil
}

// httpGet performs an authenticated GET and returns the response body.
func httpGet(url, username, password string, timeout time.Duration) ([]byte, error) {
	req, err := http.NewRequest(http.MethodGet, url, nil)
	if err != nil {
		return nil, fmt.Errorf("build request: %w", err)
	}
	if username != "" || password != "" {
		req.SetBasicAuth(username, password)
	}

	client := &http.Client{Timeout: timeout}
	resp, err := client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("request: %w", err)
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, fmt.Errorf("read body: %w", err)
	}

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("unexpected status %s: %s", resp.Status, strings.TrimSpace(string(body)))
	}
	return body, nil
}

// buildURL constructs an http://host/path?query URL.
func buildURL(host, path string, query url.Values) string {
	u := url.URL{Scheme: "http", Host: host, Path: path}
	if len(query) > 0 {
		u.RawQuery = query.Encode()
	}
	return u.String()
}

// parseBatteryTopic returns (index, field, true) for topics like
// "battery_1/voltage", or (0, "", false) otherwise.
func parseBatteryTopic(topic string) (int, string, bool) {
	const prefix = "battery_"
	if !strings.HasPrefix(topic, prefix) {
		return 0, "", false
	}
	rest := topic[len(prefix):]
	slash := strings.IndexByte(rest, '/')
	if slash <= 0 {
		return 0, "", false
	}
	idx, err := strconv.Atoi(rest[:slash])
	if err != nil || idx < 1 {
		return 0, "", false
	}
	return idx, rest[slash+1:], true
}

// asFloat extracts a float64 from a JSON value that may be a number or a
// numeric string. Returns 0 if the value cannot be interpreted.
func asFloat(raw json.RawMessage) float64 {
	if len(raw) == 0 {
		return 0
	}
	var f float64
	if err := json.Unmarshal(raw, &f); err == nil {
		return f
	}
	var s string
	if err := json.Unmarshal(raw, &s); err == nil {
		var fs float64
		fmt.Sscanf(s, "%g", &fs)
		return fs
	}
	return 0
}

// asString extracts a string from a JSON value, tolerating non-string scalars.
func asString(raw json.RawMessage) string {
	if len(raw) == 0 {
		return ""
	}
	var s string
	if err := json.Unmarshal(raw, &s); err == nil {
		return s
	}
	return string(raw)
}