server_test.go

// Copyright 2026ff novatechflow (Alexander Alten)
// SPDX-License-Identifier: PolyForm-Shield-1.0.0
package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"net/http/httptest"
	"os"
	"os/exec"
	"strings"
	"sync/atomic"
	"testing"
	"time"
)

func TestParseRetryAfter(t *testing.T) {
	cases := []struct {
		in   string
		want time.Duration
	}{
		{"", 0},
		{"30", 30 * time.Second},
		{" 5 ", 5 * time.Second},
		{"0", 0},
		{"-1", 0},
		{"garbage", 0},
		{http.TimeFormat, 0}, // unparseable as a date -> 0
	}
	for _, c := range cases {
		if got := parseRetryAfter(c.in); got != c.want {
			t.Errorf("parseRetryAfter(%q) = %v, want %v", c.in, got, c.want)
		}
	}

	// HTTP-date form: a minute out should land near a minute.
	got := parseRetryAfter(time.Now().Add(time.Minute).UTC().Format(http.TimeFormat))
	if got < 50*time.Second || got > time.Minute {
		t.Errorf("parseRetryAfter(date +1m) = %v, want ~1m", got)
	}
	// A date in the past must not produce a negative wait.
	if got := parseRetryAfter(time.Now().Add(-time.Hour).UTC().Format(http.TimeFormat)); got != 0 {
		t.Errorf("parseRetryAfter(past date) = %v, want 0", got)
	}
}

func TestPollScheduleBackoff(t *testing.T) {
	var poll pollSchedule
	now := time.Now()

	// doubles from the floor, then clamps at the ceiling
	want := []time.Duration{
		polyBackoffMin,
		2 * polyBackoffMin,
		4 * polyBackoffMin,
		8 * polyBackoffMin,
		16 * polyBackoffMin,
		polyBackoffMax,
		polyBackoffMax,
	}
	for i, w := range want {
		wait := poll.failed(now, 0)
		if poll.backoff != w {
			t.Fatalf("after %d failures: backoff = %v, want %v", i+1, poll.backoff, w)
		}
		if wait < w || wait >= w+w/10 {
			t.Fatalf("after %d failures: wait = %v, want [%v, %v)", i+1, wait, w, w+w/10)
		}
		if poll.nextAt != now.Add(wait) {
			t.Fatalf("after %d failures: nextAt = %v, want %v", i+1, poll.nextAt, now.Add(wait))
		}
	}
}

func TestPollScheduleHonoursRetryAfter(t *testing.T) {
	var poll pollSchedule
	now := time.Now()

	// Retry-After longer than our own backoff wins...
	want := polyBackoffMin + time.Minute
	if wait := poll.failed(now, want); wait != want {
		t.Errorf("wait = %v, want Retry-After %v", wait, want)
	}
	// ...and a shorter one does not shorten the backoff.
	poll = pollSchedule{}
	if wait := poll.failed(now, time.Second); wait < polyBackoffMin {
		t.Errorf("wait = %v, want at least %v", wait, polyBackoffMin)
	}
}

// End-to-end: a rate-limited data-api must not blank the dashboard, must stop
// calling until the backoff expires, and must say why in the banner.
func TestRefreshFastBacksOffAndKeepsLastPositions(t *testing.T) {
	var hits int32
	rateLimited := int32(1)
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		atomic.AddInt32(&hits, 1)
		if atomic.LoadInt32(&rateLimited) == 1 {
			w.Header().Set("Retry-After", "1")
			w.WriteHeader(http.StatusTooManyRequests)
			return
		}
		if strings.HasPrefix(r.URL.Path, "/positions") {
			w.Write([]byte(`[{"title":"Will Bitcoin win","outcome":"Yes","size":1,"currentValue":2}]`))
			return
		}
		w.Write([]byte(`[]`))
	}))
	defer srv.Close()

	origBase := polyBase
	polyBase = srv.URL
	cfg = Config{Wallet: "0xtest", CandleDays: 1, Sort: "az"} // no coins -> no market-data calls
	positionsPoll, activityPoll, pnlPoll = pollSchedule{}, pollSchedule{}, pollSchedule{}
	dataAPILastAt, polyWallet = time.Time{}, ""
	lastPositions, lastActivity = nil, nil
	t.Cleanup(func() {
		polyBase = origBase
		cfg, state = Config{}, State{}
		positionsPoll, activityPoll, pnlPoll = pollSchedule{}, pollSchedule{}, pollSchedule{}
		dataAPILastAt, polyWallet = time.Time{}, ""
		lastPositions, lastActivity = nil, nil
	})

	// First cycle succeeds: we have real positions to protect.
	atomic.StoreInt32(&rateLimited, 0)
	refreshFast()
	if len(state.Positions) != 1 || state.Note != "" {
		t.Fatalf("healthy cycle: positions=%d note=%q, want 1 and no note", len(state.Positions), state.Note)
	}

	// Now the API starts rate limiting. Force the next call to be due.
	atomic.StoreInt32(&rateLimited, 1)
	positionsPoll.nextAt = time.Time{}
	refreshFast()
	if len(state.Positions) != 1 {
		t.Errorf("after 429: positions=%d, want the last good ones kept", len(state.Positions))
	}
	if !strings.Contains(state.Note, "rate limited") {
		t.Errorf("after 429: note=%q, want a rate-limit explanation", state.Note)
	}
	if positionsPoll.backoff != polyBackoffMin {
		t.Errorf("after 429: backoff=%v, want %v", positionsPoll.backoff, polyBackoffMin)
	}

	// Subsequent cycles inside the backoff window must not touch the API.
	before := atomic.LoadInt32(&hits)
	refreshFast()
	refreshFast()
	if got := atomic.LoadInt32(&hits); got != before {
		t.Errorf("made %d calls during backoff, want 0", got-before)
	}
	if len(state.Positions) != 1 || !strings.Contains(state.Note, "rate limited") {
		t.Errorf("during backoff: positions=%d note=%q", len(state.Positions), state.Note)
	}

	// Once the window passes and the API recovers, we resume and clear the note.
	atomic.StoreInt32(&rateLimited, 0)
	positionsPoll.nextAt = time.Now().Add(-time.Second)
	refreshFast()
	if state.Note != "" || positionsPoll.backoff != 0 {
		t.Errorf("after recovery: note=%q backoff=%v, want cleared", state.Note, positionsPoll.backoff)
	}
}

