powerwatts/main.go

package main

import (
	"embed"
	"encoding/json"
	"errors"
	"fmt"
	"html/template"
	"log"
	"net/http"
	"os"
	"strconv"
	"strings"
	"sync"
	"time"
)

//go:embed static/*
var indexHTML embed.FS

type store struct {
	mu        sync.RWMutex
	value     int
	updatedAt time.Time
	history   []sample
}

const maxHistoryPoints = 10000

type sample struct {
	at    time.Time
	value int
}

func (s *store) get() int {
	s.mu.RLock()
	defer s.mu.RUnlock()
	return s.value
}

func (s *store) set(v int) {
	s.mu.Lock()
	s.value = v
	now := time.Now()
	s.updatedAt = now
	s.history = append(s.history, sample{at: now, value: v})
	s.trimHistoryLocked(now)
	s.mu.Unlock()
}

func (s *store) trimHistoryLocked(now time.Time) {
	cutoff := now.Add(-12 * time.Hour)
	keep := s.history[:0]
	for _, point := range s.history {
		if point.at.After(cutoff) {
			keep = append(keep, point)
		}
	}
	if len(keep) > maxHistoryPoints {
		keep = keep[len(keep)-maxHistoryPoints:]
	}
	s.history = keep
}

func (s *store) snapshot() (int, time.Time, []sample) {
	s.mu.RLock()
	defer s.mu.RUnlock()
	history := append([]sample(nil), s.history...)
	return s.value, s.updatedAt, history
}

func main() {
	secret := os.Getenv("WRITE_SECRET")
	addr := os.Getenv("ADDR")
	chartMax := 0
	if cfg, err := loadConfig("config.json"); err != nil {
		if !errors.Is(err, os.ErrNotExist) {
			log.Fatalf("load config: %v", err)
		}
	} else {
		if secret == "" {
			secret = cfg.WriteSecret
		}
		if addr == "" {
			addr = cfg.Addr
		}
		if cfg.ChartMaxWatts > 0 {
			chartMax = cfg.ChartMaxWatts
		}
	}
	if secret == "" {
		log.Fatal("WRITE_SECRET is required")
	}
	if addr == "" {
		addr = ":8080"
	}

	app := &server{
		secret:   secret,
		chartMax: chartMax,
		store:    &store{},
	}

	log.Printf("listening on %s", addr)
	log.Fatal(http.ListenAndServe(addr, app.routes()))
}

type server struct {
	secret   string
	chartMax int
	store    *store
}

type config struct {
	WriteSecret   string `json:"write_secret"`
	Addr          string `json:"addr"`
	ChartMaxWatts int    `json:"chart_max_watts"`
}

func loadConfig(path string) (config, error) {
	data, err := os.ReadFile(path)
	if err != nil {
		return config{}, err
	}

	var cfg config
	if err := json.Unmarshal(data, &cfg); err != nil {
		return config{}, err
	}
	return cfg, nil
}

func (s *server) routes() http.Handler {
	mux := http.NewServeMux()
	mux.HandleFunc("/", s.handleIndex)
	mux.HandleFunc("/favicon.svg", s.handleFavicon)
	mux.HandleFunc("/write", s.handleWrite)
	return mux
}