func TestRefreshFastPacesActivityIndependently(t *testing.T) {
	var positionsHits, activityHits int32
	activityLimited := atomic.Bool{}
	activityLimited.Store(true)
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch r.URL.Path {
		case "/positions":
			atomic.AddInt32(&positionsHits, 1)
			w.Write([]byte(`[]`))
		case "/activity":
			atomic.AddInt32(&activityHits, 1)
			if activityLimited.Load() {
				w.WriteHeader(http.StatusTooManyRequests)
				return
			}
			w.Write([]byte(`[{"title":"filled"}]`))
		default:
			http.NotFound(w, r)
		}
	}))
	defer srv.Close()

	origBase := polyBase
	polyBase = srv.URL
	cfg = Config{Wallet: "0xtest", CandleDays: 1, Sort: "az"}
	positionsPoll, activityPoll = pollSchedule{}, pollSchedule{}
	pnlPoll = pollSchedule{nextAt: time.Now().Add(time.Hour)}
	dataAPILastAt, polyWallet = time.Time{}, "0xtest"
	lastPositions, lastActivity = nil, []Act{{Title: "cached"}}
	t.Cleanup(func() {
		polyBase = origBase
		cfg, state = Config{}, State{}
		positionsPoll, activityPoll, pnlPoll = pollSchedule{}, pollSchedule{}, pollSchedule{}
		dataAPILastAt, polyWallet = time.Time{}, ""
		lastPositions, lastActivity = nil, nil
	})

	// When both are due, positions runs first and activity is not burst behind it.
	refreshFast()
	if positionsHits != 1 || activityHits != 0 {
		t.Fatalf("startup hits: positions=%d activity=%d, want 1/0", positionsHits, activityHits)
	}

	// A rate limit applies only to activity and retains its cached value.
	positionsPoll.nextAt = time.Now().Add(time.Hour)
	activityPoll.nextAt = time.Time{}
	dataAPILastAt = time.Time{}
	refreshFast()
	if activityHits != 1 || activityPoll.backoff != polyBackoffMin {
		t.Fatalf("after activity 429: hits=%d backoff=%v", activityHits, activityPoll.backoff)
	}
	if len(state.Activity) != 1 || state.Activity[0].Title != "cached" {
		t.Fatalf("activity after 429 = %+v, want cached value", state.Activity)
	}
	if state.Note != "" {
		t.Fatalf("activity failure should not mark positions stale: note=%q", state.Note)
	}

	// It does not retry inside its own backoff, then resets after recovery.
	refreshFast()
	if activityHits != 1 {
		t.Fatalf("activity calls during backoff=%d, want 1 total", activityHits)
	}
	activityLimited.Store(false)
	activityPoll.nextAt = time.Time{}
	dataAPILastAt = time.Time{}
	refreshFast()
	if activityHits != 2 || activityPoll.backoff != 0 {
		t.Fatalf("after activity recovery: hits=%d backoff=%v", activityHits, activityPoll.backoff)
	}
	if len(state.Activity) != 1 || state.Activity[0].Title != "filled" {
		t.Fatalf("activity after recovery = %+v", state.Activity)
	}
}

func TestRefreshPnlUsesThirtyMinuteCadence(t *testing.T) {
	var hits int32
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		atomic.AddInt32(&hits, 1)
		w.Write([]byte(`[{"t":1,"p":2}]`))
	}))
	defer srv.Close()

	origBase := pnlBase
	pnlBase = srv.URL
	pnlPoll = pollSchedule{}
	pnlSeries = nil
	t.Cleanup(func() {
		pnlBase = origBase
		pnlPoll = pollSchedule{}
		pnlSeries = nil
	})

	now := time.Now()
	refreshPnl("0xtest", now)
	refreshPnl("0xtest", now.Add(time.Minute))
	if hits != 1 {
		t.Fatalf("P/L hits=%d, want 1 inside 30-minute cadence", hits)
	}
	if wait := pnlPoll.nextAt.Sub(now); wait < pnlInterval || wait >= pnlInterval+pnlInterval/10 {
		t.Fatalf("next P/L poll in %v, want [%v, %v)", wait, pnlInterval, pnlInterval+pnlInterval/10)
	}
}

func TestFetchPositionsFiltersResolvedLosses(t *testing.T) {
	cases := []struct {
		name string
		body string
		want int
	}{
		{"resolved loss", `[{"size":15,"curPrice":0,"currentValue":0,"percentPnl":-99.9991,"redeemable":true}]`, 0},
		{"unresolved zero price", `[{"curPrice":0,"redeemable":false}]`, 1},
		{"winner awaiting redemption", `[{"curPrice":1,"redeemable":true}]`, 1},
		{"missing resolution flag", `[{"curPrice":0}]`, 1},
		{"mixed positions", `[{"curPrice":0,"redeemable":true},{"curPrice":0.68,"redeemable":false},{"curPrice":1,"redeemable":true}]`, 2},
		{"empty portfolio", `[]`, 0},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				w.Write([]byte(tc.body))
			}))
			defer srv.Close()
			origBase := polyBase
			polyBase = srv.URL
			t.Cleanup(func() { polyBase = origBase })
			positions, err := fetchPositions("0xtest")
			if err != nil {
				t.Fatal(err)
			}
			if len(positions) != tc.want {
				t.Fatalf("got %d positions, want %d", len(positions), tc.want)
			}
			for _, p := range positions {
				if p.Redeemable && p.CurPrice == 0 {
					t.Error("resolved loss remains visible")
				}
			}
		})
	}
}

func TestFetchPositionsSortsByEndTime(t *testing.T) {
	// Same calendar day for noon/evening: only gamma's timestamp separates them.
	poly := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte(`[
			{"title":"later","conditionId":"0xlater","endDate":"2026-09-01","currentValue":90},
			{"title":"undated","conditionId":"0xnone","currentValue":80},
			{"title":"evening-big","conditionId":"0xeve","endDate":"2026-08-12","currentValue":70},
			{"title":"noon-small","conditionId":"0xnoon","endDate":"2026-08-12","currentValue":5}
		]`))
	}))
	defer poly.Close()

	var gammaCalls int
	gamma := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		gammaCalls++
		w.Write([]byte(`[
			{"conditionId":"0xlater","endDate":"2026-09-01T16:00:00Z"},
			{"conditionId":"0xeve","endDate":"2026-08-12T18:00:00Z"},
			{"conditionId":"0xnoon","endDate":"2026-08-12T12:00:00Z"}
		]`))
	}))
	defer gamma.Close()

	origPoly, origGamma := polyBase, gammaBase
	polyBase, gammaBase = poly.URL, gamma.URL
	marketMetadata = map[string]marketMeta{}
	t.Cleanup(func() {
		polyBase, gammaBase = origPoly, origGamma
		marketMetadata = map[string]marketMeta{}
	})

	got, err := fetchPositions("0xtest")
	if err != nil {
		t.Fatalf("fetchPositions: %v", err)
	}
	want := []string{"noon-small", "evening-big", "later", "undated"}
	for i, w := range want {
		if got[i].Title != w {
			t.Errorf("position %d = %q, want %q", i, got[i].Title, w)
		}
	}

	// Second cycle must be served from cache, including the market gamma
	// didn't know about.
	if _, err := fetchPositions("0xtest"); err != nil {
		t.Fatalf("second fetchPositions: %v", err)
	}
	if gammaCalls != 1 {
		t.Errorf("gamma calls = %d, want 1", gammaCalls)
	}
}