func (s *server) handleIndex(w http.ResponseWriter, r *http.Request) {
	if r.URL.Path != "/" {
		http.NotFound(w, r)
		return
	}

	page, err := template.New("index.html").ParseFS(indexHTML, "static/index.html")
	if err != nil {
		http.Error(w, "template error", http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "text/html; charset=utf-8")
	watts, updatedAt, history := s.store.snapshot()
	updatedLabel := "not updated yet"
	if !updatedAt.IsZero() {
		updatedLabel = updatedAt.Format("02.01.2006 15:04:05")
	}
	if err := page.Execute(w, map[string]any{
		"Watts":        watts,
		"UpdatedAt":    updatedLabel,
		"HistoryChart": buildHistoryChart(history, s.chartMax),
	}); err != nil {
		http.Error(w, "render error", http.StatusInternalServerError)
	}
}

func buildHistoryChart(history []sample, maxWatts int) template.HTML {
	const (
		width  = 640
		height = 220
		padL   = 72
		padR   = 18
		padT   = 18
		padB   = 42
	)

	if len(history) == 0 {
		return template.HTML(`<svg viewBox="0 0 640 220" class="chart-svg" aria-label="Power history chart" role="img"><rect x="0" y="0" width="640" height="220" rx="16" fill="#0b1220" stroke="#1e293b"/><text x="320" y="112" text-anchor="middle" fill="#64748b" font-size="16" font-family="system-ui, sans-serif">No power history yet</text></svg>`)
	}

	minV, maxV := 0, history[0].value
	if maxWatts > 0 {
		maxV = maxWatts
	}
	start := history[0].at
	end := history[len(history)-1].at
	for _, point := range history[1:] {
		if maxWatts <= 0 && point.value > maxV {
			maxV = point.value
		}
		if point.at.Before(start) {
			start = point.at
		}
		if point.at.After(end) {
			end = point.at
		}
	}
	if maxV <= 0 {
		maxV = 1
	}
	span := end.Sub(start)
	if span <= 0 {
		span = time.Minute
	}

	plotW := float64(width - padL - padR)
	plotH := float64(height - padT - padB)

	points := make([]string, 0, len(history))
	var lastX, lastY float64
	for _, point := range history {
		x := float64(padL) + plotW*point.at.Sub(start).Seconds()/span.Seconds()
		y := float64(height-padB) - plotH*(float64(point.value-minV)/float64(maxV-minV))
		if y < float64(padT) {
			y = float64(padT)
		}
		if y > float64(height-padB) {
			y = float64(height - padB)
		}
		points = append(points, fmt.Sprintf("%.1f,%.1f", x, y))
		lastX, lastY = x, y
	}

	midV := minV + (maxV-minV)/2
	midT := start.Add(span / 2)
	x0 := float64(padL)
	x1 := float64(width - padR)
	yTop := float64(padT)
	yMid := float64(padT) + plotH/2
	yBottom := float64(height - padB)

	var b strings.Builder
	b.WriteString(`<svg viewBox="0 0 640 220" class="chart-svg" aria-label="Power history chart" role="img">`)
	b.WriteString(`<rect x="0" y="0" width="640" height="220" rx="16" fill="#0b1220" stroke="#1e293b"/>`)
	b.WriteString(`<g stroke="#1e293b" stroke-width="1">`)
	fmt.Fprintf(&b, `<path d="M %.1f %.1f H %.1f"/>`, x0, yTop, x1)
	fmt.Fprintf(&b, `<path d="M %.1f %.1f H %.1f"/>`, x0, yMid, x1)
	fmt.Fprintf(&b, `<path d="M %.1f %.1f H %.1f"/>`, x0, yBottom, x1)
	fmt.Fprintf(&b, `<path d="M %.1f %.1f V %.1f"/>`, x0, yTop, yBottom)
	fmt.Fprintf(&b, `<path d="M %.1f %.1f V %.1f"/>`, x0+(plotW/2), yTop, yBottom)
	fmt.Fprintf(&b, `<path d="M %.1f %.1f V %.1f"/>`, x1, yTop, yBottom)
	b.WriteString(`</g>`)
	b.WriteString(`<g fill="#64748b" font-size="12" font-family="system-ui, sans-serif">`)
	fmt.Fprintf(&b, `<text x="%.1f" y="%d" text-anchor="end">%d W</text>`, x0-10, int(yTop)+14, maxV)
	fmt.Fprintf(&b, `<text x="%.1f" y="%d" text-anchor="end">%d W</text>`, x0-10, int(yMid)+14, midV)
	fmt.Fprintf(&b, `<text x="%.1f" y="%d" text-anchor="end">0 W</text>`, x0-10, int(yBottom)+14)
	fmt.Fprintf(&b, `<text x="%.1f" y="%d" text-anchor="middle">%s</text>`, x0, int(height)-10, start.Format("15:04"))
	fmt.Fprintf(&b, `<text x="%.1f" y="%d" text-anchor="middle">%s</text>`, x0+(plotW/2), int(height)-10, midT.Format("15:04"))
	fmt.Fprintf(&b, `<text x="%.1f" y="%d" text-anchor="middle">%s</text>`, x1, int(height)-10, end.Format("15:04"))
	b.WriteString(`</g>`)
	fmt.Fprintf(&b, `<polyline fill="none" stroke="#38bdf8" stroke-width="3" stroke-linejoin="round" stroke-linecap="round" points="%s"/>`, strings.Join(points, " "))
	fmt.Fprintf(&b, `<circle cx="%.1f" cy="%.1f" r="4" fill="#22c55e"/>`, lastX, lastY)
	b.WriteString(`</svg>`)
	return template.HTML(b.String())
}

const faviconSVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" role="img" aria-label="Power meter">
  <defs>
    <linearGradient id="g" x1="16" y1="12" x2="48" y2="52" gradientUnits="userSpaceOnUse">
      <stop offset="0" stop-color="#38bdf8"/>
      <stop offset="1" stop-color="#22c55e"/>
    </linearGradient>
  </defs>
  <rect x="10" y="14" width="44" height="36" rx="9" fill="#0f172a"/>
  <rect x="14" y="18" width="36" height="28" rx="6" fill="none" stroke="url(#g)" stroke-width="3"/>
  <path d="M32 22 L25 34 H31 L28 44 L39 30 H33 Z" fill="url(#g)"/>
  <path d="M20 50h24" stroke="#334155" stroke-width="4" stroke-linecap="round"/>
</svg>`

func (s *server) handleFavicon(w http.ResponseWriter, r *http.Request) {
	if r.URL.Path != "/favicon.svg" {
		http.NotFound(w, r)
		return
	}

	w.Header().Set("Content-Type", "image/svg+xml")
	_, _ = w.Write([]byte(faviconSVG))
}

func (s *server) handleWrite(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
		return
	}

	if got := r.Header.Get("X-Secret"); got == "" || got != s.secret {
		http.Error(w, "unauthorized", http.StatusUnauthorized)
		return
	}

	value, err := parseWatts(r)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	s.store.set(value)
	w.Header().Set("Content-Type", "application/json")
	_ = json.NewEncoder(w).Encode(map[string]any{"watts": value})
}

func parseWatts(r *http.Request) (int, error) {
	contentType := r.Header.Get("Content-Type")
	if strings.Contains(contentType, "application/json") {
		var payload struct {
			Watts *int `json:"watts"`
		}
		if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
			return 0, errors.New("invalid json")
		}
		if payload.Watts == nil {
			return 0, errors.New("missing watts")
		}
		return *payload.Watts, nil
	}

	if err := r.ParseForm(); err != nil {
		return 0, errors.New("invalid form data")
	}
	if v := r.FormValue("watts"); v != "" {
		return strconv.Atoi(v)
	}
	return 0, errors.New("missing watts")
}