func TestFetchPositionsAddsBTCPriceToBeat(t *testing.T) {
	poly := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte(`[{"title":"Bitcoin Up or Down - September 12, 8:00AM-12:00PM ET","eventSlug":"btc-updown-4h-1789214400","conditionId":"0xbtc"}]`))
	}))
	defer poly.Close()

	var gammaCalls int
	gamma := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		gammaCalls++
		if gammaCalls == 1 {
			w.Write([]byte(`[{"conditionId":"0xbtc","endDate":"2026-09-12T16:00:00Z","events":[{"eventMetadata":{}}]}]`))
			return
		}
		w.Write([]byte(`[{"conditionId":"0xbtc","endDate":"2026-09-12T16:00:00Z","events":[{"eventMetadata":{"priceToBeat":77338.86223947103}}]}]`))
	}))
	defer gamma.Close()

	origPoly, origGamma := polyBase, gammaBase
	polyBase, gammaBase = poly.URL, gamma.URL
	marketMetadata = map[string]marketMeta{}
	t.Cleanup(func() {
		polyBase, gammaBase = origPoly, origGamma
		marketMetadata = map[string]marketMeta{}
	})

	first, err := fetchPositions("0xtest")
	if err != nil {
		t.Fatalf("fetchPositions: %v", err)
	}
	if first[0].PriceToBeat != nil {
		t.Fatalf("price to beat unexpectedly set before Gamma publishes it: %v", *first[0].PriceToBeat)
	}
	got, err := fetchPositions("0xtest")
	if err != nil {
		t.Fatalf("second fetchPositions: %v", err)
	}
	if len(got) != 1 || got[0].PriceToBeat == nil {
		t.Fatalf("price to beat missing from position: %+v", got)
	}
	if want := 77338.86223947103; *got[0].PriceToBeat != want {
		t.Errorf("price to beat = %v, want %v", *got[0].PriceToBeat, want)
	}
	if got[0].EndDate != "2026-09-12T16:00:00Z" {
		t.Errorf("end date = %q", got[0].EndDate)
	}
	if gammaCalls != 2 {
		t.Errorf("gamma calls = %d, want retry after missing price", gammaCalls)
	}
}

func TestFetchPositionsAddsAllUpDownMarketsPriceToBeat(t *testing.T) {
	poly := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte(`[
			{"title":"Bitcoin Up or Down - September 19, 5AM ET","eventSlug":"bitcoin-up-or-down-september-19-2026-5am-et","conditionId":"0xbtc1h"},
			{"title":"Ethereum Up or Down - September 19, 5:05AM-5:10AM ET","eventSlug":"eth-updown-5m-1789808700","conditionId":"0xeth5m"},
			{"title":"Solana Market","slug":"sol-updown-15m-1789807500","conditionId":"0xsol15m"},
			{"title":"XRP Contract","outcome":"Up","conditionId":"0xXrp"},
			{"title":"Kraken IPO by June 30, 2026?","eventSlug":"kraken-ipo-by-june-30-2026","outcome":"Yes","conditionId":"0xkraken"}
		]`))
	}))
	defer poly.Close()

	var gammaCalls int
	gamma := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		gammaCalls++
		if gammaCalls == 1 {
			// First call: metadata published without priceToBeat yet
			w.Write([]byte(`[
				{"conditionId":"0xbtc1h","endDate":"2026-09-19T10:00:00Z","events":[{"eventMetadata":{}}]},
				{"conditionId":"0xeth5m","endDate":"2026-09-19T09:10:00Z","events":[{"eventMetadata":{}}]},
				{"conditionId":"0xsol15m","endDate":"2026-09-19T09:15:00Z","events":[{"eventMetadata":{}}]},
				{"conditionId":"0xxrp","endDate":"2026-09-19T09:10:00Z","events":[{"eventMetadata":{}}]},
				{"conditionId":"0xkraken","endDate":"2026-06-30T04:00:00Z","events":[{"eventMetadata":{}}]}
			]`))
			return
		}
		// Second call: only the 4 up/down markets should be queried, NOT kraken-ipo
		w.Write([]byte(`[
			{"conditionId":"0xbtc1h","endDate":"2026-09-19T10:00:00Z","events":[{"eventMetadata":{"priceToBeat":81312.01}}]},
			{"conditionId":"0xeth5m","endDate":"2026-09-19T09:10:00Z","events":[{"eventMetadata":{"priceToBeat":2645.23}}]},
			{"conditionId":"0xsol15m","endDate":"2026-09-19T09:15:00Z","events":[{"eventMetadata":{"priceToBeat":112.27}}]},
			{"conditionId":"0xxrp","endDate":"2026-09-19T09:10:00Z","events":[{"eventMetadata":{"priceToBeat":1.415}}]}
		]`))
	}))
	defer gamma.Close()

	origPoly, origGamma := polyBase, gammaBase
	polyBase, gammaBase = poly.URL, gamma.URL
	marketMetadata = map[string]marketMeta{}
	t.Cleanup(func() {
		polyBase, gammaBase = origPoly, origGamma
		marketMetadata = map[string]marketMeta{}
	})

	first, err := fetchPositions("0xtest")
	if err != nil {
		t.Fatalf("fetchPositions: %v", err)
	}
	if len(first) != 5 {
		t.Fatalf("first positions count = %d, want 5", len(first))
	}
	for i, p := range first {
		if p.PriceToBeat != nil {
			t.Fatalf("first[%d] unexpectedly has priceToBeat: %v", i, *p.PriceToBeat)
		}
	}

	got, err := fetchPositions("0xtest")
	if err != nil {
		t.Fatalf("second fetchPositions: %v", err)
	}
	if len(got) != 5 {
		t.Fatalf("second positions count = %d, want 5", len(got))
	}

	expected := map[string]float64{
		"0xbtc1h":  81312.01,
		"0xeth5m":  2645.23,
		"0xsol15m": 112.27,
		"0xXrp":    1.415,
	}
	for _, p := range got {
		if want, ok := expected[p.ConditionID]; ok {
			if p.PriceToBeat == nil {
				t.Errorf("%s: price to beat missing", p.ConditionID)
			} else if *p.PriceToBeat != want {
				t.Errorf("%s: price to beat = %v, want %v", p.ConditionID, *p.PriceToBeat, want)
			}
		} else if p.ConditionID == "0xkraken" {
			if p.PriceToBeat != nil {
				t.Errorf("kraken position should not have price to beat: %v", *p.PriceToBeat)
			}
		}
	}

	if gammaCalls != 2 {
		t.Errorf("gamma calls = %d, want 2 (initial fetch + retry for up/down)", gammaCalls)
	}

	// Third fetch should not call Gamma again because all up/down prices are resolved
	if _, err := fetchPositions("0xtest"); err != nil {
		t.Fatalf("third fetchPositions: %v", err)
	}
	if gammaCalls != 2 {
		t.Errorf("gamma calls after 3rd fetch = %d, want still 2", gammaCalls)
	}
}

func TestMarketPairsPreserveLegacyOverride(t *testing.T) {
	if got := krakenPair(Coin{Sym: "BTC"}); got != "XBTUSD" {
		t.Errorf("kraken BTC pair = %q, want XBTUSD", got)
	}
	c := Coin{Sym: "OLD", Bn: "WIFUSDT"}
	if got := krakenPair(c); got != "WIFUSD" {
		t.Errorf("legacy Kraken pair = %q, want WIFUSD", got)
	}
	if got := coinbaseProduct(c); got != "WIF-USD" {
		t.Errorf("legacy Coinbase product = %q, want WIF-USD", got)
	}
}

func TestFetchMarketCandlesFallsBackToCoinbase(t *testing.T) {
	base := time.Now().UTC().Truncate(15 * time.Minute).Add(-2 * time.Hour).Unix()
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.URL.Path == "/0/public/OHLC":
			w.WriteHeader(http.StatusUnavailableForLegalReasons)
		case r.URL.Path == "/products/BTC-USD/candles":
			// Coinbase is newest-first: [time, low, high, open, close, volume].
			fmt.Fprintf(w, `[[%d,2,4,3,3.5,10],[%d,1,3,2,2.5,8]]`, base+900, base)
		default:
			http.NotFound(w, r)
		}
	}))
	defer srv.Close()
	origKraken, origCoinbase := krakenBase, coinbaseBase
	krakenBase, coinbaseBase = srv.URL, srv.URL
	t.Cleanup(func() { krakenBase, coinbaseBase = origKraken, origCoinbase })

	got, source, err := fetchMarketCandles(Coin{Sym: "BTC", ID: "bitcoin"}, 1)
	if err != nil {
		t.Fatal(err)
	}
	if source != "coinbase" {
		t.Errorf("source = %q, want coinbase", source)
	}
	if len(got) != 2 || got[0] != (Candle{float64(base) * 1000, 2, 3, 1, 2.5}) || got[1][0] != float64(base+900)*1000 {
		t.Errorf("normalized Coinbase candles = %#v", got)
	}
}

func TestFetchKrakenCandlesNormalizesAndSorts(t *testing.T) {
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte(`{"error":[],"result":{"BTC/USD":[[200,"3","4","2","3.5","0",1,1],[100,"2","3","1","2.5","0",1,1]],"last":200}}`))
	}))
	defer srv.Close()
	orig := krakenBase
	krakenBase = srv.URL
	t.Cleanup(func() { krakenBase = orig })

	got, err := fetchKrakenCandles(Coin{Sym: "BTC"}, 1)
	if err != nil {
		t.Fatal(err)
	}
	if len(got) != 2 || got[0] != (Candle{100000, 2, 3, 1, 2.5}) || got[1][0] != 200000 {
		t.Errorf("normalized Kraken candles = %#v", got)
	}
}

func TestFetchKrakenPricesBatchesPairs(t *testing.T) {
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		pairs := r.URL.Query().Get("pair")
		if !strings.Contains(pairs, "XBTUSD") || !strings.Contains(pairs, "ETHUSD") {
			t.Errorf("pair query = %q", pairs)
		}
		w.Write([]byte(`{"error":[],"result":{"BTC/USD":{"c":["100.5","1"]},"ETH/USD":{"c":["20.25","1"]}}}`))
	}))
	defer srv.Close()
	orig := krakenBase
	krakenBase = srv.URL
	t.Cleanup(func() { krakenBase = orig })

	got, err := fetchKrakenPrices([]Coin{{Sym: "BTC", ID: "bitcoin"}, {Sym: "ETH", ID: "ethereum"}})
	if err != nil {
		t.Fatal(err)
	}
	if got["bitcoin"] != 100.5 || got["ethereum"] != 20.25 {
		t.Errorf("prices = %#v", got)
	}
}

func TestRefreshFastUsesCoinbaseAndKeepsLastPrice(t *testing.T) {
	var krakenOK, coinbaseOK atomic.Bool
	krakenOK.Store(true)
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch r.URL.Path {
		case "/0/public/Ticker":
			if !krakenOK.Load() {
				w.WriteHeader(http.StatusUnavailableForLegalReasons)
				return
			}
			w.Write([]byte(`{"error":[],"result":{"BTC/USD":{"c":["100","1"]}}}`))
		case "/products/BTC-USD/ticker":
			if !coinbaseOK.Load() {
				w.WriteHeader(http.StatusServiceUnavailable)
				return
			}
			w.Write([]byte(`{"price":"101"}`))
		default:
			http.NotFound(w, r)
		}
	}))
	defer srv.Close()

	origKraken, origCoinbase := krakenBase, coinbaseBase
	krakenBase, coinbaseBase = srv.URL, srv.URL
	cfg = Config{CandleDays: 1, Sort: "az", Coins: []Coin{{Sym: "BTC", ID: "bitcoin"}}}
	marketPrice = map[string]float64{}
	t.Cleanup(func() {
		krakenBase, coinbaseBase = origKraken, origCoinbase
		cfg, state = Config{}, State{}
		marketPrice = map[string]float64{}
	})

	refreshFast()
	if got := state.Coins[0].Price; got != 100 {
		t.Fatalf("Kraken price = %v, want 100", got)
	}

	krakenOK.Store(false)
	coinbaseOK.Store(true)
	refreshFast()
	if got := state.Coins[0].Price; got != 101 {
		t.Fatalf("Coinbase fallback price = %v, want 101", got)
	}

	coinbaseOK.Store(false)
	refreshFast()
	if got := state.Coins[0].Price; got != 101 {
		t.Fatalf("price after both providers fail = %v, want last good 101", got)
	}
}

func TestCandleChange24(t *testing.T) {
	got := candleChange24(110, []Candle{{0, 100, 0, 0, 0}})
	if got < 9.999 || got > 10.001 {
		t.Errorf("change = %v, want 10%%", got)
	}
}

func TestShortURLDropsWallet(t *testing.T) {
	in := "https://data-api.polymarket.com/positions?user=0xdeadbeef&limit=100"
	if got := shortURL(in); got != "data-api.polymarket.com/positions" {
		t.Errorf("shortURL = %q, want the host+path with no query", got)
	}
}

func TestDefaultConfigHasNoWallet(t *testing.T) {
	if got := defaultConfig().Wallet; got != "" {
		t.Errorf("default wallet = %q, want empty", got)
	}
}

func TestEmbeddedServerVersion(t *testing.T) {
	version, err := os.ReadFile("VERSION")
	if err != nil {
		t.Fatal(err)
	}
	if got, want := strings.TrimSpace(serverVersion), strings.TrimSpace(string(version)); got == "" || got != want {
		t.Fatalf("server version = %q, want %q", got, want)
	}
	b, err := os.ReadFile("index.html")
	if err != nil {
		t.Fatal(err)
	}
	html := string(b)
	if strings.Contains(html, `id="appVer">v`) {
		t.Error("client version is hard-coded instead of coming from server state")
	}
}

func TestEnvExampleIsPolymarketCore(t *testing.T) {
	b, err := os.ReadFile(".env.example")
	if err != nil {
		t.Fatal(err)
	}
	var raw string
	for _, line := range strings.Split(string(b), "\n") {
		line = strings.TrimSpace(line)
		if strings.HasPrefix(line, "POLYDISPLAY_ASSETS=") {
			raw = strings.Trim(strings.TrimPrefix(line, "POLYDISPLAY_ASSETS="), `"'`)
			break
		}
	}
	if raw == "" {
		t.Fatal(".env.example missing POLYDISPLAY_ASSETS")
	}
	got := parseAssets(raw)
	want := []string{"BTC", "ETH", "SOL", "XRP"}
	if len(got) != len(want) {
		t.Fatalf("example assets=%d (%v), want the 4 Polymarket names %v", len(got), got, want)
	}
	for i, sym := range want {
		if got[i].Sym != sym {
			t.Errorf("example[%d]=%q, want %q", i, got[i].Sym, sym)
		}
		if got[i].ID == "" {
			t.Errorf("example[%d] %s missing coingecko id", i, sym)
		}
	}
}

func TestDefaultConfigHasNoCoins(t *testing.T) {
	if n := len(defaultConfig().Coins); n != 0 {
		t.Errorf("default coins=%d, want none (list comes from POLYDISPLAY_ASSETS)", n)
	}
}

func TestParseAssets(t *testing.T) {
	got := parseAssets("BTC:Bitcoin:bitcoin, ETH:ethereum, TRUMP:Official Trump:official-trump, WIF:dogwifhat:dogwifcoin:WIFUSDT, skipme, :noid")
	want := []Coin{
		{Sym: "BTC", Name: "Bitcoin", ID: "bitcoin"},
		{Sym: "ETH", Name: "ETH", ID: "ethereum"},
		{Sym: "TRUMP", Name: "Official Trump", ID: "official-trump"},
		{Sym: "WIF", Name: "dogwifhat", ID: "dogwifcoin", Bn: "WIFUSDT"},
	}
	if len(got) != len(want) {
		t.Fatalf("len=%d, want %d: %+v", len(got), len(want), got)
	}
	for i := range want {
		if got[i] != want[i] {
			t.Errorf("[%d]=%+v, want %+v", i, got[i], want[i])
		}
	}
}

func TestListenPort(t *testing.T) {
	t.Setenv("POLYDISPLAY_PORT", "")
	if p := listenPort(0); p != 8080 {
		t.Errorf("empty env, no file: %d, want 8080", p)
	}
	if p := listenPort(9090); p != 9090 {
		t.Errorf("empty env, file 9090: %d", p)
	}
	t.Setenv("POLYDISPLAY_PORT", "3000")
	if p := listenPort(9090); p != 3000 {
		t.Errorf("env 3000 should win over file, got %d", p)
	}
	t.Setenv("POLYDISPLAY_PORT", "nope")
	if p := listenPort(0); p != 8080 {
		t.Errorf("bad env: %d, want 8080", p)
	}
}

func TestCoinsFromEnv(t *testing.T) {
	t.Setenv("POLYDISPLAY_ASSETS", "SOL:Solana:solana,XRP:XRP:ripple")
	got := coinsFromEnv()
	if len(got) != 2 || got[0].Sym != "SOL" || got[1].ID != "ripple" {
		t.Fatalf("coinsFromEnv=%+v", got)
	}
}

func TestLoadEnvFileDoesNotOverride(t *testing.T) {
	dir := t.TempDir()
	path := dir + "/.env"
	if err := os.WriteFile(path, []byte("POLYDISPLAY_ASSETS=BTC:bitcoin\nCG_DEMO_KEY=fromfile\n"), 0644); err != nil {
		t.Fatal(err)
	}
	t.Setenv("CG_DEMO_KEY", "fromproc")
	t.Setenv("POLYDISPLAY_ASSETS", "")
	loadEnvFile(path)
	if os.Getenv("CG_DEMO_KEY") != "fromproc" {
		t.Errorf("CG_DEMO_KEY=%q, want process env to win", os.Getenv("CG_DEMO_KEY"))
	}
	if os.Getenv("POLYDISPLAY_ASSETS") != "BTC:bitcoin" {
		t.Errorf("POLYDISPLAY_ASSETS=%q, want value from file", os.Getenv("POLYDISPLAY_ASSETS"))
	}
}

func TestRefreshFastSkipsPolymarketWithoutWallet(t *testing.T) {
	var hits int32
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		atomic.AddInt32(&hits, 1)
		t.Errorf("unexpected call %s", r.URL.Path)
	}))
	defer srv.Close()

	origBase := polyBase
	polyBase = srv.URL
	cfg = Config{Wallet: "  ", CandleDays: 1, Sort: "az"}
	positionsPoll, activityPoll, pnlPoll = pollSchedule{}, pollSchedule{}, pollSchedule{}
	dataAPILastAt, polyWallet = time.Time{}, "stale"
	lastPositions = []Position{{Title: "leftover"}}
	lastActivity = []Act{{Title: "leftover"}}
	t.Cleanup(func() {
		polyBase = origBase
		cfg, state = Config{}, State{}
		positionsPoll, activityPoll, pnlPoll = pollSchedule{}, pollSchedule{}, pollSchedule{}
		dataAPILastAt, polyWallet = time.Time{}, ""
		lastPositions, lastActivity = nil, nil
	})

	refreshFast()
	if atomic.LoadInt32(&hits) != 0 {
		t.Errorf("called Polymarket %d times with no wallet, want 0", hits)
	}
	if len(state.Positions) != 0 || len(state.Activity) != 0 {
		t.Errorf("positions=%d activity=%d, want both empty", len(state.Positions), len(state.Activity))
	}
	if state.Wallet != "" || state.Note != "" {
		t.Errorf("wallet=%q note=%q, want both empty", state.Wallet, state.Note)
	}
	if want := strings.TrimSpace(serverVersion); state.Version != want {
		t.Errorf("state version=%q, want %q", state.Version, want)
	}
}

func binaryLicenseSkip(path string) bool {
	i := strings.LastIndex(path, ".")
	if i < 0 {
		return false
	}
	switch strings.ToLower(path[i+1:]) {
	case "png", "jpg", "jpeg", "gif", "webp", "ico":
		return true
	default:
		return false
	}
}

func TestLicenseHeaders(t *testing.T) {
	out, err := exec.Command("git", "ls-files").Output()
	if err != nil {
		t.Fatal(err)
	}
	plain := "Copyright 2026ff novatechflow (Alexander Alten)"
	linked := "Copyright 2026ff [novatechflow](https://www.novatechflow.com) (Alexander Alten)"
	for _, path := range strings.Split(strings.TrimSpace(string(out)), "\n") {
		if path == "" {
			continue
		}
		if path == "VERSION" { // machine-readable metadata, not source text
			continue
		}
		b, err := os.ReadFile(path)
		if err != nil {
			t.Errorf("%s: %v", path, err)
			continue
		}
		if binaryLicenseSkip(path) {
			continue
		}
		s := string(b)
		if !strings.Contains(s, plain) && !strings.Contains(s, linked) {
			t.Errorf("%s: missing copyright notice", path)
		}
	}
}

func TestInstallScriptSyntax(t *testing.T) {
	for _, sh := range []string{"install.sh"} {
		out, err := exec.Command("bash", "-n", sh).CombinedOutput()
		if err != nil {
			t.Errorf("%s: bash -n: %v\n%s", sh, err, out)
		}
	}
	b, err := os.ReadFile("install.sh")
	if err != nil {
		t.Fatal(err)
	}
	s := string(b)
	for _, want := range []string{
		"POLYMARKET_WALLET",
		"darwin) install_macos",
		"linux) install_linux",
		"https://go.dev/dl/",
		".env.example",
		"POLYDISPLAY_ASSETS",
		"POLYDISPLAY_PIN",
		"POLYDISPLAY_TOKEN_SECRET",
		"POLYDISPLAY_EXTRA_ASSETS",
		"api.coingecko.com/api/v3/search",
		"Kraken",
		"Coinbase",
	} {
		if !strings.Contains(s, want) {
			t.Errorf("install.sh missing %q", want)
		}
	}
	if strings.Contains(s, "install_windows") {
		t.Error("install.sh should not install a Windows service")
	}
	if strings.Contains(s, "api.binance.com") {
		t.Error("install.sh must not probe the geo-blocked Binance API")
	}
}

func TestLiveConfigIsGitignored(t *testing.T) {
	out, err := exec.Command("git", "check-ignore", "-v", "config.json").Output()
	if err != nil {
		t.Fatalf("config.json must be gitignored: %v", err)
	}
	if !strings.Contains(string(out), "config.json") {
		t.Errorf("check-ignore: %s", out)
	}
	if _, err := exec.Command("git", "ls-files", "--error-unmatch", "config.json").Output(); err == nil {
		t.Error("config.json is tracked; it must not be")
	}
}

func TestAutoThemeFollowsColorScheme(t *testing.T) {
	b, err := os.ReadFile("index.html")
	if err != nil {
		t.Fatal(err)
	}
	s := string(b)
	if !strings.Contains(s, "prefers-color-scheme:light") && !strings.Contains(s, "prefers-color-scheme: light") {
		t.Error("index.html missing prefers-color-scheme light palette")
	}
	if !strings.Contains(s, "--bg:#0b0e13") {
		t.Error("dark default palette missing")
	}
	if !strings.Contains(s, `col=up?"var(--green)":"var(--red)"`) {
		t.Error("candles must use theme variables, not hardcoded colors")
	}
}

func TestWebManifestContentType(t *testing.T) {
	srv := httptest.NewServer(staticHandler())
	defer srv.Close()
	resp, err := http.Get(srv.URL + "/manifest.webmanifest")
	if err != nil {
		t.Fatal(err)
	}
	defer resp.Body.Close()
	if resp.StatusCode != 200 {
		t.Fatalf("status %d", resp.StatusCode)
	}
	ct := resp.Header.Get("Content-Type")
	if !strings.HasPrefix(ct, "application/manifest+json") {
		t.Errorf("Content-Type=%q, want application/manifest+json", ct)
	}
}

func TestPadWebAppIcons(t *testing.T) {
	b, err := os.ReadFile("manifest.webmanifest")
	if err != nil {
		t.Fatal(err)
	}
	s := string(b)
	for _, want := range []string{"/media/icon-192.png", "/media/icon-512.png", `"purpose": "any"`} {
		if !strings.Contains(s, want) {
			t.Errorf("manifest.webmanifest missing %q", want)
		}
	}
	if strings.Contains(s, "maskable") {
		t.Error("do not pre-mask icons; the pad rounds a full-bleed square")
	}
	html, err := os.ReadFile("index.html")
	if err != nil {
		t.Fatal(err)
	}
	h := string(html)
	if !strings.Contains(h, `rel="apple-touch-icon"`) || !strings.Contains(h, "/media/icon-180.png") {
		t.Error("index.html missing apple-touch-icon 180")
	}
	if !strings.Contains(h, `rel="manifest"`) || !strings.Contains(h, "/manifest.webmanifest") {
		t.Error("index.html missing web app manifest link")
	}
	for _, p := range []string{"media/icon-180.png", "media/icon-192.png", "media/icon-512.png"} {
		if _, err := os.Stat(p); err != nil {
			t.Errorf("%s: %v", p, err)
		}
	}
}

func TestNoAppCacheManifest(t *testing.T) {
	b, err := os.ReadFile("index.html")
	if err != nil {
		t.Fatal(err)
	}
	if strings.Contains(string(b), `manifest=`) {
		t.Error("index.html must not set an AppCache manifest")
	}
	if _, err := os.Stat("polydisplay.appcache"); err == nil {
		t.Error("must not ship an .appcache file")
	}
}

func TestIndexExplainsMissingWallet(t *testing.T) {
	b, err := os.ReadFile("index.html")
	if err != nil {
		t.Fatal(err)
	}
	s := string(b)
	if !strings.Contains(s, "No Polymarket wallet") {
		t.Error("index.html missing the no-wallet empty state")
	}
	if !strings.Contains(s, "paste an address") {
		t.Error("index.html missing how to add a wallet")
	}
}

func TestPnlTodayUsesTwoDecimals(t *testing.T) {
	b, err := os.ReadFile("index.html")
	if err != nil {
		t.Fatal(err)
	}
	s := string(b)
	if !strings.Contains(s, `minimumFractionDigits:2,maximumFractionDigits:2`) {
		t.Error("index.html missing fixed two-decimal currency formatter")
	}
	if !strings.Contains(s, `var day=(p.d1==null)?"&mdash;":fmtSignedUsd2(p.d1)`) {
		t.Error("P/L today must use the fixed two-decimal formatter")
	}
}

func TestIndexShowsPriceToBeatWhenAvailable(t *testing.T) {
	b, err := os.ReadFile("index.html")
	if err != nil {
		t.Fatal(err)
	}
	s := string(b)
	if !strings.Contains(s, `p.priceToBeat!=null&&+p.priceToBeat>0`) {
		t.Error("price to beat must only render for a positive API value")
	}
	if !strings.Contains(s, `price to beat</span><span>'+fmtUsd2(+p.priceToBeat)`) {
		t.Error("position card missing formatted price to beat")
	}
}

func TestIndexShowsTimeToResolutionWhenAvailable(t *testing.T) {
	b, err := os.ReadFile("index.html")
	if err != nil {
		t.Fatal(err)
	}
	s := string(b)
	if !strings.Contains(s, `time to resolution</span>`) {
		t.Error("position card missing time to resolution row")
	}
	if !strings.Contains(s, `fmtResolution(p.endDate)`) {
		t.Error("position card missing fmtResolution call for endDate")
	}
	if !strings.Contains(s, `function fmtResolution(endStr)`) {
		t.Error("index.html missing fmtResolution function")
	}
}

func hourly(vals ...float64) [][2]float64 {
	now := float64(time.Now().Unix())
	out := make([][2]float64, len(vals))
	for i, v := range vals {
		out[i] = [2]float64{now - float64(len(vals)-1-i)*3600, v}
	}
	return out
}

func TestPnlDeltaMatchesPolymarketAnchor(t *testing.T) {
	// polymarket.com's 1D series is 24 hourly points spanning 23h, so the day's
	// P/L is measured against the point 24 samples back.
	series := hourly(10, 12, 20, 25)
	d := pnlDelta(series, 3)
	if d == nil {
		t.Fatal("3-sample delta over a 4-point series must resolve")
	}
	if *d != 13 { // 25 - 12
		t.Errorf("3-sample delta = %v, want 13", *d)
	}
	if pnlDelta(series, 24) != nil {
		t.Error("day delta over a 4-point series must be nil, not the all-time change")
	}
}

func TestPnlDeltaSpansExactSeries(t *testing.T) {
	// what the feed returns for 30d: exactly 720 hourly points
	vals := make([]float64, 720)
	for i := range vals {
		vals[i] = float64(i)
	}
	d := pnlDelta(hourly(vals...), 720)
	if d == nil || *d != 719 {
		t.Errorf("30d delta = %v, want the whole series span (719)", d)
	}
}

func TestThinKeepsEnds(t *testing.T) {
	in := hourly(make([]float64, 500)...)
	for i := range in {
		in[i][1] = float64(i)
	}
	out := thin(in, 120)
	if len(out) != 120 {
		t.Fatalf("thin returned %d points, want 120", len(out))
	}
	if out[0] != in[0] || out[len(out)-1] != in[len(in)-1] {
		t.Error("thin must keep the first and last point")
	}
	if got := thin(in[:50], 120); len(got) != 50 {
		t.Errorf("thin shortened a series below the cap: %d", len(got))
	}
}

func TestBuildPnlUsesSeriesEnd(t *testing.T) {
	p := buildPnl(hourly(1, 2, 3))
	if p == nil {
		t.Fatal("buildPnl returned nil for a non-empty series")
	}
	if p.Total != 3 {
		t.Errorf("Total = %v, want the last series point (3)", p.Total)
	}
	if buildPnl(nil) != nil {
		t.Error("buildPnl must return nil without a series")
	}
}

func TestCoinbasePagesAndMatchesKrakenIntervals(t *testing.T) {
	for _, days := range []int{1, 7, 14, 30} {
		t.Run(fmt.Sprint(days), func(t *testing.T) {
			calls := 0
			srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				calls++
				from, err := time.Parse(time.RFC3339, r.URL.Query().Get("start"))
				if err != nil {
					t.Error(err)
				}
				to, err := time.Parse(time.RFC3339, r.URL.Query().Get("end"))
				if err != nil {
					t.Error(err)
				}
				gran, _ := candleParams(days, "coinbase")
				if to.Sub(from) > 299*time.Duration(gran)*time.Second {
					t.Error("page exceeds inclusive candle cap")
				}
				var rows [][]float64
				for ts := from.Unix(); ts <= to.Unix(); ts += int64(gran) {
					rows = append(rows, []float64{float64(ts), 1, 4, 2, 3, 10})
				}
				json.NewEncoder(w).Encode(rows)
			}))
			defer srv.Close()
			orig := coinbaseBase
			coinbaseBase = srv.URL
			defer func() { coinbaseBase = orig }()
			got, err := fetchCoinbaseCandles(Coin{Sym: "BTC"}, days)
			if err != nil {
				t.Fatal(err)
			}
			interval, limit := candleParams(days, "kraken")
			if len(got) != limit {
				t.Fatalf("got %d candles, want %d", len(got), limit)
			}
			for i, c := range got {
				if int64(c[0])%int64(interval*60000) != 0 {
					t.Error("unaligned bucket")
				}
				if i > 0 && c[0]-got[i-1][0] != float64(interval*60000) {
					t.Error("gap or duplicate across pages")
				}
				if c[1] != 2 || c[2] != 4 || c[3] != 1 || c[4] != 3 {
					t.Errorf("OHLC changed: %v", c)
				}
			}
			wantCalls := 1
			if days == 14 {
				wantCalls = 2
			}
			if days == 30 {
				wantCalls = 3
			}
			if calls != wantCalls {
				t.Errorf("calls=%d want %d", calls, wantCalls)
			}
		})
	}
}

func TestAggregateCandlesPreservesOHLCAndRejectsMissingHour(t *testing.T) {
	in := []Candle{{10800000, 13, 16, 12, 15}, {0, 10, 12, 9, 11}, {3600000, 11, 14, 10, 13}, {7200000, 13, 15, 11, 13},
		{3600000, 11, 14, 10, 13}, // overlapping page
		{14400000, 15, 18, 14, 17}, {21600000, 17, 20, 16, 19}, {25200000, 19, 21, 18, 20}}
	got := aggregateCandles(in, 3600, 14400, time.Unix(28800, 0))
	if len(got) != 1 || got[0] != (Candle{0, 10, 16, 9, 15}) {
		t.Fatalf("aggregate=%v", got)
	}
	// Keep an unfinished bucket for drawing; the frontend excludes it from analysis.
	got = aggregateCandles([]Candle{{28800000, 20, 22, 19, 21}}, 3600, 14400, time.Unix(30000, 0))
	if len(got) != 1 {
		t.Fatal("current bucket lost")
	}
}

func TestSelectedProvidersDoNotFallBack(t *testing.T) {
	for _, provider := range []string{"kraken", "coinbase", "binance"} {
		t.Run(provider, func(t *testing.T) {
			calls := 0
			srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				calls++
				expected := map[string]string{"kraken": "/0/public/OHLC", "coinbase": "/products/BTC-USD/candles", "binance": "/api/v3/klines"}[provider]
				if r.URL.Path != expected {
					t.Errorf("unexpected fallback: %s", r.URL.Path)
				}
				w.WriteHeader(http.StatusUnavailableForLegalReasons)
			}))
			defer srv.Close()
			k, c, b := krakenBase, coinbaseBase, binanceBase
			krakenBase, coinbaseBase, binanceBase = srv.URL, srv.URL, srv.URL
			defer func() { krakenBase, coinbaseBase, binanceBase = k, c, b }()
			_, source, err := fetchSelectedCandles(Coin{Sym: "BTC"}, 30, provider)
			if err == nil || source != provider || calls != 1 {
				t.Fatalf("source=%s error=%v calls=%d", source, err, calls)
			}
		})
	}
}

func TestBinanceCandleIntervalsAndNormalization(t *testing.T) {
	for _, days := range []int{1, 7, 14, 30} {
		t.Run(fmt.Sprint(days), func(t *testing.T) {
			srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				expected := map[int]string{1: "15m", 7: "1h", 14: "4h", 30: "4h"}[days]
				_, limit := candleParams(days, "kraken")
				if r.URL.Query().Get("symbol") != "BTCUSDT" || r.URL.Query().Get("interval") != expected || r.URL.Query().Get("limit") != fmt.Sprint(limit) {
					t.Errorf("query=%s", r.URL.RawQuery)
				}
				w.Write([]byte(`[[2000,"3","4","2","3.5"],[1000,"2","3","1","2.5"]]`))
			}))
			defer srv.Close()
			orig := binanceBase
			binanceBase = srv.URL
			defer func() { binanceBase = orig }()
			got, source, err := fetchSelectedCandles(Coin{Sym: "BTC"}, days, "binance")
			if err != nil || source != "binance" || len(got) != 2 || got[0] != (Candle{1000, 2, 3, 1, 2.5}) {
				t.Fatalf("%s %v %v", source, got, err)
			}
		})
	}
}

func TestRefreshFastHonorsSelectedPriceProvider(t *testing.T) {
	for _, provider := range []string{"kraken", "coinbase", "binance"} {
		t.Run(provider, func(t *testing.T) {
			srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				expected := map[string]string{"kraken": "/0/public/Ticker", "coinbase": "/products/BTC-USD/ticker", "binance": "/api/v3/ticker/price"}[provider]
				if r.URL.Path != expected {
					t.Errorf("wrong provider: %s", r.URL.Path)
				}
				if provider == "kraken" {
					w.Write([]byte(`{"error":[],"result":{"BTC/USD":{"c":["123"]}}}`))
				} else {
					w.Write([]byte(`{"price":"123"}`))
				}
			}))
			defer srv.Close()
			k, c, b := krakenBase, coinbaseBase, binanceBase
			origCfg, origState, origPrices := cfg, state, marketPrice
			krakenBase, coinbaseBase, binanceBase = srv.URL, srv.URL, srv.URL
			cfg = Config{MarketProvider: provider, CandleDays: 1, Coins: []Coin{{Sym: "BTC", ID: "bitcoin"}}}
			marketPrice = map[string]float64{}
			defer func() {
				krakenBase, coinbaseBase, binanceBase = k, c, b
				cfg, state, marketPrice = origCfg, origState, origPrices
			}()
			refreshFast()
			if len(state.Coins) != 1 || state.Coins[0].Price != 123 {
				t.Fatalf("state=%v", state.Coins)
			}
		})
	}
}

func TestProviderConfigValidatesPersistsAndClearsCache(t *testing.T) {
	t.Chdir(t.TempDir())
	origCfg, origState, rev := cfg, state, configRevision
	origCandles, orig24, origSource, origPrices, origErrors, origUpdated := candles, cand24, csource, marketPrice, candleErrors, candleUpdated
	defer func() {
		cfg, state, configRevision = origCfg, origState, rev
		candles, cand24, csource, marketPrice, candleErrors, candleUpdated = origCandles, orig24, origSource, origPrices, origErrors, origUpdated
	}()
	cfg = defaultConfig()
	for _, body := range []string{`{"marketProvider":"invalid"}`, `{"candleDays":2}`} {
		w := httptest.NewRecorder()
		handleConfig(w, httptest.NewRequest("POST", "/api/config", strings.NewReader(body)))
		if w.Code != 400 || configRevision != rev {
			t.Fatalf("invalid config changed state: %d", w.Code)
		}
	}
	for _, provider := range []string{"kraken", "binance", "coinbase", "auto"} {
		state.Coins = []CoinState{{Sym: "BTC"}}
		candles = map[string][]Candle{"bitcoin": {{0, 1, 2, 1, 1}}}
		w := httptest.NewRecorder()
		handleConfig(w, httptest.NewRequest("POST", "/api/config", strings.NewReader(fmt.Sprintf(`{"marketProvider":%q,"candleDays":30}`, provider))))
		if w.Code != 200 || cfg.MarketProvider != provider || len(candles) != 0 || len(state.Coins) != 0 {
			t.Fatalf("provider switch failed: %d %v", w.Code, cfg)
		}
		saved := loadConfig()
		if saved.MarketProvider != provider || saved.CandleDays != 30 {
			t.Errorf("persisted=%v", saved)
		}
	}
}

func TestRefreshSlowDiscardsResultsAfterProviderChange(t *testing.T) {
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		mu.Lock()
		cfg.MarketProvider = "coinbase"
		configRevision++
		mu.Unlock()
		w.Write([]byte(`{"error":[],"result":{"BTC/USD":[[100,"2","3","1","2.5"]],"last":100}}`))
	}))
	defer srv.Close()
	origK, origCfg, rev, origCandles := krakenBase, cfg, configRevision, candles
	krakenBase = srv.URL
	cfg = Config{MarketProvider: "kraken", CandleDays: 1, Coins: []Coin{{Sym: "BTC", ID: "bitcoin"}}}
	candles = map[string][]Candle{}
	defer func() { krakenBase, cfg, configRevision, candles = origK, origCfg, rev, origCandles }()
	refreshSlow()
	if len(candles) != 0 {
		t.Fatal("previous provider results repopulated cleared cache")
	}
}